OgreMaterialSerializer.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-2011 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __MaterialSerializer_H__
#define __MaterialSerializer_H__

#include "OgrePrerequisites.h"
#include "OgreMaterial.h"
#include "OgreBlendMode.h"
#include "OgreTextureUnitState.h"
#include "OgreGpuProgram.h"
#include "OgreStringVector.h"

namespace Ogre {

    enum MaterialScriptSection
    {
        MSS_NONE,
        MSS_MATERIAL,
        MSS_TECHNIQUE,
        MSS_PASS,
        MSS_TEXTUREUNIT,
        MSS_PROGRAM_REF,
        MSS_PROGRAM,
        MSS_DEFAULT_PARAMETERS,
        MSS_TEXTURESOURCE
    };
    struct MaterialScriptProgramDefinition
    {
        String name;
        GpuProgramType progType;
        String language;
        String source;
        String syntax;
        bool supportsSkeletalAnimation;
        bool supportsMorphAnimation;
        ushort supportsPoseAnimation; // number of simultaneous poses supported
        bool usesVertexTextureFetch;
        vector<std::pair<String, String> >::type customParameters;
    };
    struct MaterialScriptContext 
    {
        MaterialScriptSection section;
        String groupName;
        MaterialPtr material;
        Technique* technique;
        Pass* pass;
        TextureUnitState* textureUnit;
        GpuProgramPtr program; // used when referencing a program, not when defining it
        bool isProgramShadowCaster; // when referencing, are we in context of shadow caster
        bool isVertexProgramShadowReceiver; // when referencing, are we in context of shadow caster
        bool isFragmentProgramShadowReceiver; // when referencing, are we in context of shadow caster
        GpuProgramParametersSharedPtr programParams;
        ushort numAnimationParametrics;
        MaterialScriptProgramDefinition* programDef; // this is used while defining a program

        int techLev,    //Keep track of what tech, pass, and state level we are in
            passLev,
            stateLev;
        StringVector defaultParamLines;

        // Error reporting state
        size_t lineNo;
        String filename;
        AliasTextureNamePairList textureAliases;
    };
    typedef bool (*ATTRIBUTE_PARSER)(String& params, MaterialScriptContext& context);

    class _OgreExport MaterialSerializer : public SerializerAlloc
    {   
    public:

        // Material serizliae event.
        enum SerializeEvent
        {
            MSE_PRE_WRITE,
            MSE_WRITE_BEGIN,
            MSE_WRITE_END,
            MSE_POST_WRITE
        };

        class Listener
        {
        public:
            virtual ~Listener() {}
            
            virtual void materialEventRaised(MaterialSerializer* ser, 
                SerializeEvent event, bool& skip, const Material* mat)
                        { (void)ser; (void)event; (void)skip; (void)mat; }
            
            virtual void techniqueEventRaised(MaterialSerializer* ser, 
                SerializeEvent event, bool& skip, const Technique* tech)
                        { (void)ser; (void)event; (void)skip; (void)tech; }
        
            virtual void passEventRaised(MaterialSerializer* ser, 
                SerializeEvent event, bool& skip, const Pass* pass)
                        { (void)ser; (void)event; (void)skip; (void)pass; }

            void gpuProgramRefEventRaised(MaterialSerializer* ser, 
                SerializeEvent event, bool& skip,
                const String& attrib, 
                const GpuProgramPtr& program, 
                const GpuProgramParametersSharedPtr& params,
                GpuProgramParameters* defaultParams)
                        {
                            (void)ser;
                            (void)event;
                            (void)skip;
                            (void)attrib;
                            (void)program;
                            (void)params;
                            (void)defaultParams;
                        }

            virtual void textureUnitStateEventRaised(MaterialSerializer* ser, 
                SerializeEvent event, bool& skip, const TextureUnitState* textureUnit)
                        {
                            (void)ser;
                            (void)event;
                            (void)skip;
                            (void)textureUnit;
                        }           
        };

    protected:
        typedef map<String, ATTRIBUTE_PARSER>::type AttribParserList;

        MaterialScriptContext mScriptContext;

        bool parseScriptLine(String& line);
        bool invokeParser(String& line, AttribParserList& parsers);
        void finishProgramDefinition(void);
        AttribParserList mRootAttribParsers;
        AttribParserList mMaterialAttribParsers;
        AttribParserList mTechniqueAttribParsers;
        AttribParserList mPassAttribParsers;
        AttribParserList mTextureUnitAttribParsers;
        AttribParserList mProgramRefAttribParsers;
        AttribParserList mProgramAttribParsers;
        AttribParserList mProgramDefaultParamAttribParsers;

        typedef vector<Listener*>::type         ListenerList;
        typedef ListenerList::iterator          ListenerListIterator;
        typedef ListenerList::const_iterator    ListenerListConstIterator;
        ListenerList mListeners;


        void writeMaterial(const MaterialPtr& pMat, const String& materialName = "");
        void writeTechnique(const Technique* pTech);
        void writePass(const Pass* pPass);
        void writeVertexProgramRef(const Pass* pPass);
        void writeShadowCasterVertexProgramRef(const Pass* pPass);
        void writeShadowReceiverVertexProgramRef(const Pass* pPass);
        void writeShadowReceiverFragmentProgramRef(const Pass* pPass);
        void writeFragmentProgramRef(const Pass* pPass);
        void writeGpuProgramRef(const String& attrib, const GpuProgramPtr& program, const GpuProgramParametersSharedPtr& params);
        void writeGpuPrograms(void);
        void writeGPUProgramParameters(const GpuProgramParametersSharedPtr& params, GpuProgramParameters* defaultParams,
            const unsigned short level = 4, const bool useMainBuffer = true);
        void writeNamedGpuProgramParameters(const GpuProgramParametersSharedPtr& params, GpuProgramParameters* defaultParams,
            const unsigned short level = 4, const bool useMainBuffer = true);
        void writeLowLevelGpuProgramParameters(const GpuProgramParametersSharedPtr& params, GpuProgramParameters* defaultParams,
            const unsigned short level = 4, const bool useMainBuffer = true);
        void writeGpuProgramParameter(
            const String& commandName, const String& identifier, 
            const GpuProgramParameters::AutoConstantEntry* autoEntry, 
            const GpuProgramParameters::AutoConstantEntry* defaultAutoEntry, 
            bool isFloat, size_t physicalIndex, size_t physicalSize,
            const GpuProgramParametersSharedPtr& params, GpuProgramParameters* defaultParams,
            const unsigned short level, const bool useMainBuffer);
        void writeTextureUnit(const TextureUnitState *pTex);
        void writeSceneBlendFactor(const SceneBlendFactor c_src, const SceneBlendFactor c_dest, 
            const SceneBlendFactor a_src, const SceneBlendFactor a_dest);
        void writeSceneBlendFactor(const SceneBlendFactor sbf_src, const SceneBlendFactor sbf_dest);
        void writeSceneBlendFactor(const SceneBlendFactor sbf);
        void writeCompareFunction(const CompareFunction cf);
        void writeColourValue(const ColourValue &colour, bool writeAlpha = false);
        void writeLayerBlendOperationEx(const LayerBlendOperationEx op);
        void writeLayerBlendSource(const LayerBlendSource lbs);
        
        typedef multimap<TextureUnitState::TextureEffectType, TextureUnitState::TextureEffect>::type EffectMap;

        void writeRotationEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex);
        void writeTransformEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex);
        void writeScrollEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex);
        void writeEnvironmentMapEffect(const TextureUnitState::TextureEffect& effect, const TextureUnitState *pTex);

        String convertFiltering(FilterOptions fo);

        
        void fireMaterialEvent(SerializeEvent event, bool& skip, const Material* mat);

        void fireTechniqueEvent(SerializeEvent event, bool& skip, const Technique* tech);
        
        void firePassEvent(SerializeEvent event, bool& skip, const Pass* pass);
        
        void fireGpuProgramRefEvent(SerializeEvent event, bool& skip,
            const String& attrib, 
            const GpuProgramPtr& program, 
            const GpuProgramParametersSharedPtr& params,
            GpuProgramParameters* defaultParams);
    

        void fireTextureUnitStateEvent(SerializeEvent event, bool& skip, const TextureUnitState* textureUnit);
        
   public:      
        MaterialSerializer();
        virtual ~MaterialSerializer() {}

        void queueForExport(const MaterialPtr& pMat, bool clearQueued = false, 
            bool exportDefaults = false, const String& materialName = "");
        void exportQueued(const String& filename, const bool includeProgDef = false, const String& programFilename = "");
        void exportMaterial(const MaterialPtr& pMat, const String& filename, bool exportDefaults = false,
            const bool includeProgDef = false, const String& programFilename = "", 
            const String& materialName = "");
        const String &getQueuedAsString() const;
        void clearQueue();

        void parseScript(DataStreamPtr& stream, const String& groupName);

        void addListener(Listener* listener);

        void removeListener(Listener* listener);

    private:
        String mBuffer;
        String mGpuProgramBuffer;
        typedef set<String>::type GpuProgramDefinitionContainer;
        typedef GpuProgramDefinitionContainer::iterator GpuProgramDefIterator;
        GpuProgramDefinitionContainer mGpuProgramDefinitionContainer;
        bool mDefaults;
        
    public:
        void beginSection(unsigned short level, const bool useMainBuffer = true)
        {
            String& buffer = (useMainBuffer ? mBuffer : mGpuProgramBuffer);
            buffer += "\n";
            for (unsigned short i = 0; i < level; ++i)
            {
                buffer += "\t";
            }
            buffer += "{";
        }
        void endSection(unsigned short level, const bool useMainBuffer = true)
        {
            String& buffer = (useMainBuffer ? mBuffer : mGpuProgramBuffer);
            buffer += "\n";
            for (unsigned short i = 0; i < level; ++i)
            {
                buffer += "\t";
            }
            buffer += "}";
        }

        void writeAttribute(unsigned short level, const String& att, const bool useMainBuffer = true)
        {
            String& buffer = (useMainBuffer ? mBuffer : mGpuProgramBuffer);
            buffer += "\n";
            for (unsigned short i = 0; i < level; ++i)
            {
                buffer += "\t";
            }
            buffer += att;
        }

        void writeValue(const String& val, const bool useMainBuffer = true)
        {
            String& buffer = (useMainBuffer ? mBuffer : mGpuProgramBuffer);
            buffer += (" " + val);
        }

        void writeComment(unsigned short level, const String& comment, const bool useMainBuffer = true)
        {
            String& buffer = (useMainBuffer ? mBuffer : mGpuProgramBuffer);
            buffer += "\n";
            for (unsigned short i = 0; i < level; ++i)
            {
                buffer += "\t";
            }
            buffer += "// " + comment;
        }



    };
}
#endif