CloudScene.h

#pragma once
#include "CloudGeometry.h"
#include "CloudLayerUpdate.h"

#include "Skydome.h"
#include "Fog.h"
#include "WangCloud.h"
#include "CloudLayerUpdate.h"
#include "CloudLayerState.h"

#define SHADOW_MAPPING

namespace osgCloudyDay
{
        class project : public osg::Uniform::Callback
        {
        public:
                project() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetProjectionMatrix_View() );}
        };
        class viewMatrix : public osg::Uniform::Callback
        {
        public:
                viewMatrix() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetViewCamera()->getViewMatrix() );}
        };
        class modelViewMatrix : public osg::Uniform::Callback
        {
        public:
                modelViewMatrix() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetViewCamera()->getViewMatrix() );}
        };
        class viewMatrixInv : public osg::Uniform::Callback
        {
        public:
                viewMatrixInv() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( osg::Matrix::inverse(Scene::GetViewCamera()->getViewMatrix()));}
        };
        class project_light : public osg::Uniform::Callback
        {
        public:
                project_light() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetProjectionMatrix_Light() );}
        };
        class viewMatrix_light : public osg::Uniform::Callback
        {
        public:
                viewMatrix_light() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetLightCamera()->getViewMatrix() );}
        };
        class modelViewMatrix_light : public osg::Uniform::Callback
        {
        public:
                modelViewMatrix_light() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( Scene::GetLightCamera()->getViewMatrix() );}
        };
        class viewMatrixInv_light : public osg::Uniform::Callback
        {
        public:
                viewMatrixInv_light() {}
                void operator()( osg::Uniform* uniform, osg::NodeVisitor* nv ){ uniform->set( osg::Matrix::inverse(Scene::GetProjectionMatrix_Light()) );}
        };

        class CloudScene : public osg::Referenced
        {
        public:
                enum CloudType
                {
                        CT_Stratus,
                        CT_AltStratus,
                        CT_StratoCumulusGenerator,
                        CT_Cumulus,
                        CT_Nimbostratus,
                        CT_Cumolonimbus,
                        CT_AltCumulusGenerator,
                        CT_Quantity
                };

                enum WC_Uniform
                {
                        WCU_LightPos,
                        WCU_TimeOfDay,
                        WCU_Fading,
                        WCU_Density,
                        WCU_AmbientLight_H0,
                        WCU_AmbientLight_H1,
                        WCU_AmbientLight_T0,
                        WCU_AmbientLight_T1,
                        WCU_DirectionalColor,
                        WCU_SunLightColor,
                        quantity
                };

        public:
                CloudScene();
                //CloudScene(int m_category, osg::ref_ptr<osg::Vec3Array> vertices, osg::ref_ptr<osg::Vec4Array> rotation, osg::ref_ptr<osg::Vec4Array> center, osg::ref_ptr<osg::Vec4Array> ids, osg::ref_ptr<osg::Vec4Array> boxcenters, osg::ref_ptr<osg::Vec3Array> ambientlight_h, osg::ref_ptr<osg::Vec3Array> ambientlight_t, osg::ref_ptr<osg::Vec3Array> diffuselight);

                ~CloudScene(void);

                osg::ref_ptr<osg::Geometry> InsertCloud(WangCloud* cloud, int layerID);
                
                void AddCloud(WangCloud* cloud, int layerID);
                void UpdateCloud(WangCloud* cloud, int at);

                void AddLayer(int layerID, int layer);
                int GetType(int layer);
                int GetNumberOfLayers();
        
                void Create();
                static void DeleteStates();


                CloudLayerUpdate* cloud_layer_update;

                void SetFog(Fog* fog);

                void Setup();

                void SetupAttributes(osg::ref_ptr<osg::StateSet> nodess4);

                static void LoadingTexture();
                static void LoadingShader();

                static void SetStates(CloudLayerState* state);
                static CloudLayerState* GetStates();

                void UpdateUniform(int type);

                int GetNumberOfClouds();
                unsigned int GetNumberOfParticles();

                static void Initialize();


                static float timeOfDay;
                static float fading;
                static float dens;
                static osg::Vec3 ambientLight_h0;
                static osg::Vec3 ambientLight_h1;
                static osg::Vec3 ambientLight_t0;
                static osg::Vec3 ambientLight_t1;
                static osg::Matrix3 directionalColors;
                static float time;
                static osg::Vec3 sunLightColor;

                static osg::ref_ptr<osg::Program> cloudShadowMapProg;
                static osg::ref_ptr<osg::Program> cloudBlurHoriProg;
                static osg::ref_ptr<osg::Program> cloudBlurVertProg;
                static osg::ref_ptr<osg::Program> cloudBlurLinearHoriProg;
                static osg::ref_ptr<osg::Program> cloudBlurLinearVertProg;
                static osg::ref_ptr<osg::Program> cloudProg; 
                static osg::ref_ptr<osg::Program> cloudShadowProg;
                static osg::ref_ptr<osg::Texture2D> tex_clouds;
        
                static osg::FrameBufferObject* fbo_viewer;
                static osg::FrameBufferObject* fbo_light;


                osg::ref_ptr<osg::Uniform> project_lightuniform;
                osg::ref_ptr<osg::Uniform> modelViewMatrix_lightuniform;
                osg::ref_ptr<osg::Uniform> viewMatrix_lightuniform;
                osg::ref_ptr<osg::Uniform> viewMatrixInv_lightuniform;
                osg::ref_ptr<osg::Uniform> projectuniform;
                osg::ref_ptr<osg::Uniform> modelViewMatrixuniform;
                osg::ref_ptr<osg::Uniform> viewMatrixuniform;
                osg::ref_ptr<osg::Uniform> viewMatrixInvuniform;

                osg::ref_ptr<osg::Geode> quadBillBoard;
                osg::ref_ptr<osg::StateSet> nodess4;

                osg::ref_ptr<osg::Vec3Array> m_cloudcenter;

                osg::ref_ptr<osg::IntArray> m_start_indices;

                bool setup_attribute;
                osg::ref_ptr<osg::Geode> geode;

        #ifdef SHADOW_MAPPING
                osg::ref_ptr<osgCloudyDay::CloudGeometry> geometry;
        #else
                osg::ref_ptr<osg::Geometry> geometry;
        #endif

                void RemoveScreenBillBoard();   

                osg::Vec3 CalculatePosition(int m_type);

                int numClouds;
                
                osg::Geometry* createSphere(osg::Vec3 middlePoint, float radius, int vpr);
                osg::ref_ptr<osg::Geometry> CreateBBForCloud(int cloudID);      

                std::vector<WangCloud*> m_clouds;

                unsigned int GetLayer(int index);

                static bool m_backtofront;
                static bool m_backtofront_old;  



                static void CreateCloudCamera();

                static osg::ref_ptr<osg::Camera> GetCloudCamera();
                

                static osg::ref_ptr<osg::Texture2D> fbo_light_texture;  //SHADOW                
                static osg::ref_ptr<osg::Texture2D> fbo_cloud_texture;  //CLOUD TEXTURE
                
                static osg::FrameBufferObject* fbo_cloud_viewer;                //CLOUD FRAMEBUFFER
                static osg::FrameBufferObject* fbo_shadow;
                static osg::FrameBufferObject* fbo_vert_linear_blur;
                static osg::FrameBufferObject* fbo_hori_linear_blur;
                static osg::FrameBufferObject* fbo_vert_blur;
                static osg::FrameBufferObject* fbo_hori_blur;
                static osg::FrameBufferObject* fbo_hori_blur2;  



        protected:              
                static osg::ref_ptr<osg::Camera> m_lightCloudCamera;    

                void AddDrawElementsPoint(std::vector<unsigned int> index, unsigned int start, unsigned int count, int k);

                void InsertScreenBillBoard();
                /*
                 * Random generator
                 * @return random value
                 */
                inline float frand();
                osg::Vec2 GetGaussianDistributedRandomNumber(osg::Vec2 m, float v);
                void GenerateRandomSequence(int num_elements);
                osg::Vec2 m_numOfClouds;
                std::vector<int> sequence;
        
                unsigned int m_num_indices;     

                std::vector<unsigned int> m_layerToNumberCloud;
                std::vector<unsigned int> m_layerToCloudType;
                std::vector<unsigned int> m_layerToCloudLayerID;
                osg::ref_ptr<osg::IntArray> m_startLayerIndex;

                osg::ref_ptr<osg::Vec3Array> m_vertices;
                osg::ref_ptr<osg::Vec3Array> m_bb_min;
                osg::ref_ptr<osg::Vec3Array> m_bb_max;
                osg::ref_ptr<osg::Vec4Array> m_rotation;
                osg::ref_ptr<osg::Vec4Array> m_center;
                osg::ref_ptr<osg::Vec4Array> m_ids;
                osg::ref_ptr<osg::Vec4Array> m_box_centers;     
                osg::ref_ptr<osg::Vec4Array> m_color;   
                
                osg::ref_ptr<osg::IntArray> m_numPrimitiveArrays;       

                std::map<int, std::string> m_uniforms;

                osg::ref_ptr<osg::Vec3Array> m_ambientlight_h;
                osg::ref_ptr<osg::Vec3Array> m_ambientlight_t;
                osg::ref_ptr<osg::Vec3Array> m_diffuselight;

                static CloudLayerState* m_CloudLayerState;      

                Fog* m_fog;
        };
}