SMaterial.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef S_MATERIAL_HPP_INCLUDED
#define S_MATERIAL_HPP_INCLUDED
 
#include <nirtcpp/core/engine/SColor.hpp>
#include <nirtcpp/core/engine/matrix4.hpp>
#include <nirtcpp/core/engine/irrArray.hpp>
#include <nirtcpp/core/engine/irrMath.hpp>
#include <nirtcpp/core/engine/EMaterialTypes.hpp>
#include <nirtcpp/core/engine/EMaterialFlags.hpp>
#include <nirtcpp/core/engine/SMaterialLayer.hpp>
 
namespace nirt
{
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 = _NIRT_MATERIAL_MAX_TEXTURES_;
 
 
    NIRTCPP_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),
            PolygonOffsetDepthBias(0.f), PolygonOffsetSlopeScale(0.f),
            PolygonOffsetFactor(0), PolygonOffsetDirection(EPO_FRONT),
            Wireframe(false), PointCloud(false), GouraudShading(true),
            Lighting(true), ZWriteEnable(EZW_AUTO), BackfaceCulling(true), FrontfaceCulling(false),
            FogEnable(false), NormalizeNormals(false), UseMipMaps(true)
        { }
 
        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:8;
 
 
        f32 BlendFactor;
 
 
        f32 PolygonOffsetDepthBias;
 
 
        f32 PolygonOffsetSlopeScale;
 
 
        u8 PolygonOffsetFactor:3;
 
 
        E_POLYGON_OFFSET PolygonOffsetDirection:2;
 
 
        bool Wireframe:1;
 
        bool PointCloud:1;
 
        bool GouraudShading:1;
 
        bool Lighting:1;
 
 
        E_ZWRITE ZWriteEnable:3;
 
        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;
                    break;
                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 ||
                PolygonOffsetDepthBias != b.PolygonOffsetDepthBias ||
                PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale ||
                PolygonOffsetFactor != b.PolygonOffsetFactor ||
                PolygonOffsetDirection != b.PolygonOffsetDirection ||
                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;
        }
    };
 
    NIRTCPP_API extern SMaterial IdentityMaterial;
} // end namespace video
} // end namespace nirt
 
#endif