Scene.h

#pragma once
#include <GL/glew.h>
#include <GL/GL.h>
#include "SkydomeMie.h"
#include "SkydomeHimmel.h"

#include "Fog.h"

#include <osg/Matrix>
#include <osg/MatrixTransform>
#include <osg/Node>
#include <osg/Geometry>
#include <osg/Program>
#include <osg/Geode>
#include <osg/Texture2D>
#include <osg/Image>
#include <osg/BlendFunc>
#include <osg/CullFace>
#include <osgDB/ReadFile>
#include <osg/NodeVisitor>
#include <osg/Texture2D>
#include <osgDB/ReadFile>
#include <osgViewer/Renderer>

#include <osg/Texture2D>
#include <osg/Texture3D>

//#define CREATE_BOUNDINGBOX
#define SHADOW_MAPPING

namespace osgCloudyDay
{
        class Scene
        {
        public:
                Scene(int width, int height);

                ~Scene(void);

                static void CreateViewCamera();
                static void CreateLightCamera();        
                static void CreateViewDepthCamera();

                static osg::Matrix& GetViewMatrix_View();
                static osg::Matrix& GetProjectionMatrix_View();
                static osg::Matrix& GetProjectionMatrix_Light();

                static osg::ref_ptr<osg::Camera> GetLightCamera();
                static osg::ref_ptr<osg::Camera> GetViewCamera();
                static osg::ref_ptr<osg::Camera> GetViewCamera2();      
                static osg::ref_ptr<osg::Camera> GetViewDepthCamera();  

                static void SetLightCamera(osg::ref_ptr<osg::Camera> c);
                static void SetViewCamera(osg::ref_ptr<osg::Camera> c);                                 

                static osg::ref_ptr<osg::Program> GetShadowProgram();
                static osg::ref_ptr<osg::Program> GetShadingProgram();
                static osg::ref_ptr<osg::Program> GetDebugProgram();

                static int GetWidth();
                static int GetHeight();         

                static osg::ref_ptr<osg::Texture2D> GetShadowTexture(); //SHADOW

                static osg::ref_ptr<osg::Texture2D> GetShadowDepthTexture();    //DEPTH SHADOW
                static osg::ref_ptr<osg::Texture2D> GetSceneDepthTexture();     //DEPTH SCENE
                static osg::ref_ptr<osg::Texture2D> GetSceneTexture();  //SCENE TEXTURE
                
                static osg::ref_ptr<osg::Texture2D> GetGoodRayTexture();                //GOOD RAYS HELEPR TEXTURE              
                static osg::ref_ptr<osg::Texture2D> GetHUDTexture();    //HUD TEXTURE                   
                static osg::ref_ptr<osg::Texture2D> GetBlurTexture();                   

                
                static osgCloudyDay::Skydome* m_skydome;                        
                static osg::FrameBufferObject* fbo_vert_linear_blur2;
                static osg::FrameBufferObject* fbo_hori_linear_blur2;
                static osg::FrameBufferObject* fbo_scene_viewer;

        protected:              
                static osg::ref_ptr<osg::Texture2D> fbo_light_texture2; //SHADOW
                static osg::ref_ptr<osg::Texture2D> fbo_goodrays;               //GOOD RAYS HELEPR TEXTURE
                static osg::ref_ptr<osg::Texture2D> fbo_scene_depth;    //DEPTH SCENE
                static osg::ref_ptr<osg::Texture2D> fbo_scene_texture;  //SCENE TEXTURE
                static osg::ref_ptr<osg::Texture2D> fbo_hud_texture;    //HUD TEXTURE                   
                static osg::ref_ptr<osg::Texture2D> fbo_blur_texture;   
                static osg::ref_ptr<osg::Texture2D> fbo_light_depth;    //DEPTH SHADOW

                static int m_width;
                static int m_height;

                static osg::ref_ptr<osg::Program> shadowProg;
                static osg::ref_ptr<osg::Program> lightningProg;
                static osg::ref_ptr<osg::Program> debugProg;

                static osg::ref_ptr<osg::Camera> m_ViewCameraDepthOnly; 
                static osg::ref_ptr<osg::Camera> m_ViewCamera;  
                static osg::ref_ptr<osg::Camera> m_LightCamera; 
                static osg::ref_ptr<osg::Camera> m_ViewDepthCamera;                     
        };

        class CullCallBackViewCamera3 : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera3(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                //std::cerr << "DrawLightMatrix" << std::endl;          
                Scene::GetViewCamera()->setViewMatrix(Scene::GetViewDepthCamera()->getViewMatrix());
                Scene::GetViewCamera()->setProjectionMatrix(Scene::GetViewDepthCamera()->getProjectionMatrix());

                traverse(node, nv);
                
                //Scene::GetViewCamera()->setViewMatrix(Scene::GetViewDepthCamera()->getViewMatrix());
                //Scene::GetViewCamera()->setProjectionMatrix(Scene::GetViewDepthCamera()->getProjectionMatrix());
        }

};
        class CullCallBackViewCamera2 : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera2(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
        //      std::cerr << "DepthViewMatrix" << std::endl;

                osg::Vec3 e;
                osg::Vec3 c;
                osg::Vec3 u;
                Scene::GetViewDepthCamera()->getViewMatrixAsLookAt(e,c,u);
        //      std::cerr << "1eye: " << e.x() << " " << e.y() << " " << e.z() << std::endl;

                Scene::GetViewCamera2()->setViewMatrix(Scene::GetViewDepthCamera()->getViewMatrix());
                Scene::GetViewCamera2()->setProjectionMatrix(Scene::GetViewDepthCamera()->getProjectionMatrix());
                Scene::GetViewCamera()->setViewMatrix(Scene::GetViewDepthCamera()->getViewMatrix());
                Scene::GetViewCamera()->setProjectionMatrix(Scene::GetViewDepthCamera()->getProjectionMatrix());
                traverse(node, nv);
        }

};
        class CullCallBackViewCamera5 : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera5(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                //std::cerr << "ViewMatrix Cull only Depth" << std::endl;               
                osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);                     
                cv->getCurrentCamera()->setViewMatrix(Scene::GetViewMatrix_View());

                traverse(node, nv);
        }
};
        class CullCallBackViewCamera6 : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera6(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                //std::cerr << "ViewMatrix Cull Color" << std::endl;            
                osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);                     
                cv->getCurrentCamera()->setViewMatrix(Scene::GetViewMatrix_View());
                traverse(node, nv);
        }
};
        class CullCallBackViewCamera4 : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera4(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                //std::cerr << "DepthMatrix" << std::endl;                      
                traverse(node, nv);
        }
};
        class CullCallBackViewCamera : public osg::NodeCallback
{
        public:
        CullCallBackViewCamera(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
        //      std::cerr << "ViewMatrix" << std::endl;         
                traverse(node, nv);
        }
};

        class ViewerLightTerrainCallback : public osg::NodeCallback
{
public:
        ViewerLightTerrainCallback(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);        
                osg::ref_ptr<osg::Geode> geometry = dynamic_cast<osg::Geode*> (node);

                if(geometry && cv)
                {
                        //std::cerr << "TERRAIN" << std::endl;
                        osg::Vec3f eye = osg::Vec3f();
                        osg::Vec3f center = osg::Vec3f();
                        osg::Vec3f up = osg::Vec3f();
                        Scene::GetLightCamera()->getViewMatrixAsLookAt(eye, center, up);

                        //std::cout << "Eye: " << eye.x() << " " << eye.y() << " " << eye.z() << std::endl;
                        //std::cout << "Center: " << center.x() << " " << center.y() << " " << center.z() << std::endl;

                        
                        osg::Matrixd view(cv->getCurrentCamera()->getViewMatrix());
                        osg::Matrixd invViewMatrix = osg::Matrixd::inverse(view);
                        osg::Matrixd modelview(*cv->getModelViewMatrix());
                        osg::Matrixd model = modelview*invViewMatrix;
                        osg::Matrixd proj(cv->getCurrentCamera()->getProjectionMatrix());
                
                        geometry->getOrCreateStateSet()->getUniform("ModelMatrix")->set(model);
                        geometry->getOrCreateStateSet()->getUniform("ViewMatrix")->set(Scene::GetViewMatrix_View());
                        geometry->getOrCreateStateSet()->getUniform("ProjectionMatrix")->set(Scene::GetProjectionMatrix_View());                

#ifdef SHADOW_MAPPING
                        geometry->getOrCreateStateSet()->getUniform("light_proj_matrix")->set(Scene::GetProjectionMatrix_Light());
                        geometry->getOrCreateStateSet()->getUniform("light_mv_matrix")->set(Scene::GetLightCamera()->getViewMatrix());
#endif
                }
                traverse(node, nv);
        }
};

        class ViewerLightCallback : public osg::NodeCallback
{
public:
        ViewerLightCallback(void)
        {

        }

        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
        {
                osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(nv);        
                osg::ref_ptr<osg::Geode> geometry = dynamic_cast<osg::Geode*> (node);

                if(geometry && cv)
                {
                        osg::Matrixd view(cv->getCurrentCamera()->getViewMatrix());
                        osg::Matrixd invViewMatrix = osg::Matrixd::inverse(view);
                        osg::Matrixd modelview(*cv->getModelViewMatrix());
                        osg::Matrixd model = modelview*invViewMatrix;
                        osg::Matrixd proj(cv->getCurrentCamera()->getProjectionMatrix());
                
                        geometry->getOrCreateStateSet()->getUniform("ModelMatrix")->set(model);
                        geometry->getOrCreateStateSet()->getUniform("ViewMatrix")->set(Scene::GetViewMatrix_View());
                        geometry->getOrCreateStateSet()->getUniform("ProjectionMatrix")->set(Scene::GetProjectionMatrix_View());                

                        //geometry->getOrCreateStateSet()->getUniform("light_mv_matrix")->set(Scene::GetViewMatrix_Light());            
                        //geometry->getOrCreateStateSet()->getUniform("light_proj_matrix")->set(Scene::GetProjectionMatrix_Light());            
                        
                        //geometry->getOrCreateStateSet()->getUniform("ViewMatrix")->set(Scene::GetViewMatrix_View());
                        //geometry->getOrCreateStateSet()->getUniform("ViewMatrix")->set(camera_plane_cubemap[0]->getViewMatrix());                     
                        //geometry->getOrCreateStateSet()->getUniform("ProjectionMatrix")->set(Scene::GetProjectionMatrix_View());                                      
                        
                        /*
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("v3LightPos", Scene::m_skydome->GetLightPosition()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("v3InvWavelength", osg::Vec3(1.f/powf(Scene::m_skydome->GetInverseWaveLength().x(), 4.f), 1.f/powf(Scene::m_skydome->GetInverseWaveLength().y(), 4.f), 1.f/powf(Scene::m_skydome->GetInverseWaveLength().z(), 4.f))));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fOuterRadius", Scene::m_skydome->GetOtherRadius()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fOuterRadius2", powf(Scene::m_skydome->GetOtherRadius(),2.f)));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fInnerRadius", Scene::m_skydome->GetInnerRadius()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fInnerRadius2", powf(Scene::m_skydome->GetInnerRadius(),2.f)));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fKrESun", Scene::m_skydome->GetKr()*Scene::m_skydome->GetESun()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fKmESun", Scene::m_skydome->GetKm()*Scene::m_skydome->GetESun()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fKr4PI", Scene::m_skydome->GetKr()*4.f*(float)PI));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fKm4PI", Scene::m_skydome->GetKm()*4.f*(float)PI));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fScale", 1.f / (Scene::m_skydome->GetOtherRadius() - Scene::m_skydome->GetInnerRadius())));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fScaleDepth", Scene::m_skydome->GetRayleighScaleDepth()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("fScaleOverScaleDepth", (1.f / (Scene::m_skydome->GetOtherRadius() - Scene::m_skydome->GetInnerRadius())) / Scene::m_skydome->GetRayleighScaleDepth()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("g", Scene::m_skydome->GetG()));
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("g2", (powf(Scene::m_skydome->GetG(),2.f))));
                        
                        geometry->getOrCreateStateSet()->addUniform(new osg::Uniform("color_tex", 0));  */

                        
                        //std::cerr << "SCENE" << std::endl;                    

                        //std::cout << "ath callback" << std::endl;

#ifdef SHADOW_MAPPING
                        geometry->getOrCreateStateSet()->getUniform("light_proj_matrix")->set(Scene::GetProjectionMatrix_Light());
                        geometry->getOrCreateStateSet()->getUniform("light_mv_matrix")->set(Scene::GetLightCamera()->getViewMatrix());
#endif
                }
                traverse(node, nv);
        }
};
}