SOverrideMaterial.hpp

// Copyright (C) 2017 Michael Zeilfelder
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef S_OVERRIDE_MATERIAL_HPP_INCLUDED
#define S_OVERRIDE_MATERIAL_HPP_INCLUDED
 
#include <duckcpp/core/engine/SMaterial.hpp>
 
namespace dcpp
{
namespace video
{
 
    class SOverrideMaterial
    {
    public:
        SMaterial Material;
 
 
        dcpp::uint32_kt EnableFlags;
 
        bool EnableLayerFlags[MATERIAL_MAX_TEXTURES];
 
        bool EnableTextures[MATERIAL_MAX_TEXTURES];
 
        bool EnableLayers[MATERIAL_MAX_TEXTURES];
 
 
        dcpp::uint16_kt EnablePasses;
 
 
        bool Enabled;
 
    public:
        class SMaterialTypeReplacement
        {
        public:
            SMaterialTypeReplacement(dcpp::int32_kt original, dcpp::uint32_kt replacement) : Original(original), Replacement(replacement) {}
            SMaterialTypeReplacement(dcpp::uint32_kt replacement) : Original(-1), Replacement(replacement) {}
 
        public:
            dcpp::int32_kt Original;
 
            dcpp::uint32_kt Replacement;
        };
 
    public:
        dcpp::nub::array<SMaterialTypeReplacement> MaterialTypes;
 
    public:
        SOverrideMaterial() : EnableFlags(0), EnablePasses(0), Enabled(false)
        {
        }
 
    public:
        void reset()
        {
            EnableFlags = 0;
            EnablePasses = 0;
            Enabled = false;
            for (dcpp::uint32_kt i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
            {
                EnableLayerFlags[i] = true; // doesn't do anything unless EnableFlags is set, just saying by default all texture layers are affected by flags
                EnableTextures[i] = false;
                EnableLayers[i] = false;
            }
            MaterialTypes.clear();
        }
 
        void apply(SMaterial& material)
        {
            if (Enabled)
            {
                for (dcpp::uint32_kt i = 0; i < MaterialTypes.size(); ++i)
                {
                    const SMaterialTypeReplacement& mtr = MaterialTypes[i];
                    if (mtr.Original < 0 || (dcpp::int32_kt)mtr.Original == material.MaterialType)
                        material.MaterialType = (E_MATERIAL_TYPE)mtr.Replacement;
                }
                for (dcpp::uint32_kt f=0; f<32; ++f)
                {
                    const dcpp::uint32_kt num=(1<<f);
                    if (EnableFlags & num)
                    {
                        switch (num)
                        {
                        case EMF_WIREFRAME: material.Wireframe = Material.Wireframe; break;
                        case EMF_POINTCLOUD: material.PointCloud = Material.PointCloud; break;
                        case EMF_GOURAUD_SHADING: material.GouraudShading = Material.GouraudShading; break;
                        case EMF_LIGHTING: material.Lighting = Material.Lighting; break;
                        case EMF_ZBUFFER: material.ZBuffer = Material.ZBuffer; break;
                        case EMF_ZWRITE_ENABLE: material.ZWriteEnable = Material.ZWriteEnable; break;
                        case EMF_BACK_FACE_CULLING: material.BackFaceCulling = Material.BackFaceCulling; break;
                        case EMF_FRONT_FACE_CULLING: material.FrontfaceCulling = Material.FrontfaceCulling; break;
                        case EMF_BILINEAR_FILTER:
                            for ( dcpp::uint32_kt i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                            {
                                if ( EnableLayerFlags[i] )
                                {
                                    material.TextureLayer[i].BilinearFilter = Material.TextureLayer[i].BilinearFilter;
                                }
                            }
                            break;
                        case EMF_TRILINEAR_FILTER:
                            for ( dcpp::uint32_kt i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                            {
                                if ( EnableLayerFlags[i] )
                                {
                                    material.TextureLayer[i].TrilinearFilter = Material.TextureLayer[i].TrilinearFilter;
                                }
                            }
                            break;
                        case EMF_ANISOTROPIC_FILTER:
                            for ( dcpp::uint32_kt i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                            {
                                if ( EnableLayerFlags[i] )
                                {
                                    material.TextureLayer[i].AnisotropicFilter = Material.TextureLayer[i].AnisotropicFilter;
                                }
                            }
                            break;
                        case EMF_FOG_ENABLE: material.FogEnable = Material.FogEnable; break;
                        case EMF_NORMALIZE_NORMALS: material.NormalizeNormals = Material.NormalizeNormals; break;
                        case EMF_TEXTURE_WRAP:
                            for ( dcpp::uint32_kt i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                            {
                                if ( EnableLayerFlags[i] )
                                {
                                    material.TextureLayer[i].TextureWrapU = Material.TextureLayer[i].TextureWrapU;
                                    material.TextureLayer[i].TextureWrapV = Material.TextureLayer[i].TextureWrapV;
                                    material.TextureLayer[i].TextureWrapW = Material.TextureLayer[i].TextureWrapW;
                                }
                            }
                            break;
                        case EMF_ANTI_ALIASING: material.AntiAliasing = Material.AntiAliasing; break;
                        case EMF_COLOR_MASK: material.ColorMask = Material.ColorMask; break;
                        case EMF_COLOR_MATERIAL: material.ColorMaterial = Material.ColorMaterial; break;
                        case EMF_USE_MIP_MAPS: material.UseMipMaps = Material.UseMipMaps; break;
                        case EMF_BLEND_OPERATION: material.BlendOperation = Material.BlendOperation; break;
                        case EMF_BLEND_FACTOR: material.BlendFactor = Material.BlendFactor; break;
                        case EMF_POLYGON_OFFSET:
                            material.PolygonOffsetDirection = Material.PolygonOffsetDirection;
                            material.PolygonOffsetFactor = Material.PolygonOffsetFactor;
                            material.PolygonOffsetDepthBias = Material.PolygonOffsetDepthBias;
                            material.PolygonOffsetSlopeScale = Material.PolygonOffsetSlopeScale;
                            break;
                        }
                    }
                }
                for(dcpp::uint32_kt i=0; i<MATERIAL_MAX_TEXTURES; ++i )
                {
                    if ( EnableLayers[i] )
                    {
                        material.TextureLayer[i] = Material.TextureLayer[i];
                    }
                    else if ( EnableTextures[i] )
                    {
                        material.TextureLayer[i].Texture = Material.TextureLayer[i].Texture;
                    }
                }
            }
        }
    };
 
} // end namespace video
} // end namespace dcpp
 
#endif // S_OVERRIDE_MATERIAL_HPP_INCLUDED