OgreShaderParticleRenderer.h

Go to the documentation of this file.

#pragma once
#ifndef __OGRE_SHADER_PARTICLE_RENDERER_H__
#define __OGRE_SHADER_PARTICLE_RENDERER_H__
 
 
#include <OgreParticleSystemRenderer.h>
#include <OgreVector2.h>
 
namespace Ogre {
 
 
 
    class ShaderParticleRenderer : public ParticleSystemRenderer, public Renderable
    {
    protected:
        MaterialPtr         mMaterial;              
        VertexData*         mVertexData;
        IndexData*          mIndexData;
        uint8               mRenderQueueID;
 
        bool                mVertexFormatColour;            
        bool                mVertexFormatTexture;           
        bool                mVertexFormatSize;              
        bool                mVertexFormatRotation;          
        bool                mVertexFormatRotationSpeed;     
        bool                mVertexFormatDirection;         
        bool                mVertexFormatTTL;               
        bool                mVertexFormatTotalTTL;          
        bool                mVertexFormatTimeFragment;      
        bool                mVertexFormatTimeFragmentInv;   
        size_t              mVertexSize;
        Vector2             mTexCoordTable[4];              
 
        Vector2             mDefaultParticleSize;   
        Node*               mParentNode;            
        SortMode            mSortMode;              
        mutable LightList   mLightList;             
        mutable ulong       mLightListUpdated;      
        Real                mRadius;                
        bool                mParentIsTagPoint;      
        bool                mKeepInLocalSpace;      
 
    public:
        ShaderParticleRenderer();
        virtual ~ShaderParticleRenderer();
 
        class _OgrePrivate CmdVertexFormatColour : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatTexture : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatSize : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatRotation : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatRotationSpeed : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatDirection : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatTTL : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatTotalTTL : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatTimeFrag : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        class _OgrePrivate CmdVertexFormatTimeFragInv : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
 
        // getters / setters
        void setVertexFormatColour(bool bUse) { mVertexFormatColour = bUse; }
        bool getVertexFormatColour() const { return mVertexFormatColour; }
 
        void setVertexFormatTexture(bool bUse) { mVertexFormatTexture = bUse; }
        bool getVertexFormatTexture() const { return mVertexFormatTexture; }
 
        void setVertexFormatSize(bool bUse) { mVertexFormatSize = bUse; }
        bool getVertexFormatSize() const { return mVertexFormatSize; }
 
        void setVertexFormatRotation(bool bUse) { mVertexFormatRotation = bUse; }
        bool getVertexFormatRotation() const { return mVertexFormatRotation; }
 
        void setVertexFormatRotationSpeed(bool bUse) { mVertexFormatRotationSpeed = bUse; }
        bool getVertexFormatRotationSpeed() const { return mVertexFormatRotationSpeed; }
 
        void setVertexFormatDirection(bool bUse) { mVertexFormatDirection = bUse; }
        bool getVertexFormatDirection() const { return mVertexFormatDirection; }
 
        void setVertexFormatTTL(bool bUse) { mVertexFormatTTL = bUse; }
        bool getVertexFormatTTL() const { return mVertexFormatTTL; }
 
        void setVertexFormatTotalTTL(bool bUse) { mVertexFormatTotalTTL = bUse; }
        bool getVertexFormatTotalTTL() const { return mVertexFormatTotalTTL; }
 
        void setVertexFormatTimeFragment(bool bUse) { mVertexFormatTimeFragment = bUse; }
        bool getVertexFormatTimeFragment() const { return mVertexFormatTimeFragment; }
 
        void setVertexFormatTimeFragmentInv(bool bUse) { mVertexFormatTimeFragmentInv = bUse; }
        bool getVertexFormatTimeFragmentInv() const { return mVertexFormatTimeFragmentInv; }
 
        virtual const String& getType(void) const override;
        virtual void _updateRenderQueue(RenderQueue* queue, Ogre::list<Particle*>::type& currentParticles, bool cullIndividually) override;
        virtual void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables = false) override;
        virtual void _setMaterial(MaterialPtr& mat) override;
        virtual void _notifyCurrentCamera(Camera* cam) override;
        virtual void _notifyParticleRotated(void) override;
        virtual void _notifyParticleResized(void) override;
        virtual void _notifyParticleQuota(size_t quota) override;
        virtual void _notifyAttached(Node* parent, bool isTagPoint = false) override;
        virtual void _notifyDefaultDimensions(Real width, Real height) override;
        virtual ParticleVisualData* _createVisualData(void) override;
        virtual void _destroyVisualData(ParticleVisualData* vis) override;
        virtual void setRenderQueueGroup(uint8 queueID) override;
        virtual void setKeepParticlesInLocalSpace(bool keepLocal) override;
        virtual SortMode _getSortMode(void) const override;
 
        virtual const MaterialPtr& getMaterial(void) const override;
        virtual void getRenderOperation(RenderOperation& op) override;
        virtual void getWorldTransforms(Matrix4* xform) const override;
        virtual Real getSquaredViewDepth(const Camera* cam) const override;
        virtual const LightList& getLights(void) const override;
 
    private:
        const String rendererTypeName = "shader";
 
        bool allocateBuffers(size_t iNumParticles);
 
        void addParticle(uint8* pDataVB, const Particle& particle) const;
        void setRenderQueueGroupAndPriority(Ogre::uint8,Ogre::ushort);
    protected:
        static CmdVertexFormatColour        msVertexFmtColour;
        static CmdVertexFormatTexture       msVertexFmtTexture;
        static CmdVertexFormatSize          msVertexFmtSize;
        static CmdVertexFormatRotation      msVertexFmtRotation;
        static CmdVertexFormatRotationSpeed msVertexFmtRotationSpeed;
        static CmdVertexFormatDirection     msVertexFmtDirection;
        static CmdVertexFormatTTL           msVertexFmtTTL;
        static CmdVertexFormatTotalTTL      msVertexFmtTotalTTL;
        static CmdVertexFormatTimeFrag      msVertexFmtTimeFrag;
        static CmdVertexFormatTimeFragInv   msVertexFmtTimeFragInv;
    };
 
    class ShaderParticleRendererFactory : public ParticleSystemRendererFactory
    {
    public:
        const String& getType() const override;
        ParticleSystemRenderer* createInstance( const String& name ) override;
        void destroyInstance( ParticleSystemRenderer* inst) override;
    private:
        const String rendererTypeName = "shader";
    };
 
 
} // namespace Ogre
 
#endif // __OGRE_SHADER_PARTICLE_RENDERER_H__