VRS - The Virtual Rendering System

version 3.3

greenspace.h

Go to the documentation of this file.

#ifndef GREENSPACE_H
#define GREENSPACE_H

#include <vrs/environment/config.h>
#include <vrs/shape.h>
#include <vrs/image/image.h>
#include <vrs/distantlight.h>
#include <vrs/opengl/backgroundgl.h>

namespace VRS {
    template<typename T> class Iterator;
    class Facet;
    class Texture2DGL;
    class PolygonSet;
    class ImageTexture2DGL;
}

namespace EnvironmentRenderer {

    class VRS_ENV_API GreenSpace : public VRS::Shape {
    public:
        GreenSpace(VRS::SO<VRS::Iterator<VRS::SO<VRS::Facet> > > surface,
                   VRS::SO<VRS::Iterator<VRS::SO<VRS::Image> > > textures = NULL,
                   double grassLength = 1.0,
                   double grassDensity = 1.0,
                   double angle = 100.0,
                   unsigned int fans = 1,
                   unsigned int lamellas = 1,
                   double aspectRatio = 1.0,
                   double topPadding = 0.0,
                   double alphaTestValue = 0.5,
                   double displayDistance = 100.0);



        VRS::SO<VRS::Iterator<VRS::SO<VRS::Facet> > > getSurface() const;
        void setSurface(VRS::SO<VRS::Iterator<VRS::SO<VRS::Facet> > > surface);

        VRS::SO<VRS::Iterator<VRS::SO<VRS::Image> > > getTextures() const;
        void setTextures(VRS::SO<VRS::Iterator<VRS::SO<VRS::Image> > > textures);

        double getGrassDensity() const;
        void setGrassDensity(double density);

        double getGrassLength() const;
        void setGrassLength(double density);

        double getAngle() const;
        void setAngle(double angle);

        void setFans(unsigned int fans);
        unsigned int getFans() const;

        void setLamellas(unsigned int lamellas);
        unsigned int getLamellas() const;

        void setAspectRatio(double aspectRatio);
        double getAspectRatio() const;

        void setTopPadding(double aspectRatio);
        double getTopPadding() const;

        void setAlphaTestValue(double alphaTestValue);
        double getAlphaTestValue() const;

        void setDisplayDistance(double distance);
        double getDisplayDistance() const;

        static VRS::SO<VRS::Image> getGrassTexture(unsigned int texWidth, unsigned int texHeight,
                                                   double surfaceWidth, double surfaceLength,
                                                   VRS::SO<GreenSpace> greenSpace,
                                                   VRS::SO<VRS::DistantLight> sun = new VRS::DistantLight(VRS::Vector(0.0, 1.0, 0.0), VRS::Color::white, 1.0),
                                                   VRS::SO<VRS::BackgroundGL> background = new VRS::BackgroundGL());

        inline virtual VRS::Bounds boundingBox() const;


        // needed by the painter. do not call these methods!
        bool needsUpdate() const;
        void setBoundingBox(const VRS::Bounds &bounds);

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

    private:

        GreenSpace(); // only for serialization

        //static VRS::SO<VRS::PolygonSet> createTussockGeometry(double length, double angle);

        VRS::SO<VRS::Iterator<VRS::SO<VRS::Facet> > > m_surface;
        VRS::SO<VRS::Iterator<VRS::SO<VRS::Image> > > m_grassTextures;

        double m_grassDensity;
        double m_grassLength;
        double m_angle;
        double m_aspectRatio;
        double m_topPadding;
        double m_alphaTestValue;
        double m_displayDistance;
        unsigned int m_fans;
        unsigned int m_lamellas;

        mutable bool m_needsUpdate;

        VRS::Bounds m_boundingBox;
    };


    inline VRS::SO<VRS::Iterator<VRS::SO<VRS::Facet> > > GreenSpace::getSurface() const
    {
        return m_surface;
    }

    inline VRS::SO<VRS::Iterator<VRS::SO<VRS::Image> > > GreenSpace::getTextures() const {
        return m_grassTextures;
    }

    inline VRS::Bounds GreenSpace::boundingBox() const {
        return m_boundingBox;
    }

    inline void GreenSpace::setBoundingBox(const VRS::Bounds &bounds)
    {
        m_boundingBox = bounds;
    }

    inline double GreenSpace::getGrassDensity() const {
        return m_grassDensity;
    }

    inline double GreenSpace::getGrassLength() const {
        return m_grassLength;
    }

    inline double GreenSpace::getAngle() const {
        return m_angle;
    }

    inline unsigned int GreenSpace::getFans() const
    {
        return m_fans;
    }

    inline unsigned int GreenSpace::getLamellas() const
    {
        return m_lamellas;
    }

    inline double GreenSpace::getAspectRatio() const
    {
        return m_aspectRatio;
    }

    inline double GreenSpace::getTopPadding() const
    {
        return m_topPadding;
    }

    inline double GreenSpace::getAlphaTestValue() const
    {
        return m_alphaTestValue;
    }

    inline double GreenSpace::getDisplayDistance() const
    {
        return m_displayDistance;
    }

} // namepsace EnvironmentRenderer

#endif // GREENSPACE_H

---

Generated on Sun May 19 06:00:28 2013 by Doxygen 1.5.6

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