D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spMaterialStates.hpp

Go to the documentation of this file.

/*
 * Material states header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_MATERIAL_STATES_H__
#define __SP_MATERIAL_STATES_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spMaterialConfigTypes.hpp"
#include "Base/spMaterialColor.hpp"

#include <limits.h>


namespace sp
{
namespace video
{


class SP_EXPORT MaterialStates
{
    
    public:
        
        MaterialStates();
        MaterialStates(const MaterialStates* Other);
        virtual ~MaterialStates();
        
        /* === Functions === */
        
        virtual void copy(const MaterialStates* Other);
        
        virtual bool compare(const MaterialStates* Other) const;
        
        virtual void update();
        
        /* === Inline functions === */
        
        inline void setWireframe(const EWireframeTypes Type)
        {
            RenderModeFront_ = RenderModeBack_ = Type;
            update();
        }
        
        inline void setWireframe(const EWireframeTypes TypeFront, const EWireframeTypes TypeBack)
        {
            RenderModeFront_    = TypeFront;
            RenderModeBack_     = TypeBack;
            update();
        }
        
        inline EWireframeTypes getWireframeFront() const
        {
            return RenderModeFront_;
        }
        inline EWireframeTypes getWireframeBack() const
        {
            return RenderModeBack_;
        }
        
        inline void setRenderFace(const EFaceTypes Face)
        {
            RenderFace_ = Face;
            update();
        }
        inline EFaceTypes getRenderFace() const
        {
            return RenderFace_;
        }
        
        inline void setShininess(f32 Intensity)
        {
            Shininess_ = 128.0f - math::MinMax(Intensity, 0.0f, 1.0f)*128;
        }
        inline f32 getShininess() const
        {
            return 1.0f - Shininess_/128;
        }
        
        inline void setShininessFactor(f32 Factor)
        {
            Shininess_ = math::MinMax(Factor, 0.0f, 128.0f);
        }
        inline f32 getShininessFactor() const
        {
            return Shininess_;
        }
        
        inline void setColorMaterial(bool isColorMaterial)
        {
            isColorMaterial_ = isColorMaterial;
        }
        inline bool getColorMaterial() const
        {
            return isColorMaterial_;
        }
        
        inline void setLighting(bool isLighting)
        {
            isLighting_ = isLighting;
        }
        inline bool getLighting() const
        {
            return isLighting_;
        }
        
        inline void setDepthBuffer(bool isDepthBuffer)
        {
            isZBuffer_ = isDepthBuffer;
            update();
        }
        inline bool getDepthBuffer() const
        {
            return isZBuffer_;
        }
        
        inline void setBlending(bool isBlending)
        {
            isBlending_ = isBlending;
            update();
        }
        inline bool getBlending() const
        {
            return isBlending_;
        }
        
        inline void setFog(bool isFog)
        {
            isFog_ = isFog;
        }
        inline bool getFog() const
        {
            return isFog_;
        }
        
        inline void setPolygonOffset(bool isPolygonOffset)
        {
            isPolygonOffset_ = isPolygonOffset;
            update();
        }
        inline bool getPolygonOffset() const
        {
            return isPolygonOffset_;
        }
        
        inline void setColors(
            const color &Diffuse, const color &Ambient, const color &Specular, const color &Emission)
        {
            ColorDiffuse_   = Diffuse;
            ColorAmbient_   = Ambient;
            ColorSpecular_  = Specular;
            ColorEmission_  = Emission;
        }
        
        inline void setDiffuseColor(const color &Color)
        {
            ColorDiffuse_ = Color;
        }
        inline color getDiffuseColor() const
        {
            return ColorDiffuse_;
        }
        inline color& getDiffuseColor()
        {
            return ColorDiffuse_;
        }
        
        inline void setAmbientColor(const color &Color)
        {
            ColorAmbient_ = Color;
        }
        inline color getAmbientColor() const
        {
            return ColorAmbient_;
        }
        inline color& getAmbientColor()
        {
            return ColorAmbient_;
        }
        
        inline void setSpecularColor(const color &Color)
        {
            ColorSpecular_ = Color;
        }
        inline color getSpecularColor() const
        {
            return ColorSpecular_;
        }
        inline color& getSpecularColor()
        {
            return ColorSpecular_;
        }
        
        inline void setEmissionColor(const color &Color)
        {
            ColorEmission_ = Color;
        }
        inline color getEmissionColor() const
        {
            return ColorEmission_;
        }
        inline color& getEmissionColor()
        {
            return ColorEmission_;
        }
        
        inline void setDiffuseAlpha(f32 Alpha)
        {
            ColorDiffuse_.Alpha = static_cast<u8>(math::MinMax(Alpha * 255.0f, 0.0f, 255.0f));
        }
        
        inline void setShading(const EShadingTypes Type)
        {
            Shading_ = Type;
        }
        inline EShadingTypes getShading() const
        {
            return Shading_;
        }
        
        inline void setPolygonOffset(bool isPolygonOffset, f32 OffsetFactor, f32 OffsetUnits = 0.0f)
        {
            isPolygonOffset_    = isPolygonOffset;
            OffsetFactor_       = OffsetFactor;
            OffsetUnits_        = OffsetUnits;
            update();
        }
        
        inline void setPolygonOffsetFactor(f32 Factor)
        {
            OffsetFactor_ = Factor;
            update();
        }
        inline f32 getPolygonOffsetFactor() const
        {
            return OffsetFactor_;
        }
        
        inline void setPolygonOffsetUnits(f32 Units)
        {
            OffsetUnits_ = Units;
            update();
        }
        inline f32 getPolygonOffsetUnits() const
        {
            return OffsetUnits_;
        }
        
        inline void setBlendingMode(const EDefaultBlendingTypes Mode)
        {
            setDefaultBlending(Mode, BlendSource_, BlendTarget_);
        }
        
        inline void setBlendingMode(const EBlendingTypes BlendSource, const EBlendingTypes BlendTarget)
        {
            BlendSource_ = BlendSource;
            BlendTarget_ = BlendTarget;
            update();
        }
        
        inline void setBlendSource(const EBlendingTypes BlendSource)
        {
            BlendSource_ = BlendSource;
            update();
        }
        inline EBlendingTypes getBlendSource() const
        {
            return BlendSource_;
        }
        
        inline void setBlendTarget(const EBlendingTypes BlendTarget)
        {
            BlendTarget_ = BlendTarget;
            update();
        }
        inline EBlendingTypes getBlendTarget() const
        {
            return BlendTarget_;
        }
        
        inline void setDepthMethod(const ESizeComparisionTypes Method)
        {
            DepthMethod_ = Method;
            update();
        }
        inline ESizeComparisionTypes getDepthMethod() const
        {
            return DepthMethod_;
        }
        
        virtual void setAlphaMethod(const ESizeComparisionTypes Method, f32 AlphaReference);
        
        inline void setAlphaMethod(const ESizeComparisionTypes Method)
        {
            setAlphaMethod(Method, AlphaReference_);
        }
        inline ESizeComparisionTypes getAlphaMethod() const
        {
            return AlphaMethod_;
        }
        inline void setAlphaReference(f32 AlphaReference)
        {
            setAlphaMethod(AlphaMethod_, AlphaReference);
        }
        inline f32 getAlphaReference() const
        {
            return AlphaReference_;
        }
        
        inline void setMaterialCallback(const UserMaterialCallback &MaterialCallback)
        {
            UserMaterialProc_ = MaterialCallback;
        }
        inline UserMaterialCallback getMaterialCallback() const
        {
            return UserMaterialProc_;
        }
        
    protected:
        
        /* === Functions == */
        
        virtual void setDefaultBlending(
            const video::EDefaultBlendingTypes Mode, video::EBlendingTypes &SrcBlend, video::EBlendingTypes &DestBlend
        );
        
        /* === Members === */
        
        color                   ColorDiffuse_;      
        color                   ColorAmbient_;      
        color                   ColorSpecular_;     
        color                   ColorEmission_;     
        
        f32                     Shininess_;         
        f32                     AlphaReference_;    
        f32                     OffsetFactor_;      
        f32                     OffsetUnits_;       
        
        EShadingTypes           Shading_;           
        ESizeComparisionTypes   DepthMethod_;       
        ESizeComparisionTypes   AlphaMethod_;       
        EBlendingTypes          BlendSource_;       
        EBlendingTypes          BlendTarget_;       
        EWireframeTypes         RenderModeFront_;   
        EWireframeTypes         RenderModeBack_;    
        EFaceTypes              RenderFace_;        
        
        bool                    isColorMaterial_;   
        bool                    isLighting_;        
        bool                    isBlending_;        
        bool                    isZBuffer_;         
        bool                    isFog_;             
        bool                    isPolygonOffset_;   
        
        UserMaterialCallback    UserMaterialProc_;
        
    private:
        
        friend class Direct3D9RenderSystem;
        friend class Direct3D11RenderSystem;
        
        /* === Members === */
        
        // Independent video driver references
        void* RefRasterizerState_;
        void* RefDepthStencilState_;
        void* RefBlendState_;
        
};


} // /namespace video

} // /namespace sp


#endif



// ================================================================================