Lights.h

Go to the documentation of this file.

#pragma once

//VRECKO
#include <vrecko/Ability.h>
#include <vrecko/PluginManager.h>
#include <vrecko/World.h>
#include <vrecko/Scene.h>

//Lights
#include <osg/LightSource>
#include <osg/Light>
#include <osg/LightModel>

//XML
#include <helpers/XercesXMLUtils.h>
#include <vrecko/ReaderWriter.h>
#include <xercesc/parsers/XercesDOMParser.hpp>

//Shadows
#include <osgShadow/ShadowMap>
#include <osgShadow/SoftShadowMap>
#include <osgShadow/ShadowTexture>
#include <osgShadow/LightSpacePerspectiveShadowMap>
#include <osg/CullFace>

//Billboarding
#include <osg/BlendFunc>
#include <osg/AlphaFunc>
#include <osg/Geometry>
#include <osg/Texture2D>
#include <osgDB/readFile>
#include <osg/Depth>

#include <cmath>
#include <sstream>
#include <iostream>


namespace APLightsEditor 
{

class Lights : public vrecko::Ability
{
private:
    osg::ref_ptr<osg::Group>                    lightGroup;
    //Shadow techniques
    osg::ref_ptr<osgShadow::ShadowMap>          sm;
    osg::ref_ptr<osgShadow::SoftShadowMap>      ssm;
    //osg::ref_ptr<osgShadow::ShadowTexture>        lispSM;
    
    osg::ref_ptr<osg::ClearNode>                clearColor;
    osg::ref_ptr<osg::LightModel>               lightModel;
    osg::ref_ptr<osg::StateSet>                 lightSS;
    std::vector<osg::Node*>                     flares;
    unsigned int                                maxLights;
    int                                         shadowLightID;
    int                                         sunID;
    osg::Vec4                                   sunDate;        //saved as osg::Vec4(day,month,year,hour*60+minute)

    osg::ref_ptr<osg::Uniform>                  maximum;

    //global illumination variables
    osg::ref_ptr<osg::Camera>                   ndCamera;
    osg::ref_ptr<osg::Camera>                   ndCameraBack;
    osg::ref_ptr<osg::Camera>                   doCamera;
    osg::ref_ptr<osg::Camera>                   bounceCamera;
    osg::ref_ptr<osg::Camera>                   blurXCamera;
    osg::ref_ptr<osg::Camera>                   blurYCamera;
    osg::ref_ptr<osg::StateSet>                 ndSS;
    osg::ref_ptr<osg::StateSet>                 ndBSS;
    osg::ref_ptr<osg::StateSet>                 doSS;
    osg::ref_ptr<osg::StateSet>                 bounceSS;
    osg::ref_ptr<osg::StateSet>                 blurXSS;
    osg::ref_ptr<osg::StateSet>                 blurYSS;
    osg::Vec2                                   giTextureSize;
    osg::Vec2                                   viewportSize;

    std::string                                 envMapPath;
    //Sun computation
    void    clamp(double clampValue, double& number);
    double  computeSunSunriseOrSunset(int day, int month, int year, bool sunrise);
public:
    bool    loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
    
    enum shadowModes
    {
        NONE,
        SHADOW_MAP,
        SOFT_SHADOW_MAP

    } shadowMode;

    enum shadingModes
    {
        GOURAUD,
        PHONG

    } shadeMode;

    enum giModes
    {
        FULL,
        HALF,
        NO

    } giMode;

    virtual void preInitialize();
    virtual void postInitialize();
    
    //Constructor, destructor
    Lights(void);
    ~Lights(void);
    void InitializeGI();
    int add(osg::Vec4 position  = osg::Vec4(0,0,0,1),
            osg::Vec3 direction = osg::Vec3(0,0,-1),
            float spotCutOff    = 180,
            float spotExp       = 0);
    int add(osg::LightSource* lightSource);
    int addSun(int day, int month, int year, int hour, int minute, osg::Vec4* sunPosition = NULL);
    bool remove(int lightNum);
    bool removeAll();
    int size();
    osg::Light* at(int lightNum);
    osg::LightSource* getLightSource(int lightNum);
    osg::Light* getLight(int lightNum);
    bool setLightVisibility(int lightNum, bool on);
    bool setActiveShadowLight(int lightNum);
    void enableShadows(bool OnOrOff);
    void setMode(shadowModes shadowMode, shadingModes shadingMode, giModes giMode);
    bool isShadowsEnabled();
    void setClearColor(osg::Vec4 color);
    osg::Vec4& getClearColor();
    int getCurrentShadowLightID();
    shadowModes getCurrentShadowMode()  { return shadowMode; }
    shadingModes getCurrectShadingMode() { return shadeMode; }
    giModes getCurrentGIMode() { return giMode; }
    void setGlobalAmbient(osg::Vec4 color);
    const osg::Vec4 getGlobalAmbient() { return lightModel->getAmbientIntensity(); }
    int getDOSampleCount();
    float getDORadius();
    int getBounceSampleCount();
    float getBounceRadius();
    int getBlurSize();
    void setDOSampleCount(int count);
    void setDORadius(float radius);
    void setBounceSampleCount(int count);
    void setBounceRadius(float radius);
    void setBlurSize(int size);
    void createFlare(int lightNum);
    const osg::Vec4& getSunDate() { return sunDate; }
    osgShadow::ShadowTechnique* getShadowTechnique();
    std::vector<osg::Node*>& getFlares() { return flares; }
    osg::Texture2D* createBuffer(osg::Vec2 textureSize, osg::Texture::FilterMode filter,
                osg::Texture::WrapMode wrap, GLint internalFormat, GLenum sourceFormat);
    void setUpCamera(osg::ref_ptr<osg::Camera> camera, osg::Vec2 textureSize, osg::ref_ptr<osg::StateSet> camSS,
                osg::ref_ptr<osg::Shader> vert, osg::ref_ptr<osg::Shader> frag);

};
}