shapeList.h

Go to the documentation of this file.

#ifndef GROUP_INCLUDED
#define GROUP_INCLUDED
#include <vector>
#include <unordered_map>
#include <Util/geometry.h>
#include "shape.h"
 
namespace Ray
{
    class AffineShape : public Shape
    {
    protected:
        Shape *_shape;
    public:
        AffineShape( void );
 
        virtual Util::Matrix4D getMatrix( void ) const = 0;
 
        virtual Util::Matrix4D getInverseMatrix( void ) const = 0;
 
        virtual Util::Matrix3D getNormalMatrix( void ) const = 0;
 
        // Shape methods //
    public:
        void initOpenGL( void );
        void updateBoundingBox( void );
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        void processOverlapping( const Filter &filter , const Kernel &kernel , ShapeProcessingInfo tInfo ) const;
        virtual bool isInside( Util::Point3D p ) const;
        virtual void drawOpenGL( GLSLProgram *glslProgram ) const;
    };
    class AffineShape : public Shape {…};
 
 
    class StaticAffineShape : public AffineShape
    {
        Util::Matrix4D _localTransform;
 
        Util::Matrix4D _inverseTransform;
 
        Util::Matrix3D _normalTransform;
    public:
        static std::string Directive( void ){ return "static_affine"; }
 
        StaticAffineShape( void );
 
        void set( Util::Matrix4D m );
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "static affine"; }
        void init( const class LocalSceneData &data );
        void initOpenGL( void );
 
        // AffineShape methods //
    public:
        Util::Matrix4D getMatrix( void ) const;
        Util::Matrix4D getInverseMatrix( void ) const;
        Util::Matrix3D getNormalMatrix( void ) const;
    };
    class StaticAffineShape : public AffineShape {…};
 
    class DynamicAffineShape : public AffineShape
    {
        std::string _paramName;
 
        const Util::Matrix4D *_matrix;
    public:
 
        DynamicAffineShape( void );
 
        static std::string Directive( void ){ return "dynamic_affine"; }
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "dynamic affine"; }
        void init( const class LocalSceneData &data );
 
        // AffineShape methods //
    public:
        Util::Matrix4D getMatrix( void ) const;
        Util::Matrix4D getInverseMatrix( void ) const;
        Util::Matrix3D getNormalMatrix( void ) const;
    };
    class DynamicAffineShape : public AffineShape {…};
 
    class Difference : public Shape
    {
        Shape *_shape0 , *_shape1;
 
    public:
        Difference( Shape *shape0=NULL , Shape *shape1=NULL );
 
        static std::string Directive( void ){ return "shape_difference"; }
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "difference"; }
        void init( const class LocalSceneData& data );
        void initOpenGL( void );
        void updateBoundingBox( void );
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        bool isInside( Util::Point3D p ) const;
        void drawOpenGL( GLSLProgram *glslProgram ) const;
        size_t primitiveNum( void ) const;
    };
    class Difference : public Shape {…};
 
    class ShapeBoundingBoxHit
    {
    public:
        double t;
 
        const Shape *shape;
 
        static bool Compare( const ShapeBoundingBoxHit &v1 , const ShapeBoundingBoxHit &v2 );
    };
    class ShapeBoundingBoxHit {…};
 
    class ShapeList : public Shape
    {
        friend class Union;
        friend class Intersection;
 
        static std::string _DirectiveHeader( void ){ return "shape_list"; }
    public:
 
        static std::unordered_map< std::string , Util::BaseFactory< Shape > * > ShapeFactories;
 
        static std::string Directive( void ){ return _DirectiveHeader() + std::string( "_begin" ); }
 
        std::vector< Shape* > shapes;
 
        // Shape methods //
    protected:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "shape list"; }
        void init( const class LocalSceneData &data );
        void initOpenGL( void );
        void updateBoundingBox( void );
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        void processOverlapping( const Filter &filter , const Kernel &kernel , ShapeProcessingInfo tInfo ) const;
        bool isInside( Util::Point3D p ) const;
        void drawOpenGL( GLSLProgram * glslProgram ) const;
        void addTrianglesOpenGL( std::vector< class TriangleIndex >& triangles );
    };
    class ShapeList : public Shape {…};
 
    class TriangleList : public ShapeList
    {
        friend class Scene;
 
        GLuint _vertexBufferID = 0;
 
        GLuint _elementBufferID = 0;
 
        unsigned int _tNum;
 
        unsigned int _vNum;
 
        const class Vertex *_vertices;
 
        int _materialIndex;
 
        const class Material *_material;
    public:
        static std::string Directive( void ){ return "shape_triangles"; }
 
        TriangleList( void );
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "triangles"; }
        void init( const class LocalSceneData &data );
        void initOpenGL( void );
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        void processOverlapping( const Filter &filter , const Kernel &kernel , ShapeProcessingInfo tInfo ) const;
        void drawOpenGL( GLSLProgram * glslProgram ) const;
    };
    class TriangleList : public ShapeList {…};
 
    class Union : public Shape
    {
        ShapeList _shapeList;
    public:
        static std::string Directive( void ){ return "shape_union"; }
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "union"; }
        void init( const class LocalSceneData &data );
        void initOpenGL( void );
        void updateBoundingBox( void );
        bool isInside( Util::Point3D p ) const;
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        void drawOpenGL( GLSLProgram * glslProgram ) const;
    };
    class Union : public Shape {…};
 
 
    class Intersection : public Shape
    {
        ShapeList _shapeList;
 
    public:
        static std::string Directive( void ){ return "shape_intersection"; }
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "intersection"; }
        void init( const class LocalSceneData &data );
        void initOpenGL( void );
        void updateBoundingBox( void );
        bool isInside( Util::Point3D p ) const;
        bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const;
        void drawOpenGL( GLSLProgram * glslProgram ) const;
    };
    class Intersection : public Shape {…};
}
#endif // GROUP_INCLUDED