scene.h

Go to the documentation of this file.

#ifndef SCENE_INCLUDED
#define SCENE_INCLUDED
#include <unordered_map>
#include <vector>
#include <Util/geometry.h>
#include <Image/image.h>
#include "shape.h"
#include "light.h"
#include "shapeList.h"
#include "keyFrames.h"
#include "camera.h"
 
namespace Ray
{
    class Material;
    class Texture;
    class File;
    class KeyFrameFile;
    class Shader;
    class Vertex;
 
    std::string ReadDirective( std::istream &stream );
 
    void UnreadDirective( std::istream &stream , const std::string &directive );
 
    Shape *ReadShape( std::istream &stream , const std::unordered_map< std::string , Util::BaseFactory< Shape > * > &shapeFactories );
 
    class GlobalSceneData
    {
    public:
        Camera camera;
 
        std::vector< Light * > lights;
 
        Shader *shader;
 
        GlobalSceneData( void );
 
        ~GlobalSceneData( void );
 
        static std::unordered_map< std::string , Util::BaseFactory< Light > * > LightFactories;
    };
 
    std::ostream &operator << ( std::ostream &stream , const GlobalSceneData &data );
 
    std::istream &operator >> ( std::istream &stream ,       GlobalSceneData &data );
 
    class LocalSceneData
    {
    public:
        std::vector< Vertex > vertices;
 
        std::vector< Material > materials;
 
        std::vector< Texture > textures;
 
        std::vector< File > files;
 
        KeyFrameFile *keyFrameFile;
 
        template< typename ParameterType >
        void setKeyFrameEvaluator( void );
 
        void setCurrentTime( double t , int curveFit );
 
        LocalSceneData( void );
 
        ~LocalSceneData( void );
    };
 
    std::ostream &operator << ( std::ostream &stream , const LocalSceneData &data );
 
    std::istream &operator >> ( std::istream &stream ,       LocalSceneData &data );
 
    class SceneGeometry : public Shape
    {
        LocalSceneData _localData;
 
        ShapeList _shapeList;
 
    public:
        void init( void );
 
        template< typename ParameterType >
        void setKeyFrameEvaluator( void );
 
        void setCurrentTime( double t , int curveFit );
 
        // Shape methods //
    private:
        void _write( std::ostream &stream ) const;
        void _read( std::istream &stream );
    public:
        std::string name( void ) const { return "scene geometry"; }
        void init( const LocalSceneData &sceneData );
        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;
    };
 
    class Scene : public SceneGeometry
    {
        friend class Window;
        friend class FileInstance;
        friend std::ostream &operator << ( std::ostream & , const Scene & );
        friend std::istream &operator >> ( std::istream & ,       Scene & );
 
        GlobalSceneData _globalData;
 
    public:
        static std::string BaseDir;
 
        static Util::Point3D Reflect( Util::Point3D v , Util::Point3D n );
 
        static bool Refract( Util::Point3D v , Util::Point3D n , double ir , Util::Point3D& refract );
 
        Util::Point3D getColor( Util::Ray3D ray , int rDepth , Util::Point3D cLimit , unsigned int lightSamples , unsigned int tIdx );
 
        Image::Image32 rayTrace( int width , int height , int rLimit , double cLimit , unsigned int lightSamples , bool showProgress );
 
        void initOpenGL( void );
 
        void drawOpenGL( void ) 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;
    };
 
    std::ostream &operator << ( std::ostream &stream , const Scene &scene );
 
    std::istream &operator >> ( std::istream &stream ,       Scene &scene );
 
    class File : public SceneGeometry
    {
        friend std::istream &operator >> ( std::istream & , File & );
        friend class FileInstance;
        friend class Scene;
    public:
        std::string filename;
    };
 
    std::ostream &operator << ( std::ostream &stream , const File &file );
 
    std::istream &operator >> ( std::istream &stream ,       File &file );
 
    class Vertex
    {
    public:
        Util::Point3D position;
 
        Util::Point3D normal;
 
        Util::Point2D texCoordinate;
    };
 
    std::ostream &operator << ( std::ostream &stream , const Vertex &vertex );
 
    std::istream &operator >> ( std::istream &stream ,       Vertex &vertex );
 
    class RayShapeIntersectionInfo
    {
    public:
        RayShapeIntersectionInfo( void );
 
        double t;
 
        Util::Point3D position;
 
        Util::Point3D normal;
 
        Util::Point2D texture;
 
        bool operator < ( const RayShapeIntersectionInfo &iInfo ) const;
 
        bool operator < ( double t ) const;
    };
 
    class Material
    {
        friend SceneGeometry;
        friend Scene;
        friend class File;
        friend std::ostream &operator << ( std::ostream & , const Material & );
        friend std::istream &operator >> ( std::istream & ,       Material & );
        friend std::istream &operator >> ( std::istream & ,       Scene & );
 
        int _texIndex;
    public:
        Util::Point3D ambient;
 
        Util::Point3D diffuse;
 
        Util::Point3D specular;
 
        Util::Point3D emissive;
 
        Util::Point3D transparent;
 
        double specularFallOff;
 
        double ir;
 
        const Texture *tex;
 
        std::string foo;
 
        Material( void );
 
        void drawOpenGL( GLSLProgram * glslProgram ) const;
    };
 
    std::ostream &operator << ( std::ostream &stream , const Material &material );
 
    std::istream &operator >> ( std::istream &stream ,       Material &material );
 
    class Texture
    {
        friend Scene;
        friend Material;
        friend std::ostream &operator << ( std::ostream & , const Texture & );
        friend std::istream &operator >> ( std::istream & ,       Texture & );
 
        std::string _filename;
 
        Image::Image32 _image;
 
        GLuint _openGLHandle;
    public:
        void initOpenGL( void );
    };
 
    std::ostream &operator << ( std::ostream &stream , const Texture &texture );
 
    std::istream &operator >> ( std::istream &stream ,       Texture &texture );
 
    class Shader
    {
    public:
        std::string vertexShaderFilename;
 
        std::string fragmentShaderFilename;
 
        GLSLProgram *glslProgram;
 
        Shader( void );
 
        ~Shader( void );
    };
 
    std::ostream &operator << ( std::ostream &stream , const Shader &shader );
 
    std::istream &operator >> ( std::istream &stream ,       Shader &shader );
 
    class KeyFrameFile
    {
    public:
        std::string filename;
 
        KeyFrameMatrices keyFrameMatrices;
    };
 
    std::ostream &operator << ( std::ostream &stream , const KeyFrameFile &keyFrameFile );
 
    std::istream &operator >> ( std::istream &stream ,       KeyFrameFile &keyFrameFile );
}
 
#include "scene.inl"
#endif // SCENE_INCLUDED