MaterialManager.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of Hydrax.
Visit ---
 
Copyright (C) 2008 Xavier Vergu�n Gonz�lez <xavierverguin@hotmail.com>
                                           <xavyiy@gmail.com>
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
--------------------------------------------------------------------------------
*/
 
#ifndef _Hydrax_MaterialManager_H_
#define _Hydrax_MaterialManager_H_
 
#include "Prerequisites.h"
 
#include "Enums.h"
 
 
 
namespace Hydrax
{
    class Hydrax;
 
    class MaterialManager
    {
    public:
        enum MaterialType
        {
            // Water material
            MAT_WATER = 0,
            // Depth material
            MAT_DEPTH = 1,
            // Underwater material
            MAT_UNDERWATER = 2,
            // Compositor material(material wich is used in underwater compositor)
            MAT_UNDERWATER_COMPOSITOR = 3,
            // Simple red material
            MAT_SIMPLE_RED = 4,
            // Simple black material
            MAT_SIMPLE_BLACK = 5
        };
        enum MaterialType {…};
 
        enum CompositorType
        {
            // Underwater compositor
            COMP_UNDERWATER = 0
        };
        enum CompositorType {…};
 
        enum GpuProgram
        {
            // Vertex program
            GPUP_VERTEX   = 0,
            // Fragment program
            GPUP_FRAGMENT = 1
        };
        enum GpuProgram {…};
 
        enum ShaderMode
        {
            // HLSL
            SM_HLSL = 0,
            // Cg
            SM_CG   = 1,
            // GLSL
            SM_GLSL = 2
        };
        enum ShaderMode {…};
 
        enum NormalMode
        {
            // Normal map from precomputed texture(CPU)
            NM_TEXTURE = 0,
            // Normal map from vertex(CPU)
            NM_VERTEX  = 1,
            // Normal map from RTT(GPU)
            NM_RTT     = 2
        };
        enum NormalMode {…};
 
        struct Options
        {
            Options()
                : SM(SM_HLSL)
                , NM(NM_TEXTURE)
            {
            }
            Options() {…}
 
            Options(const ShaderMode &_SM,
                    const NormalMode &_NM)
                : SM(_SM)
                , NM(_NM)
            {
            }
            Options(const ShaderMode &_SM, {…}
 
            ShaderMode SM;
            NormalMode NM;
        };
        struct Options {…};
 
        class UnderwaterCompositorListener : public Ogre::CompositorInstance::Listener
        {
        public:
            void notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat);
 
            void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat);
 
            MaterialManager *mMaterialManager;
        };
        class UnderwaterCompositorListener : public Ogre::CompositorInstance::Listener {…};
 
        MaterialManager(Hydrax *h);
 
        ~MaterialManager();
 
        bool createMaterials(const HydraxComponent &Components, const Options &Options);
 
        void removeMaterials();
 
        void removeCompositor();
 
        void reload(const MaterialType &Material);
 
        bool fillGpuProgramsToPass(Ogre::Pass* Pass,
                                   const Ogre::String GpuProgramNames[2],
                                   const ShaderMode& SM,
                                   const Ogre::String EntryPoints[2],
                                   const Ogre::String Data[2]);
 
        bool createGpuProgram(const Ogre::String &Name,
                              const ShaderMode& SM,
                              const GpuProgram& GPUP,
                              const Ogre::String& EntryPoint,
                              const Ogre::String& Data);
 
        inline const bool& isCreated() const
        {
            return mCreated;
        }
        inline const bool& isCreated() const {…}
 
        inline Ogre::MaterialPtr &getMaterial(const MaterialType &Material)
        {
            return mMaterials[static_cast<int>(Material)];
        }
        inline Ogre::MaterialPtr &getMaterial(const MaterialType &Material) {…}
 
        inline Ogre::CompositorPtr &getCompositor(const CompositorType &Compositor)
        {
            return mCompositors[static_cast<int>(Compositor)];
        }
        inline Ogre::CompositorPtr &getCompositor(const CompositorType &Compositor) {…}
 
        inline const bool& isCompositorEnable(const CompositorType &Compositor) const
        {
            return mCompositorsEnable[static_cast<int>(Compositor)];
        }
        inline const bool& isCompositorEnable(const CompositorType &Compositor) const {…}
 
        void setCompositorEnable(const CompositorType &Compositor, const bool &Enable);
 
        inline const Options &getLastOptions() const
        {
            return mOptions;
        }
        inline const Options &getLastOptions() const {…}
 
        void addDepthTechnique(Ogre::Technique *Technique, const bool& AutoUpdate = true);
 
        void addDepthTextureTechnique(Ogre::Technique *Technique, const Ogre::String& TextureName, const Ogre::String& AlphaChannel = "w", const bool& AutoUpdate = true);
 
        inline std::vector<Ogre::Technique*> &getDepthTechniques()
        {
            return mDepthTechniques;
        }
        inline std::vector<Ogre::Technique*> &getDepthTechniques() {…}
 
        void setGpuProgramParameter(const GpuProgram &GpuP, const MaterialType &MType, const Ogre::String &Name, const Ogre::Real &Value);
 
        void setGpuProgramParameter(const GpuProgram &GpuP, const MaterialType &MType, const Ogre::String &Name, const Ogre::Vector2 &Value);
 
        void setGpuProgramParameter(const GpuProgram &GpuP, const MaterialType &MType, const Ogre::String &Name, const Ogre::Vector3 &Value);
 
        void updateAnimatedTextures(float dt);
 
    private:
        bool _isComponent(const HydraxComponent &List, const HydraxComponent &ToCheck) const;
 
        bool _createWaterMaterial(const HydraxComponent &Components, const Options &Options);
 
        bool _createDepthMaterial(const HydraxComponent &Components, const Options &Options);
 
        bool _createDepthTextureGPUPrograms(const HydraxComponent &Components, const Options &Options, const Ogre::String& AlphaChannel);
 
        bool _createUnderwaterMaterial(const HydraxComponent &Components, const Options &Options);
 
        bool _createUnderwaterCompositor(const HydraxComponent &Components, const Options &Options);
 
        bool _createSimpleColorMaterial(const Ogre::ColourValue& MaterialColor, const MaterialType& MT, const Ogre::String& MaterialName, const bool& DepthCheck = true, const bool& DepthWrite = true);
 
        bool mCreated;
        Ogre::MaterialPtr mMaterials[6];
        Ogre::CompositorPtr mCompositors[1];
        bool mCompositorsNeedToBeReloaded[1];
        bool mCompositorsEnable[1];
        std::vector<Ogre::Technique*> mDepthTechniques;
        HydraxComponent mComponents;
        Options mOptions;
        UnderwaterCompositorListener mUnderwaterCompositorListener;
        Hydrax *mHydrax;
        std::vector<Ogre::TextureUnitState*> mCausticsAnimTexVec;
        unsigned int mCausticsAnimCurrentFrame = 0;
        float mCausticsAnimCurrentFrameElapsedTime = 0.f;
    };
    class MaterialManager {…};
};
 
 
#endif