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_NEVER=0,
        ECFN_LESSEQUAL=1,
        ECFN_EQUAL=2,
        ECFN_LESS,
        ECFN_NOTEQUAL,
        ECFN_GREATEREQUAL,
        ECFN_GREATER,
        ECFN_ALWAYS
    };

    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 << 12) | (modulate << 8) | (srcFact << 4) | dstFact;
        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 & 0x0000F000) >> 12;
        modulo  = E_MODULATE_FUNC( ( state & 0x00000F00 ) >> 8 );
        srcFact = E_BLEND_FACTOR ( ( state & 0x000000F0 ) >> 4 );
        dstFact = 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
    };


    const u32 MATERIAL_MAX_TEXTURES = _IRR_MATERIAL_MAX_TEXTURES_;

    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),
            PolygonOffsetFactor(0), PolygonOffsetDirection(EPO_FRONT),
            Wireframe(false), PointCloud(false), GouraudShading(true),
            Lighting(true), ZWriteEnable(true), 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; ++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; ++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;
            PolygonOffsetFactor = other.PolygonOffsetFactor;
            PolygonOffsetDirection = other.PolygonOffsetDirection;
            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;


        u8 PolygonOffsetFactor:3;


        E_POLYGON_OFFSET PolygonOffsetDirection:1;


        bool Wireframe:1;

        bool PointCloud:1;

        bool GouraudShading:1;

        bool Lighting:1;


        bool ZWriteEnable:1;

        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; 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; ++i)
                        TextureLayer[i].BilinearFilter = value;
                }
                break;
                case EMF_TRILINEAR_FILTER:
                {
                    for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                        TextureLayer[i].TrilinearFilter = value;
                }
                break;
                case EMF_ANISOTROPIC_FILTER:
                {
                    if (value)
                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                            TextureLayer[i].AnisotropicFilter = 0xFF;
                    else
                        for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++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; ++i)
                    {
                        TextureLayer[i].TextureWrapU = (E_TEXTURE_CLAMP)value;
                        TextureLayer[i].TextureWrapV = (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_POLYGON_OFFSET:
                    PolygonOffsetFactor = value?1:0;
                    PolygonOffsetDirection = EPO_BACK;
                    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_NEVER;
                case EMF_ZWRITE_ENABLE:
                    return ZWriteEnable;
                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[1].TextureWrapU ||
                            TextureLayer[1].TextureWrapV ||
                            TextureLayer[2].TextureWrapU ||
                            TextureLayer[2].TextureWrapV ||
                            TextureLayer[3].TextureWrapU ||
                            TextureLayer[3].TextureWrapV);
                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_POLYGON_OFFSET:
                    return PolygonOffsetFactor != 0;
            }

            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 ||
                PolygonOffsetFactor != b.PolygonOffsetFactor ||
                PolygonOffsetDirection != b.PolygonOffsetDirection ||
                UseMipMaps != b.UseMipMaps;
            for (u32 i=0; (i<MATERIAL_MAX_TEXTURES) && !different; ++i)
            {
                different |= (TextureLayer[i] != b.TextureLayer[i]);
            }
            return different;
        }


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

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

    IRRLICHT_API extern SMaterial IdentityMaterial;

} // end namespace video
} // end namespace irr

#endif