VRS - The Virtual Rendering System

version 3.3

watersurfacetechnique.h

Go to the documentation of this file.

#ifndef WATERSURFACETECHNIQUE_H
#define WATERSURFACETECHNIQUE_H

#include <vrs/environment/config.h>
#include <vrs/environment/watersurface.h>
#include <vrs/opengl/techniquegl.h>
#include <vrs/opengl/texturegl.h>
#include <vrs/time.h>
#include <map>

namespace VRS {
    class Clock;
    class Engine;
    class Shape;
    class Texture2DGL;
    template<typename T, typename V> class CachedEngineResource;
    class PolyAttribute;
    class FrameBufferObjectGL;
    class RenderTextureGL;
    class VRSTime;
    class BackgroundGL; 
}

namespace EnvironmentRenderer {

    class WaterReflected;

    class VRS_ENV_API WaterSurfaceTechnique : public VRS::TechniqueGL  {
    public:
        WaterSurfaceTechnique(bool reflectAll = false,
                              unsigned int textureWidth = 512,
                              unsigned int textureHeight = 512);


        void setReflectAll(bool reflectAll);
        bool getReflectAll() const;

        void setReflFilter(VRS::TextureGL::FilterMode min = VRS::TextureGL::LINEAR, VRS::TextureGL::FilterMode mag = VRS::TextureGL::LINEAR);
        void setRefrFilter(VRS::TextureGL::FilterMode min = VRS::TextureGL::LINEAR, VRS::TextureGL::FilterMode mag = VRS::TextureGL::LINEAR);

        VRS::TextureGL::FilterMode reflMinFilter() const { return m_reflMinFilter; }
        VRS::TextureGL::FilterMode reflMagFilter() const { return m_reflMagFilter; }
        VRS::TextureGL::FilterMode refrMinFilter() const { return m_refrMinFilter; }
        VRS::TextureGL::FilterMode refrMagFilter() const { return m_refrMagFilter; }


        VRS::SO<VRS::Texture2DGL> getReflectionTexture(VRS::SO<WaterSurface> watersurface);
        VRS::SO<VRS::Texture2DGL> getRefractionTexture();
        VRS::SO<VRS::Texture2DGL> getMaskTexture();

        void registerBackgroundTechnique(VRS::SO<VRS::BackgroundGL> background);

        void setTextureSize(unsigned int width, unsigned int height);
        unsigned int getTextureWidth() const;
        unsigned int getTextureHeight() const;

        virtual void start(VRS::Engine*);
        virtual void stop(VRS::Engine*);

        virtual bool preparePass(VRS::Engine*);
        virtual void finishPass(VRS::Engine*);
        virtual void nextPass(VRS::Engine*);

        virtual bool prepareEval(VRS::Engine* engine, const VRS::Shape* shape);
        virtual void finishEval(VRS::Engine* engine, const VRS::Shape* shape);


        virtual bool canBeUsed(VRS::Engine* engine) const;

        VRS_TYPEINFO(WaterSurfaceTechnique, VRS::TechniqueGL);
        VRS_SERIALIZABLE(WaterSurfaceTechnique);

    private:
        /*************************
        *    helper functions    *
        **************************/
        void updateWaterSurfaceData();

        // returns true, if an appropriate surface was found. sets the
        // m_currentSurfaceIndex and m_currentSurface to a new value but
        // never delivers the first element from m_surfaces. check for
        // this entry manually
        bool selectNextReflectingSurface();

        // check weather a watersurface is reflecting/refracting
        inline bool isReflecting(WaterSurface* ws)
        {
            return ws != NULL && (m_markedAsReflecting[ws] || m_reflectAll);
        }

        inline bool isRefracting(WaterSurface* ws)
        {
            return ws != NULL && ws->isRefracting();
        }

        /**************************
        *    transient members    *
        **************************/
        struct WaterSurfaceData
        {
            WaterSurfaceData(VRS::SO<VRS::FrameBufferObjectGL> fbo = NULL,
                             VRS::SO<VRS::Texture2DGL>         reflTex = NULL,
                             const VRS::TransactionNo& reflNo = 0)
            :   refFBO(fbo),
                reflectionTexture(reflTex),
                reflectionTextureTransaction(reflNo)
            {}

            VRS::SO<VRS::FrameBufferObjectGL> refFBO;
            VRS::SO<VRS::Texture2DGL>         reflectionTexture;
            VRS::VertexData<3, float>         normalTranslation;
            VRS::TransactionNo                reflectionTextureTransaction;
        };

        VRS::SO<VRS::NonPersistentArray<VRS::WO<WaterSurface> > > m_surfaces;
        std::map<VRS::WO<WaterSurface>, bool> m_markedAsReflecting;

        VRS::SO<VRS::FrameBufferObjectGL> m_waterMaskFBO;
        VRS::SO<VRS::Texture2DGL> m_waterMask;
        VRS::SO<VRS::RenderTextureGL> m_waterMaskTarget;
        VRS::SO<VRS::Texture2DGL> m_waterMaskDepth;
        VRS::SO<VRS::RenderTextureGL> m_waterMaskDepthTarget;

        // data for watersurfaces that are not 'touched' for 10 frames are removed
        typedef VRS::CachedEngineResource<VRS::WO<WaterSurface>, WaterSurfaceData> CachedWaterSurfaceData;
        VRS::SO<CachedWaterSurfaceData> m_surfaceData;

        unsigned int m_currentSurfaceIndex;
        VRS::WO<EnvironmentRenderer::WaterSurface> m_currentSurface;

        int m_recursions;
        bool m_render;

        VRS::SO<VRS::Texture2DGL> m_reflTex;
        VRS::SO<VRS::Texture2DGL> m_refrTex;

        VRS::TransactionNo m_textureTransaction;

        VRS::Matrix m_originalModelview;
        VRS::Matrix m_originalProjection;

        VRS::VRSTime m_currentPassTime, m_lastPassTime;
        double m_elapsedTime;
        VRS::SO<VRS::Clock> m_lastClock;


        /***************************
        *    persistent members    *
        ***************************/
        // persistent members
        bool m_reflectAll;

        VRS::TextureGL::FilterMode m_reflMagFilter, m_reflMinFilter;
        VRS::TextureGL::FilterMode m_refrMagFilter, m_refrMinFilter;

        unsigned int m_textureWidth, m_textureHeight;
        VRS::SO<VRS::BackgroundGL> m_background;

    };

} // namepsace EnvironmentRenderer

#endif // WATERSURFACETECHNIQUE_H

---

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

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