include/VR3Scene.h

Go to the documentation of this file.

// Copyright (C) 2010  Daniele Giannetti
//
// This file is part of VR3Lib.
// The VR3Lib is free software, but is distributed in the static precompiled 
// version as it is NOT open source. The VR3Lib may be used in any virtual 
// reality application free of charge, but it must be clearly stated that this 
// library is used in the application EULA and distribution license 
// (for both free and proprietary applications).

#ifndef __VR3SCENE_H__
#define __VR3SCENE_H__

// these includes must always precede the VR3Scene.h include
#include <VR3Camera.h>
#include <VR3light.h>
#include <VR3FBO.h>
#include <VR3Background.h>


struct VR3SceneShaderParams {
    GLfloat projmat[16];
    GLfloat viewmat[16];

    GLfloat projviewmat[16];
    // orthogonal projection matrix updated at each Begin()..End() block
    GLfloat orthoprojmat[16];

    GLfloat camerapos[3];
    GLint numactivelights;
    GLfloat lightambient[VR3SC_NUM_LIGHTS*3];
    GLfloat lightdiffuse[VR3SC_NUM_LIGHTS*3];
    GLfloat lightspecular[VR3SC_NUM_LIGHTS*3];
    GLfloat lightpos[VR3SC_NUM_LIGHTS*3];
};


class VR3Scene {

    static VR3Scene* ms_activescene;

    bool m_beginendblock;
    long m_time;
    long m_starttime;
    long m_framecounter;
    int m_polycounter;
    


    VR3Camera m_cameras[VR3SC_NUM_CAMERAS];
    VR3Camera* m_current_camera;
    VR3Light m_lights[VR3SC_NUM_LIGHTS];

    bool m_face_culling;
    bool m_vf_culling;
    VR3Background m_background;
    int m_polygons;




    GLint m_env_mode;
    VR3Texture* m_env_specular;
    VR3Texture* m_env_diffuse;




    GLsizei m_totdrawregion[2];
    GLint m_minframetime;
    GLfloat m_framerate;


    VR3SceneShaderParams m_shadparams;

    VR3Scene(const VR3Scene&);
    VR3Scene& operator = (const VR3Scene&);




    void RealBegin( GLsizei width, GLsizei height, 
                    VR3Camera* cam, int flags );


// ------------------- Shader Parameters Update Functions --------------------//




    void UpdateLightParams();


    void UpdateMatrices(GLsizei width, GLsizei height);

public:


    void StoreUniforms(GLsizei width, GLsizei height);


// ------------------------ Active Scene Management --------------------------//


    static VR3Scene* GetActiveScene() { return ms_activescene; }

// ---------------------- Constructor and Destructor -------------------------//




    VR3Scene( GLsizei width, GLsizei height, GLfloat fovy, 
              GLfloat znear = VR3SC_DEF_ZNEAR, 
              GLfloat zfar = VR3SC_DEF_ZFAR );


    ~VR3Scene();


//---------------------- Get and Set Scene parameters ------------------------//




    void SetClearColor(GLfloat r, GLfloat g, GLfloat b);


    void SetClearColor(const GLfloat* color);


    VR3Camera* GetCurrentCamera() { return m_current_camera; }


    void SetActiveCamera(int id);


    void SetLightPosition(int id, GLfloat x, GLfloat y, GLfloat z);


    void SetLightPosition(int id, const GLfloat *v);


    void GetLightPosition(int id, GLfloat *p);


    void SetLightColor( int id, int color, 
                        GLfloat r, GLfloat g, GLfloat b );


    void GetLightColor( int id, int color, GLfloat* c);


    GLint GetActiveLights(bool* fa);


    void SetBackground(const char* file_name, bool fl_skybox = false)
        { m_background.SetBackground(file_name, fl_skybox); }


    VR3Texture* GetBackground() 
        { return m_background.GetBackground(); }


    void EnvironmentMapping(const char* diff_file, const char* spec_file);


    VR3Texture* GetEnvMap(GLint map);


    GLint GetEnvMappingMode()
        { return m_env_mode; }


    void SetFrameRate(GLfloat fps);


    GLfloat GetFrameRate() { return m_framerate; }


    GLint GetNumPolys() { return m_polygons; }


    void AddPolys(GLint polys) { m_polycounter += polys; }


    bool HasBegun() { return m_beginendblock; }

//---------------------- Enable and Disable Components -----------------------//




    void Enable(int feature, int optional_param = 0);


    void Disable(int feature, int optional_param = 0);


    bool IsEnabled(int feature, int optional_param = 0);


    bool CheckVFCulling()
        { return m_vf_culling; }
 

//------------------------- Visualization Functions --------------------------//




    void UpdateDrawRegion(GLsizei w, GLsizei h);


//------------------- Scene Properties Discovery Function --------------------//




    const VR3SceneShaderParams* FetchParameters()
        { return &m_shadparams; }


//------------------- Rendering Begin and End Functions ----------------------//




    void Begin( VR3Camera* cam = 0, int flags = 0 );


    void BeginAbs( GLint x, GLint y, GLsizei w, GLsizei h, 
                   VR3Camera* cam = 0, int flags = 0 );


    void BeginRel( GLfloat x, GLfloat y, GLfloat w, GLfloat h,
                   VR3Camera* cam = 0, int flags = 0 );


    void BeginFBO( VR3FBO* fbo, VR3Camera* cam = 0, int flags = 0 );


    void End();


};

#endif