VRS - The Virtual Rendering System

version 3.3

skydome.h

Go to the documentation of this file.

#ifndef SKYDOME_H
#define SKYDOME_H

#include <vrs/environment/config.h>
#include <vrs/shape.h>
#include <vrs/color.h>

namespace VRS {
    template<typename T> class Array;
    class TextureGL;
}

namespace EnvironmentRenderer {

    class CloudLayer;

    class VRS_ENV_API SkyDome : public VRS::Shape {
    public:
        SkyDome(const VRS::Vector &sunDir = VRS::Vector(0.0, 1.0, 0.0),
                const VRS::Color &sunColor = VRS::Color(1.0, 1.0, 1.0),
                bool perFragment = true);

        virtual VRS::Bounds boundingBox() const;

        VRS::Vector getSunDirection() const;
        void setSunDirection(const VRS::Vector &dir);

        static VRS::Vector calculateSunDirection(double longitude, double latitude, int year, int month, int day, int hour = 12, int minute = 0, int second = 0);
        void setSunDirection(double longitude, double latitude, int year, int month, int day, int hour = 12, int minute = 0, int second = 0);

        void addCloudLayer(VRS::SO<CloudLayer> layer);

        CloudLayer* removeCloudLayer(unsigned int index);
        bool removeCloudLayer(VRS::SO<CloudLayer> layer);

        void clearCloudLayers();

        void setRenderClouds(bool yesNo);
        bool renderClouds() const;

        CloudLayer* getCloudLayer(unsigned int index) const;

        VRS::SO<VRS::Iterator<VRS::SO<CloudLayer> > > getCloudLayers() const;

        bool getPerFragment() const;
        void setPerFragment(bool perFragment);

        VRS::Color getSunLightColor() const;
        void setSunLightColor(const VRS::Color &c);

        VRS::Color getSunLightColorGroundLevel() const;

        VRS::Vector getSkyColor(const VRS::Vector& direction) const;

        double getPlanetRadius() const;
        void setPlanetRadius(double radius);

        double getAtmosphereThickness() const;
        void setAtmosphereThickness(double thickness);

        VRS::VertexData<2, unsigned int> getAtmosphereDetail() const;
        void setAtmosphereDetail(unsigned int slices, unsigned int stacks);

        VRS::VertexData<2, unsigned int> getCloudDetail() const;
        void setCloudDetail(unsigned int slices, unsigned int stacks);


        VRS::VertexData<3, unsigned int> getWavelengths() const;
        void setWavelengths(unsigned int red, unsigned int green, unsigned int blue);

        float getRayleighCoefficient() const;
        void setRayleighCoefficient(float coeff);

        float getExcentricity() const;
        void setExcentricity(float excentricity);
        float getMieCoefficient() const;
        void setMieCoefficient(float coeff);

        float getInscatteringScale() const;
        void setInscatteringScale(float scale);


        static double calculateAtmosphereThickness(double planetRadius, double atmosphereThickness, const VRS::Vector &direction);

        // needed by the painter. do not call these methods!
        bool needsUpdateAtmosphere() const;
        bool needsUpdateClouds() const;

        VRS_TYPEINFO(SkyDome, VRS::Shape);
        VRS_SERIALIZABLE(SkyDome);

    private:
        VRS::Bounds m_boundingBox;

        VRS::Vector m_sunDirection;
        VRS::Color m_sunColor;

        VRS::VertexData<3, unsigned int> m_wavelengths;

        float m_rayleighCoefficient;
        float m_excentricity, m_mieCoefficient, m_inscatteringScale;

        double m_atmosphereThickness, m_planetRadius;
        VRS::VertexData<2, unsigned int> m_atmosphereDetail, m_cloudDetail;

        bool m_perFragment;
        bool m_renderClouds;

        VRS::SO<VRS::Array<VRS::SO<CloudLayer> > > m_cloudLayers;

        mutable bool m_needsUpdateAtmosphere, m_needsUpdateClouds;
    };


    class VRS_ENV_API CloudLayer : public VRS::SharedObj {
    public:
        CloudLayer(VRS::TextureGL* texture, const VRS::Vector& flowingDirection = VRS::Vector::origin, double coverage = 0.5, double density = 0.0, double opacity = 1.0, const VRS::Vector& scale = VRS::Vector(1.0, 1.0, 1.0));

        VRS::TextureGL* getTexture() const;
        void setTexture(VRS::TextureGL* texture);

        VRS::Vector getFlowingDirection() const;
        void setFlowingDirection(const VRS::Vector& direction);

        double getCoverage() const;
        void setCoverage(double coverage);

        double getDensity() const;
        void setDensity(double density);

        double getOpacity() const;
        void setOpacity(double opacity);

        VRS::Vector getScale() const;
        void setScale(const VRS::Vector& scale);

        VRS_TYPEINFO(CloudLayer, VRS::SharedObj);
        VRS_SERIALIZABLE(CloudLayer);

    private:
        CloudLayer();

        VRS::SO<VRS::TextureGL> m_texture;
        VRS::Vector m_flowingDirection;
        VRS::Vector m_scale;

        double m_coverage, m_density, m_opacity;
    };

} // namespace EnvironmentRenderer

#endif // SKYDOME_H

---

Generated on Thu May 24 06:00:15 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact