Create2DCloud.h

#pragma once
#include "Cloud2DState.h"
#include "ObjectModel.h"
#include "Ground.h"
#include "HUD.h"
#include "PostProcess.h"
#include "AtmosphereMie.h"
#include "AtmosphereHimmel.h"
#include "TerrainMIE.h"
#include "TerrainHimmel.h"
#include "TerrainGeometry.h"
#include "ReflectionCamera.h"
#include "CloudCreator.h"
#include "Atmosphereprecompute.h"

#include <osg/PolygonMode>
#include <osg/ShapeDrawable>
#include <osg/Depth>
#include <osg/Program>
#include <osg/Shader>
#include <osg/Uniform>

namespace osgCloudyDay
{
        class PerlinNoiseCallback : public osg::NodeCallback
        {
        public:
                PerlinNoiseCallback(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::RefMatrixd* m = cv->getModelViewMatrix();
                                osg::Matrixd viewMatrix = cv->getCurrentCamera()->getViewMatrix();
                                osg::Matrixd invViewMatrix = osg::Matrixd::inverse(viewMatrix);
                                osg::Matrixd worldmat = invViewMatrix * (*m);
                                osg::Matrixd invWorldMatrix = osg::Matrixd::inverse(worldmat);
        
                                geometry->getOrCreateStateSet()->getUniform("ProjectionMatrix")->set(cv->getCurrentCamera()->getProjectionMatrix());
                                geometry->getOrCreateStateSet()->getUniform("ViewMatrix")->set(cv->getCurrentCamera()->getViewMatrix());
                                geometry->getOrCreateStateSet()->getUniform("ModelMatrix")->set(worldmat);
                                geometry->getOrCreateStateSet()->getUniform("NormalMatrix")->set(invWorldMatrix);
                                geometry->getOrCreateStateSet()->getUniform("LightMatrix")->set(Scene::GetLightCamera()->getViewMatrix());                      
                        }
                        traverse(node, nv);
                }
        };

        class Create2DCloud
        {
        public:
                Create2DCloud(void);
                ~Create2DCloud(void);

                void Initialize(std::vector<Cloud2DState> cloud2dstates);
                osg::Node* GetNode();
                osg::Node* GetNodeLight();
                osg::Node* GetReflectionCamera(int at);

        protected:
                std::vector<osg::ref_ptr<osg::Geode>> m_geodes;
                std::vector<osg::ref_ptr<osg::Geode>> m_light_geodes;

                osg::Group* m_node_scene;
                osg::Group* m_node_light;
                osg::Group** m_reflection;
        };
}