OgreMaterial.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

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 _Material_H__
#define _Material_H__

#include "OgrePrerequisites.h"

#include "OgreResource.h"
#include "OgreIteratorWrappers.h"
#include "OgreCommon.h"
#include "OgreColourValue.h"
#include "OgreBlendMode.h"


namespace Ogre {

    // Forward declaration
    class MaterialPtr;

    class _OgreExport Material : public Resource
    {
        friend class SceneManager;
        friend class MaterialManager;

    public:
        typedef std::vector<Real> LodDistanceList;
        typedef ConstVectorIterator<LodDistanceList> LodDistanceIterator;
    protected:


        void applyDefaults(void);

        typedef std::vector<Technique*> Techniques;
        Techniques mTechniques;
        Techniques mSupportedTechniques;
        typedef std::map<unsigned short, Technique*> LodTechniques;
        typedef std::map<unsigned short, LodTechniques*> BestTechniquesBySchemeList;
        BestTechniquesBySchemeList mBestTechniquesBySchemeList;

        LodDistanceList mLodDistances;
        bool mReceiveShadows;
        bool mTransparencyCastsShadows;
        bool mCompilationRequired;

        void insertSupportedTechnique(Technique* t);

        void clearBestTechniqueList(void);

        void loadImpl(void);

        void unloadImpl(void);
        size_t calculateSize(void) const { return 0; } // TODO 
    public:

        Material(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);

        ~Material();
        Material& operator=( const Material& rhs );

        bool isTransparent(void) const;

        void setReceiveShadows(bool enabled) { mReceiveShadows = enabled; }
        bool getReceiveShadows(void) const { return mReceiveShadows; }

        void setTransparencyCastsShadows(bool enabled) { mTransparencyCastsShadows = enabled; }
        bool getTransparencyCastsShadows(void) const { return mTransparencyCastsShadows; }

        Technique* createTechnique(void);
        Technique* getTechnique(unsigned short index);
        Technique* getTechnique(const String& name);
        unsigned short getNumTechniques(void) const;
        void removeTechnique(unsigned short index);     
        void removeAllTechniques(void);
        typedef VectorIterator<Techniques> TechniqueIterator;
        TechniqueIterator getTechniqueIterator(void);
        TechniqueIterator getSupportedTechniqueIterator(void);
        
        Technique* getSupportedTechnique(unsigned short index);
        unsigned short getNumSupportedTechniques(void) const;

        unsigned short getNumLodLevels(unsigned short schemeIndex) const;
        unsigned short getNumLodLevels(const String& schemeName) const;

        Technique* getBestTechnique(unsigned short lodIndex = 0);


        MaterialPtr clone(const String& newName, bool changeGroup = false, 
            const String& newGroup = StringUtil::BLANK) const;

        void copyDetailsTo(MaterialPtr& mat) const;

        void compile(bool autoManageTextureUnits = true);

        // -------------------------------------------------------------------------------
        // The following methods are to make migration from previous versions simpler
        // and to make code easier to write when dealing with simple materials
        // They set the properties which have been moved to Pass for all Techniques and all Passes

        void setPointSize(Real ps);

        void setAmbient(Real red, Real green, Real blue);

        void setAmbient(const ColourValue& ambient);

        void setDiffuse(Real red, Real green, Real blue, Real alpha);

        void setDiffuse(const ColourValue& diffuse);

        void setSpecular(Real red, Real green, Real blue, Real alpha);

        void setSpecular(const ColourValue& specular);

        void setShininess(Real val);

        void setSelfIllumination(Real red, Real green, Real blue);

        void setSelfIllumination(const ColourValue& selfIllum);

        void setDepthCheckEnabled(bool enabled);

        void setDepthWriteEnabled(bool enabled);

        void setDepthFunction( CompareFunction func );

        void setColourWriteEnabled(bool enabled);

        void setCullingMode( CullingMode mode );

        void setManualCullingMode( ManualCullingMode mode );

        void setLightingEnabled(bool enabled);

        void setShadingMode( ShadeOptions mode );

        void setFog(
            bool overrideScene,
            FogMode mode = FOG_NONE,
            const ColourValue& colour = ColourValue::White,
            Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0 );

        void setDepthBias(ushort bias);

        void setTextureFiltering(TextureFilterOptions filterType);
        void setTextureAnisotropy(int maxAniso);

        void setSceneBlending( const SceneBlendType sbt );

        void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);


        void _notifyNeedsRecompile(void);

        void setLodLevels(const LodDistanceList& lodDistances);
        LodDistanceIterator getLodDistanceIterator(void) const;

        unsigned short getLodIndex(Real d) const;
        unsigned short getLodIndexSquaredDepth(Real squaredDepth) const;

        void touch(void) 
        { 
            if (mCompilationRequired) 
                compile();
            // call superclass
            Resource::touch();
        }
        
        bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;

        bool getCompilationRequired() const
        {
            return mCompilationRequired;
        }


    };

    class _OgreExport MaterialPtr : public SharedPtr<Material> 
    {
    public:
        MaterialPtr() : SharedPtr<Material>() {}
        explicit MaterialPtr(Material* rep) : SharedPtr<Material>(rep) {}
        MaterialPtr(const MaterialPtr& r) : SharedPtr<Material>(r) {} 
        MaterialPtr(const ResourcePtr& r) : SharedPtr<Material>()
        {
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Material*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
        }

        MaterialPtr& operator=(const ResourcePtr& r)
        {
            if (pRep == static_cast<Material*>(r.getPointer()))
                return *this;
            release();
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Material*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
            return *this;
        }
    };

} //namespace 

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:43 2006