SMaterial.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __S_MATERIAL_H_INCLUDED__
#define __S_MATERIAL_H_INCLUDED__

#include "SColor.h"
#include "matrix4.h"
#include "irrArray.h"
#include "irrMath.h"
#include "EMaterialTypes.h"
#include "EMaterialFlags.h"
#include "SMaterialLayer.h"

namespace irr
{
namespace video
{
        class ITexture;

        enum E_BLEND_FACTOR
        {
                EBF_ZERO        = 0,            
                EBF_ONE,                        
                EBF_DST_COLOR,                  
                EBF_ONE_MINUS_DST_COLOR,        
                EBF_SRC_COLOR,                  
                EBF_ONE_MINUS_SRC_COLOR,        
                EBF_SRC_ALPHA,                  
                EBF_ONE_MINUS_SRC_ALPHA,        
                EBF_DST_ALPHA,                  
                EBF_ONE_MINUS_DST_ALPHA,        
                EBF_SRC_ALPHA_SATURATE          
        };

        enum E_BLEND_OPERATION
        {
                EBO_NONE = 0,   
                EBO_ADD,        
                EBO_SUBTRACT,   
                EBO_REVSUBTRACT,
                EBO_MIN,        
                EBO_MAX,        
                EBO_MIN_FACTOR, 
                EBO_MAX_FACTOR, 
                EBO_MIN_ALPHA,  
                EBO_MAX_ALPHA   
        };

        enum E_MODULATE_FUNC
        {
                EMFN_MODULATE_1X        = 1,
                EMFN_MODULATE_2X        = 2,
                EMFN_MODULATE_4X        = 4
        };

        enum E_COMPARISON_FUNC
        {
                ECFN_DISABLED=0,
                ECFN_LESSEQUAL=1,
                ECFN_EQUAL=2,
                ECFN_LESS,
                ECFN_NOTEQUAL,
                ECFN_GREATEREQUAL,
                ECFN_GREATER,
                ECFN_ALWAYS,
                ECFN_NEVER
        };

        enum E_COLOR_PLANE
        {
                ECP_NONE=0,
                ECP_ALPHA=1,
                ECP_RED=2,
                ECP_GREEN=4,
                ECP_BLUE=8,
                ECP_RGB=14,
                ECP_ALL=15
        };


        enum E_ALPHA_SOURCE
        {
                EAS_NONE=0,
                EAS_VERTEX_COLOR,
                EAS_TEXTURE
        };


        inline f32 pack_textureBlendFunc(const E_BLEND_FACTOR srcFact, const E_BLEND_FACTOR dstFact,
                        const E_MODULATE_FUNC modulate=EMFN_MODULATE_1X, const u32 alphaSource=EAS_TEXTURE)
        {
                const u32 tmp = (alphaSource << 20) | (modulate << 16) | (srcFact << 12) | (dstFact << 8) | (srcFact << 4) | dstFact;
                return FR(tmp);
        }


        inline f32 pack_textureBlendFuncSeparate(const E_BLEND_FACTOR srcRGBFact, const E_BLEND_FACTOR dstRGBFact,
                        const E_BLEND_FACTOR srcAlphaFact, const E_BLEND_FACTOR dstAlphaFact,
                        const E_MODULATE_FUNC modulate=EMFN_MODULATE_1X, const u32 alphaSource=EAS_TEXTURE)
        {
                const u32 tmp = (alphaSource << 20) | (modulate << 16) | (srcAlphaFact << 12) | (dstAlphaFact << 8) | (srcRGBFact << 4) | dstRGBFact;
                return FR(tmp);
        }


        inline void unpack_textureBlendFunc(E_BLEND_FACTOR &srcFact, E_BLEND_FACTOR &dstFact,
                        E_MODULATE_FUNC &modulo, u32& alphaSource, const f32 param)
        {
                const u32 state = IR(param);
                alphaSource = (state & 0x00F00000) >> 20;
                modulo = E_MODULATE_FUNC( ( state & 0x000F0000 ) >> 16 );
                srcFact = E_BLEND_FACTOR ( ( state & 0x000000F0 ) >> 4 );
                dstFact = E_BLEND_FACTOR ( ( state & 0x0000000F ) );
        }


        inline void unpack_textureBlendFuncSeparate(E_BLEND_FACTOR &srcRGBFact, E_BLEND_FACTOR &dstRGBFact,
                        E_BLEND_FACTOR &srcAlphaFact, E_BLEND_FACTOR &dstAlphaFact,
                        E_MODULATE_FUNC &modulo, u32& alphaSource, const f32 param)
        {
                const u32 state = IR(param);
                alphaSource = (state & 0x00F00000) >> 20;
                modulo = E_MODULATE_FUNC( ( state & 0x000F0000 ) >> 16 );
                srcAlphaFact = E_BLEND_FACTOR ( ( state & 0x0000F000 ) >> 12 );
                dstAlphaFact = E_BLEND_FACTOR ( ( state & 0x00000F00 ) >> 8 );
                srcRGBFact = E_BLEND_FACTOR ( ( state & 0x000000F0 ) >> 4 );
                dstRGBFact = E_BLEND_FACTOR ( ( state & 0x0000000F ) );
        }

        inline bool textureBlendFunc_hasAlpha ( const E_BLEND_FACTOR factor )
        {
                switch ( factor )
                {
                        case EBF_SRC_ALPHA:
                        case EBF_ONE_MINUS_SRC_ALPHA:
                        case EBF_DST_ALPHA:
                        case EBF_ONE_MINUS_DST_ALPHA:
                        case EBF_SRC_ALPHA_SATURATE:
                                return true;
                        default:
                                return false;
                }
        }



        enum E_ANTI_ALIASING_MODE
        {
                EAAM_OFF=0,
                EAAM_SIMPLE=1,
                EAAM_QUALITY=3,
                EAAM_LINE_SMOOTH=4,
                EAAM_POINT_SMOOTH=8,
                EAAM_FULL_BASIC=15,

                EAAM_ALPHA_TO_COVERAGE=16
        };


        enum E_COLOR_MATERIAL
        {
                ECM_NONE=0,
                ECM_DIFFUSE,
                ECM_AMBIENT,
                ECM_EMISSIVE,
                ECM_SPECULAR,
                ECM_DIFFUSE_AND_AMBIENT
        };


        enum E_POLYGON_OFFSET
        {

                EPO_BACK=0,

                EPO_FRONT=1
        };

        const c8* const PolygonOffsetDirectionNames[] =
        {
                "Back",
                "Front",
                0
        };

        enum E_ZWRITE
        {
                EZW_OFF = 0,

                EZW_AUTO,

                EZW_ON
        };

        const c8* const ZWriteNames[] =
        {
                "Off",
                "Auto",
                "On",
                0
        };




        const u32 MATERIAL_MAX_TEXTURES = _IRR_MATERIAL_MAX_TEXTURES_;


        IRRLICHT_API extern u32 MATERIAL_MAX_TEXTURES_USED;

        // Note for implementors: Serialization is in CNullDriver
        class SMaterial
        {
        public:
                SMaterial()
                : MaterialType(EMT_SOLID), AmbientColor(255,255,255,255), DiffuseColor(255,255,255,255),
                        EmissiveColor(0,0,0,0), SpecularColor(255,255,255,255),
                        Shininess(0.0f), MaterialTypeParam(0.0f), MaterialTypeParam2(0.0f), Thickness(1.0f),
                        ZBuffer(ECFN_LESSEQUAL), AntiAliasing(EAAM_SIMPLE), ColorMask(ECP_ALL),
                        ColorMaterial(ECM_DIFFUSE), BlendOperation(EBO_NONE), BlendFactor(0.0f),
                        PolygonOffsetFactor(0), PolygonOffsetDirection(EPO_FRONT),
                        PolygonOffsetDepthBias(0.f), PolygonOffsetSlopeScale(0.f),
                        Wireframe(false), PointCloud(false), GouraudShading(true),
                        Lighting(true), ZWriteEnable(EZW_AUTO), BackfaceCulling(true), FrontfaceCulling(false),
                        FogEnable(false), NormalizeNormals(false), UseMipMaps(true)
                { }


                SMaterial(const SMaterial& other)
                {
                        // These pointers are checked during assignment
                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                TextureLayer[i].TextureMatrix = 0;
                        *this = other;
                }


                SMaterial& operator=(const SMaterial& other)
                {
                        // Check for self-assignment!
                        if (this == &other)
                                return *this;

                        MaterialType = other.MaterialType;

                        AmbientColor = other.AmbientColor;
                        DiffuseColor = other.DiffuseColor;
                        EmissiveColor = other.EmissiveColor;
                        SpecularColor = other.SpecularColor;
                        Shininess = other.Shininess;
                        MaterialTypeParam = other.MaterialTypeParam;
                        MaterialTypeParam2 = other.MaterialTypeParam2;
                        Thickness = other.Thickness;
                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                        {
                                TextureLayer[i] = other.TextureLayer[i];
                        }

                        Wireframe = other.Wireframe;
                        PointCloud = other.PointCloud;
                        GouraudShading = other.GouraudShading;
                        Lighting = other.Lighting;
                        ZWriteEnable = other.ZWriteEnable;
                        BackfaceCulling = other.BackfaceCulling;
                        FrontfaceCulling = other.FrontfaceCulling;
                        FogEnable = other.FogEnable;
                        NormalizeNormals = other.NormalizeNormals;
                        ZBuffer = other.ZBuffer;
                        AntiAliasing = other.AntiAliasing;
                        ColorMask = other.ColorMask;
                        ColorMaterial = other.ColorMaterial;
                        BlendOperation = other.BlendOperation;
                        BlendFactor = other.BlendFactor;
                        PolygonOffsetFactor = other.PolygonOffsetFactor;
                        PolygonOffsetDirection = other.PolygonOffsetDirection;
                        PolygonOffsetDepthBias = other.PolygonOffsetDepthBias;
                        PolygonOffsetSlopeScale = other.PolygonOffsetSlopeScale;
                        UseMipMaps = other.UseMipMaps;

                        return *this;
                }

                SMaterialLayer TextureLayer[MATERIAL_MAX_TEXTURES];

                E_MATERIAL_TYPE MaterialType;


                SColor AmbientColor;


                SColor DiffuseColor;

                SColor EmissiveColor;


                SColor SpecularColor;


                f32 Shininess;


                f32 MaterialTypeParam;


                f32 MaterialTypeParam2;

                f32 Thickness;


                u8 ZBuffer;


                u8 AntiAliasing;


                u8 ColorMask:4;


                u8 ColorMaterial:3;


                E_BLEND_OPERATION BlendOperation:4;


                f32 BlendFactor;


                u8 PolygonOffsetFactor:3;


                E_POLYGON_OFFSET PolygonOffsetDirection:1;


                f32 PolygonOffsetDepthBias;


                f32 PolygonOffsetSlopeScale;


                bool Wireframe:1;

                bool PointCloud:1;

                bool GouraudShading:1;

                bool Lighting:1;


                E_ZWRITE ZWriteEnable:2;

                bool BackfaceCulling:1;

                bool FrontfaceCulling:1;

                bool FogEnable:1;


                bool NormalizeNormals:1;


                bool UseMipMaps:1;


                core::matrix4& getTextureMatrix(u32 i)
                {
                        return TextureLayer[i].getTextureMatrix();
                }


                const core::matrix4& getTextureMatrix(u32 i) const
                {
                        if (i<MATERIAL_MAX_TEXTURES)
                                return TextureLayer[i].getTextureMatrix();
                        else
                                return core::IdentityMatrix;
                }


                void setTextureMatrix(u32 i, const core::matrix4& mat)
                {
                        if (i>=MATERIAL_MAX_TEXTURES)
                                return;
                        TextureLayer[i].setTextureMatrix(mat);
                }


                ITexture* getTexture(u32 i) const
                {
                        return i < MATERIAL_MAX_TEXTURES ? TextureLayer[i].Texture : 0;
                }


                void setTexture(u32 i, ITexture* tex)
                {
                        if (i>=MATERIAL_MAX_TEXTURES)
                                return;
                        TextureLayer[i].Texture = tex;
                }


                void setFlag(E_MATERIAL_FLAG flag, bool value)
                {
                        switch (flag)
                        {
                                case EMF_WIREFRAME:
                                        Wireframe = value; break;
                                case EMF_POINTCLOUD:
                                        PointCloud = value; break;
                                case EMF_GOURAUD_SHADING:
                                        GouraudShading = value; break;
                                case EMF_LIGHTING:
                                        Lighting = value; break;
                                case EMF_ZBUFFER:
                                        ZBuffer = value; break;
                                case EMF_ZWRITE_ENABLE:
                                        ZWriteEnable = value ? EZW_AUTO : EZW_OFF; break;
                                case EMF_BACK_FACE_CULLING:
                                        BackfaceCulling = value; break;
                                case EMF_FRONT_FACE_CULLING:
                                        FrontfaceCulling = value; break;
                                case EMF_BILINEAR_FILTER:
                                {
                                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                                TextureLayer[i].BilinearFilter = value;
                                }
                                break;
                                case EMF_TRILINEAR_FILTER:
                                {
                                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                                TextureLayer[i].TrilinearFilter = value;
                                }
                                break;
                                case EMF_ANISOTROPIC_FILTER:
                                {
                                        if (value)
                                                for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                                        TextureLayer[i].AnisotropicFilter = 0xFF;
                                        else
                                                for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                                        TextureLayer[i].AnisotropicFilter = 0;
                                }
                                break;
                                case EMF_FOG_ENABLE:
                                        FogEnable = value; break;
                                case EMF_NORMALIZE_NORMALS:
                                        NormalizeNormals = value; break;
                                case EMF_TEXTURE_WRAP:
                                {
                                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES_USED; ++i)
                                        {
                                                TextureLayer[i].TextureWrapU = (E_TEXTURE_CLAMP)value;
                                                TextureLayer[i].TextureWrapV = (E_TEXTURE_CLAMP)value;
                                                TextureLayer[i].TextureWrapW = (E_TEXTURE_CLAMP)value;
                                        }
                                }
                                break;
                                case EMF_ANTI_ALIASING:
                                        AntiAliasing = value?EAAM_SIMPLE:EAAM_OFF; break;
                                case EMF_COLOR_MASK:
                                        ColorMask = value?ECP_ALL:ECP_NONE; break;
                                case EMF_COLOR_MATERIAL:
                                        ColorMaterial = value?ECM_DIFFUSE:ECM_NONE; break;
                                case EMF_USE_MIP_MAPS:
                                        UseMipMaps = value; break;
                                case EMF_BLEND_OPERATION:
                                        BlendOperation = value?EBO_ADD:EBO_NONE; break;
                                case EMF_BLEND_FACTOR:
                                        break;
                                case EMF_POLYGON_OFFSET:
                                        PolygonOffsetFactor = value?1:0;
                                        PolygonOffsetDirection = EPO_BACK;
                                        PolygonOffsetSlopeScale = value?1.f:0.f;
                                        PolygonOffsetDepthBias = value?1.f:0.f;
                                default:
                                        break;
                        }
                }


                bool getFlag(E_MATERIAL_FLAG flag) const
                {
                        switch (flag)
                        {
                                case EMF_WIREFRAME:
                                        return Wireframe;
                                case EMF_POINTCLOUD:
                                        return PointCloud;
                                case EMF_GOURAUD_SHADING:
                                        return GouraudShading;
                                case EMF_LIGHTING:
                                        return Lighting;
                                case EMF_ZBUFFER:
                                        return ZBuffer!=ECFN_DISABLED;
                                case EMF_ZWRITE_ENABLE:
                                        return ZWriteEnable != EZW_OFF;
                                case EMF_BACK_FACE_CULLING:
                                        return BackfaceCulling;
                                case EMF_FRONT_FACE_CULLING:
                                        return FrontfaceCulling;
                                case EMF_BILINEAR_FILTER:
                                        return TextureLayer[0].BilinearFilter;
                                case EMF_TRILINEAR_FILTER:
                                        return TextureLayer[0].TrilinearFilter;
                                case EMF_ANISOTROPIC_FILTER:
                                        return TextureLayer[0].AnisotropicFilter!=0;
                                case EMF_FOG_ENABLE:
                                        return FogEnable;
                                case EMF_NORMALIZE_NORMALS:
                                        return NormalizeNormals;
                                case EMF_TEXTURE_WRAP:
                                        return !(TextureLayer[0].TextureWrapU ||
                                                        TextureLayer[0].TextureWrapV ||
                                                        TextureLayer[0].TextureWrapW);
                                case EMF_ANTI_ALIASING:
                                        return (AntiAliasing==1);
                                case EMF_COLOR_MASK:
                                        return (ColorMask!=ECP_NONE);
                                case EMF_COLOR_MATERIAL:
                                        return (ColorMaterial != ECM_NONE);
                                case EMF_USE_MIP_MAPS:
                                        return UseMipMaps;
                                case EMF_BLEND_OPERATION:
                                        return BlendOperation != EBO_NONE;
                                case EMF_BLEND_FACTOR:
                                        return BlendFactor != 0.f;
                                case EMF_POLYGON_OFFSET:
                                        return PolygonOffsetFactor != 0 || PolygonOffsetDepthBias != 0.f;
                        }

                        return false;
                }


                inline bool operator!=(const SMaterial& b) const
                {
                        bool different =
                                MaterialType != b.MaterialType ||
                                AmbientColor != b.AmbientColor ||
                                DiffuseColor != b.DiffuseColor ||
                                EmissiveColor != b.EmissiveColor ||
                                SpecularColor != b.SpecularColor ||
                                Shininess != b.Shininess ||
                                MaterialTypeParam != b.MaterialTypeParam ||
                                MaterialTypeParam2 != b.MaterialTypeParam2 ||
                                Thickness != b.Thickness ||
                                Wireframe != b.Wireframe ||
                                PointCloud != b.PointCloud ||
                                GouraudShading != b.GouraudShading ||
                                Lighting != b.Lighting ||
                                ZBuffer != b.ZBuffer ||
                                ZWriteEnable != b.ZWriteEnable ||
                                BackfaceCulling != b.BackfaceCulling ||
                                FrontfaceCulling != b.FrontfaceCulling ||
                                FogEnable != b.FogEnable ||
                                NormalizeNormals != b.NormalizeNormals ||
                                AntiAliasing != b.AntiAliasing ||
                                ColorMask != b.ColorMask ||
                                ColorMaterial != b.ColorMaterial ||
                                BlendOperation != b.BlendOperation ||
                                BlendFactor != b.BlendFactor ||
                                PolygonOffsetFactor != b.PolygonOffsetFactor ||
                                PolygonOffsetDirection != b.PolygonOffsetDirection ||
                                PolygonOffsetDepthBias != b.PolygonOffsetDepthBias ||
                                PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale ||
                                UseMipMaps != b.UseMipMaps
                                ;
                        for (u32 i=0; (i<MATERIAL_MAX_TEXTURES_USED) && !different; ++i)
                        {
                                different |= (TextureLayer[i] != b.TextureLayer[i]);
                        }
                        return different;
                }


                inline bool operator==(const SMaterial& b) const
                { return !(b!=*this); }

                bool isAlphaBlendOperation() const
                {
                        if (BlendOperation != EBO_NONE && BlendFactor != 0.f)
                        {
                                E_BLEND_FACTOR srcRGBFact = EBF_ZERO;
                                E_BLEND_FACTOR dstRGBFact = EBF_ZERO;
                                E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;
                                E_BLEND_FACTOR dstAlphaFact = EBF_ZERO;
                                E_MODULATE_FUNC modulo = EMFN_MODULATE_1X;
                                u32 alphaSource = 0;

                                unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, BlendFactor);

                                if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) ||
                                        textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))
                                {
                                        return true;
                                }
                        }
                        return false;
                }

                bool isTransparent() const
                {
                        if ( MaterialType==EMT_TRANSPARENT_ADD_COLOR ||
                                MaterialType==EMT_TRANSPARENT_ALPHA_CHANNEL ||
                                MaterialType==EMT_TRANSPARENT_VERTEX_ALPHA ||
                                MaterialType==EMT_TRANSPARENT_REFLECTION_2_LAYER )
                                return true;

                        return false;
                }
        };

        IRRLICHT_API extern SMaterial IdentityMaterial;
} // end namespace video
} // end namespace irr

#endif