Cloud.h

Go to the documentation of this file.

#ifndef _VRECKO_CLOUDS_CLOUD_H
#define _VRECKO_CLOUDS_CLOUD_H

#include <osg/Vec4>
#include <osg/Geometry>
#include <osg/Texture2D>

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <set>
#include <cmath>

#include "BoundingVol.h"

#ifndef PI
#define PI 3.1415926535
#endif

struct CloudSceneInfo
{
    int screenWidth, screenHeight;
    double Fovy, Aspect, Near, Far;
};

struct SunLight
{
    osg::Vec4f ambientLight,
              sunColor;
    osg::Vec3f position;
};

struct Particle
{
    float size;
    osg::Vec3f position;
    osg::Vec4f color;
};

struct CloudParticle : public Particle
{
    float distToCam; 
    float render_cloud_tex_u1, render_cloud_tex_v1,
          render_cloud_tex_u2, render_cloud_tex_v2;
};

class Cloud
{
public:
    AABoundingBox boundingBox;                                                          // Bounding box (sphere, actually) of the cloud
    std::vector<CloudParticle> cloudParticle;                                           // Contains all of the cloud's particles
private:

    float distToCam;
    bool screenImpostor;                                                                // Indicates whether the camera is in the cloud and impostor is rendered on the whole screen

    osg::ref_ptr<osg::Geometry> cloudGeometry;                                          // Cloud geometry itself, contains all of the particles and is connected to the scene graph
    osg::ref_ptr<osg::StateSet> cloudState;                                             // State of the cloud

    osg::Vec3f center;                                                                  // Contains position of the center of the cloud (a vector used as a point in 3D)
    osg::Vec3f last_cam;
    osg::Vec3f right, up;

    static osg::Vec3f cameraPosition, cameraView, cameraUp;                             // Current camera data
    static osg::Matrix viewMatrix;                                                      // Curent view matrix

    static osg::ref_ptr<osg::Texture2D> cloudParticleTexture;                           // Texture with cloud particles

    // Lighting related attributes
    static const int SplatBufferSize;
    static float Albedo;
    static float Extinction;
    static float Alpha;
    static SunLight sunLight;
    static unsigned int lightTexture;

    // Priority queue and cloud update related attributes
    static std::priority_queue<Cloud *, std::vector<Cloud *> > cloudQueue;
    static std::vector<Cloud*> cloudVector;
    static std::set<Cloud*> inQueueSet;
    static unsigned int maxUpdatesParFrame;
    static float translateErrorTolerance;

    static CloudSceneInfo sceneInfo;                                                    // Contains the information about the scene and projection - view struct CloudSceneInfo
    
public:
    Cloud() { screenImpostor = false; }

    void CalculateBoundingBox(void);

    void ComputeUpRightVectors();

    void LightCloud(void);

    void RegularUpdate();

    void InitCloudGeometry(osg::ref_ptr<osg::Geometry> cloudGeometry);

    void UpdateCloudLotRocScale();

    void UpdateCloudColor();

    void UpdateCloud();

    void Delete(void);

    // Set methods
    static void SetSunLight(SunLight& sun) { sunLight = sun; }
    void SetLastCam(osg::Vec3f last_cam) { this->last_cam = last_cam; }

    // Static methods

    static void GenerateLightTexture(void);

    static void DestroyLightTexture(void);

    static bool AddToQueue(Cloud* cloudToUpdate);

    static void RealizeQueue(void);

    static void SetTranslateErrorTolerance(float tolerance) { translateErrorTolerance = abs(cos(tolerance/180*3.1415926f)); }
    static void SetMaxCloudUpdates(unsigned int max) { maxUpdatesParFrame = max; }
    static void SetSceneInfo(const CloudSceneInfo& info) { sceneInfo = info; }

    static void SetCloudParticleTexture(osg::ref_ptr<osg::Texture2D> newCloudParticleTexture) { cloudParticleTexture = newCloudParticleTexture; }

    static void SetCamera(const osg::Vec3f& newCameraPosition, const osg::Vec3f& newCameraView, const osg::Vec3f& newCameraUp);
    static void SetViewMatrix(const osg::Matrix& newViewMatrix) { viewMatrix = newViewMatrix; }

public:
    // Functors
    class ParticleAwayComparison
    {
    public:
        bool operator () (CloudParticle particle1, CloudParticle particle2)
        {
            return particle1.distToCam < particle2.distToCam;
        }
    } SortAway;
};

#endif