E:/Programming/MyProject/K_Game_hg/GameEngine/include/render/Material.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _RENDERMATERIAL_H_
#define _RENDERMATERIAL_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <resource/Resource.h>
#include <render/Color.h>
#include <render/BlendMode.h>

#include <string>
#include <list>

namespace resource
{
class Serializer;
}

namespace render
{

enum ShadeOptions
{
        SO_FLAT,
        SO_GOURAUD,
        SO_PHONG
};

enum FogMode
{
        FM_NONE,        
        FM_EXP,         
        FM_EXP2,        
        FM_LINEAR       
};


class Shader;
class TextureUnit;

class ENGINE_PUBLIC_EXPORT Material : public resource::Resource
{
public:

        Material(const std::string& name, resource::Serializer* serializer);
        ~Material();

        void setAmbient(f32 red, f32 green, f32 blue);
        void setAmbient(const Color& ambient);

        void setDiffuse(f32 red, f32 green, f32 blue);
        void setDiffuse(const Color& diffuse);

        void setSpecular(f32 red, f32 green, f32 blue);
        void setSpecular(const Color& specular);

        void setEmissive(f32 red, f32 green, f32 blue);
        void setEmissive(const Color& emissive);

        void setShininess(f32 shininess);

        const Color& getAmbient() const;

        const Color& getDiffuse() const;

        const Color& getSpecular() const;

        const Color& getEmissive() const;

        f32 getShininess() const;

        void setLightingEnabled(bool enabled);

        bool getLightingEnabled() const;

        void setShadingMode(ShadeOptions mode);

        ShadeOptions getShadingMode() const;

        void setFog(bool overrideScene = true, FogMode mode = FM_NONE, const Color& color = Color::White, f32 density = 0.001f, f32 start = 0.0f, f32 end = 1.0f);
        
        bool getFogOverride() const;

        FogMode getFogMode() const;

        const Color& getFogColor() const;

        f32 getFogDensity() const;

        f32 getFogStart() const;

        f32 getFogEnd() const;

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

        SceneBlendFactor getSourceBlendFactor() const;

        SceneBlendFactor getDestBlendFactor() const;

        bool isTransparent() const;

        void setDepthCheckEnabled(bool enabled);

        bool getDepthCheckEnabled() const;

        void setDepthWriteEnabled(bool enabled);

        bool getDepthWriteEnabled() const;

        void addTextureUnit(TextureUnit* tu);

        TextureUnit* getTextureUnit(u32 index) const;

        u32 getNumTextureUnits() const; 
        
        void removeTextureUnit(u32 index);

        void removeAllTextureUnits();

        void setVertexShader(const std::string& filename);
        void setVertexShader(Shader* shader);
        Shader* getVertexShader();

        void setFragmentShader(const std::string& filename);
        void setFragmentShader(Shader* shader);
        Shader* getFragmentShader();

        void setGeometryShader(const std::string& filename);
        void setGeometryShader(Shader* shader);
        Shader* getGeometryShader();

        bool isProgrammable();
        bool hasVertexShader();
        bool hasFragmentShader();
        bool hasGeometryShader();

protected:

        void initProperties();
        void unloadImpl();

        // Color properties
        Color mAmbient;
        Color mDiffuse;
        Color mSpecular;
        Color mEmissive;
        f32 mShininess;

        // Blending factors
        SceneBlendFactor mSourceBlendFactor;
        SceneBlendFactor mDestBlendFactor;

        // Depth buffer settings
        bool mDepthCheck;
        bool mDepthWrite;

        bool mLightingEnabled;

        ShadeOptions mShadeOptions;

        // Fog
        bool mFogOverride;
        FogMode mFogMode;
        Color mFogColor;
        f32 mFogDensity;
        f32 mFogStart;
        f32 mFogEnd;

        // Textures
        std::list<TextureUnit*> mTextureUnits;

        Shader* mVertexShader;
        Shader* mFragmentShader;
        Shader* mGeometryShader;
};

} //namespace render

#endif