shape.h

Go to the documentation of this file.

#ifndef SHAPE_INCLUDED
#define SHAPE_INCLUDED
#include <vector>
#include <stdexcept>
#include <string>
#include <functional>
#include <atomic>
#include <Util/geometry.h>
#include <Util/factory.h>
#include <GL/glew.h>
#pragma warning( disable : 4290 )
#ifdef __APPLE__
#include <GLUT/glut.h>
#else // !__APPLE__
#include <GL/glut.h>
#endif // __APPLE__
#include <Util/exceptions.h>
#include "GLSLProgram.h"
 
#ifdef VERBOSE_MESSAGING
inline void AssertOpenGLState( std::string fileName , int line , std::string functionName )
{
    GLenum errorCode;
    if( ( errorCode=glGetError() )!=GL_NO_ERROR )
    {
        std::cerr << Util::MakeMessageString( "[OPEN_GL ERROR]" , fileName , line , functionName , gluErrorString( errorCode ) , " (" , errorCode , ")" ) << std::endl;
        exit( 0 );
    }
}
#ifndef ASSERT_OPEN_GL_STATE
#define ASSERT_OPEN_GL_STATE( ... ) AssertOpenGLState( __FILE__ , __LINE__ , __FUNCTION__ )
#endif // ASSERT_OPEN_GL_STATE
#else // !VERBOSE_MESSAGING
inline void AssertOpenGLState( std::string functionName )
{
    GLenum errorCode;
    if( ( errorCode=glGetError() )!=GL_NO_ERROR )
    {
        std::cerr << Util::MakeMessageString( "[OPEN_GL ERROR]" , functionName , gluErrorString( errorCode ) , " (" , errorCode , ")" ) << std::endl;
        exit( 0 );
    }
}
inline void AssertOpenGLState( std::string functionName ) {…}
#ifndef ASSERT_OPEN_GL_STATE
#define ASSERT_OPEN_GL_STATE( ... ) AssertOpenGLState( __FUNCTION__ )
#endif // ASSERT_OPEN_GL_STATE
#endif // VERBOSE_MESSAGING
 
 
namespace Ray
{
    /*** This is a simple class defining globally accessible variables. (Feel free to add more as needed.) */
    struct GlobalProperties
    {
        static bool DebugFlag;
    };
    struct GlobalProperties {…};
 
    struct RayTracingStats
    {
        static std::atomic< size_t > _RayNum;
        static std::atomic< size_t > _RayPrimitiveIntersectionNum;
        static std::atomic< size_t > _RayBoundingBoxIntersectionNum;
        static std::atomic< size_t > _ConeBoundingBoxIntersectionNum;
    public:
 
        static void Reset( void );
        static void IncrementRayNum( unsigned int count=1 );
        static void IncrementRayPrimitiveIntersectionNum( unsigned int count=1 );
        static void IncrementRayBoundingBoxIntersectionNum( unsigned int count=1 );
        static void IncrementConeBoundingBoxIntersectionNum( unsigned int count=1 );
        static size_t RayNum( void );
        static size_t RayPrimitiveIntersectionNum( void );
        static size_t RayBoundingBoxIntersectionNum( void );
        static size_t ConeBoundingBoxIntersectionNum( void );
    };
    struct RayTracingStats {…};
 
    struct ShapeBoundingBox : public Util::BoundingBox3D
    {
        ShapeBoundingBox( void ) : Util::BoundingBox3D() {};
        ShapeBoundingBox( const ShapeBoundingBox &bBox ) : Util::BoundingBox3D( bBox ) {}
        ShapeBoundingBox( const Util::BoundingBox3D &bBox ) : Util::BoundingBox3D( bBox ) {}
        ShapeBoundingBox &operator = ( const ShapeBoundingBox &bBox ){ Util::BoundingBox3D::operator = ( bBox ) ; return *this; }
        ShapeBoundingBox &operator = ( const Util::BoundingBox3D &bBox ){ Util::BoundingBox3D::operator = ( bBox ) ; return *this; }
        Util::BoundingBox1D intersect( const Util::Ray3D &ray ) const;
    };
    struct ShapeBoundingBox : public Util::BoundingBox3D {…};
 
    class Shape
    {
        friend std::ostream &operator << ( std::ostream & , const Shape & );
        friend std::istream &operator >> ( std::istream & ,       Shape & );
 
        virtual void _write( std::ostream &stream ) const = 0;
 
        virtual void _read( std::istream &stream ) = 0;
    protected:
        ShapeBoundingBox _bBox;
 
        size_t _primitiveNum;
 
    public:
        static unsigned int OpenGLTessellationComplexity;
 
        static unsigned int WriteInsetSize;
 
        static void WriteInset( std::ostream &stream );
 
        virtual ~Shape( void ){}
 
        ShapeBoundingBox boundingBox( void ) const;
 
        virtual void init( const class LocalSceneData& data ) = 0;
 
        virtual void initOpenGL( void ) = 0;
 
        virtual void updateBoundingBox( void ) = 0;
 
        virtual std::string name( void ) const = 0;
 
        virtual bool isInside( Util::Point3D p ) const = 0;
 
        virtual void drawOpenGL( GLSLProgram *glslProgram ) const=0;
 
        virtual void addTrianglesOpenGL( std::vector< class TriangleIndex > &triangles ) {}
 
        size_t primitiveNum( void ) const;
 
        struct ShapeProcessingInfo
        {
            ShapeProcessingInfo( void );
            Util::Matrix4D localToGlobal , globalToLocal;
            Util::Matrix3D directionGlobalToLocal , normalLocalToGlobal;
            const class Material *material;
 
            enum ProcessingType
            {
                NONE ,
                PROPAGATE ,
                TERMINATE
            };
            enum ProcessingType {…};
        };
        struct ShapeProcessingInfo {…};
 
        typedef std::function< ShapeProcessingInfo::ProcessingType ( const ShapeProcessingInfo & , const Shape & ) > Filter;
        typedef std::function< void ( const ShapeProcessingInfo & , const Shape & ) > Kernel;
        typedef std::function< bool ( double ) > RayIntersectionFilter;
        typedef std::function< bool ( const ShapeProcessingInfo & , const class RayShapeIntersectionInfo & ) > RayIntersectionKernel;
 
        virtual void processOverlapping( const Filter &filter , const Kernel &kernel , ShapeProcessingInfo spInfo ) const;
 
        virtual bool processFirstIntersection( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const = 0;
 
        virtual int processAllIntersections( const Util::Ray3D &ray , const Util::BoundingBox1D &range , const RayIntersectionFilter &rFilter , const RayIntersectionKernel &rKernel , ShapeProcessingInfo spInfo , unsigned int tIdx ) const = 0;
    };
    class Shape {…};
 
    inline std::ostream &operator << ( std::ostream &stream , const Shape &shape ){ shape._write( stream ) ; return stream; }
 
    inline std::istream &operator >> ( std::istream &stream ,       Shape &shape ){ shape._read( stream ) ; return stream; }
}
#endif // SHAPE_INCLUDED