irr::video::SOverrideMaterial Struct Reference

#include <SOverrideMaterial.h>

Classes
struct	SMaterialTypeReplacement

Public Member Functions
	SOverrideMaterial ()
	Default constructor. More...
void	reset ()
	disable overrides and reset all flags More...
void	apply (SMaterial &material)
	Apply the enabled overrides. More...

Public Attributes
SMaterial	Material
	The Material values. More...
u32	EnableFlags
	Which values are overridden. More...
bool	EnableLayerFlags [MATERIAL_MAX_TEXTURES]
	For those flags in EnableFlags which affect layers, set which of the layers are affected. More...
bool	EnableTextures [MATERIAL_MAX_TEXTURES]
	Which textures are overridden. More...
bool	EnableLayers [MATERIAL_MAX_TEXTURES]
	Overwrite complete layers (settings of EnableLayerFlags and EnableTextures don't matter then for layer data) More...
u16	EnablePasses
	Set in which render passes the material override is active. More...
bool	Enabled
	Global enable flag, overwritten by the SceneManager in each pass. More...
core::array< SMaterialTypeReplacement >	MaterialTypes
	To overwrite SMaterial::MaterialType. More...

Detailed Description

Definition at line 15 of file SOverrideMaterial.h.

Constructor & Destructor Documentation

SOverrideMaterial()

irr::video::SOverrideMaterial::SOverrideMaterial ( )

inline

Default constructor.

Definition at line 62 of file SOverrideMaterial.h.

                                    : EnableFlags(0), EnablePasses(0), Enabled(false)
                {
                }

Member Function Documentation

apply()

void irr::video::SOverrideMaterial::apply ( SMaterial &  material )

inline

Apply the enabled overrides.

Definition at line 82 of file SOverrideMaterial.h.

                {
                        if (Enabled)
                        {
                                for (u32 i = 0; i < MaterialTypes.size(); ++i)
                                {
                                        const SMaterialTypeReplacement& mtr = MaterialTypes[i];
                                        if (mtr.Original < 0 || (s32)mtr.Original == material.MaterialType)
                                                material.MaterialType = (E_MATERIAL_TYPE)mtr.Replacement;
                                }
                                for (u32 f=0; f<32; ++f)
                                {
                                        const u32 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 ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                                                        {
                                                                if ( EnableLayerFlags[i] )
                                                                {
                                                                        material.TextureLayer[i].BilinearFilter = Material.TextureLayer[i].BilinearFilter;
                                                                }
                                                        }
                                                        break;
                                                case EMF_TRILINEAR_FILTER:
                                                        for ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
                                                        {
                                                                if ( EnableLayerFlags[i] )
                                                                {
                                                                        material.TextureLayer[i].TrilinearFilter = Material.TextureLayer[i].TrilinearFilter;
                                                                }
                                                        }
                                                        break;
                                                case EMF_ANISOTROPIC_FILTER:
                                                        for ( u32 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 ( u32 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(u32 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;
                                        }
                                }
                        }
                }

reset()

void irr::video::SOverrideMaterial::reset ( )

inline

disable overrides and reset all flags

Definition at line 67 of file SOverrideMaterial.h.

                {
                        EnableFlags = 0;
                        EnablePasses = 0;
                        Enabled = false;
                        for (u32 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();
                }

Member Data Documentation

Enabled

bool irr::video::SOverrideMaterial::Enabled

Global enable flag, overwritten by the SceneManager in each pass.

NOTE: This is generally not set by users of the engine, but the Scenemanager uses the EnablePass array and sets Enabled to true if the Override material is enabled in the current pass. As user you generally only set EnablePasses. The exception is when rendering without SceneManager but using draw calls in the VideoDriver.

Definition at line 43 of file SOverrideMaterial.h.

EnableFlags

u32 irr::video::SOverrideMaterial::EnableFlags

Which values are overridden.

OR'ed values from E_MATERIAL_FLAGS.

Definition at line 22 of file SOverrideMaterial.h.

EnableLayerFlags

bool irr::video::SOverrideMaterial::EnableLayerFlags[MATERIAL_MAX_TEXTURES]

For those flags in EnableFlags which affect layers, set which of the layers are affected.

Definition at line 25 of file SOverrideMaterial.h.

EnableLayers

bool irr::video::SOverrideMaterial::EnableLayers[MATERIAL_MAX_TEXTURES]

Overwrite complete layers (settings of EnableLayerFlags and EnableTextures don't matter then for layer data)

Definition at line 31 of file SOverrideMaterial.h.

EnablePasses

u16 irr::video::SOverrideMaterial::EnablePasses

Set in which render passes the material override is active.

OR'ed values from E_SCENE_NODE_RENDER_PASS.

Definition at line 35 of file SOverrideMaterial.h.

EnableTextures

bool irr::video::SOverrideMaterial::EnableTextures[MATERIAL_MAX_TEXTURES]

Which textures are overridden.

Definition at line 28 of file SOverrideMaterial.h.

Material

SMaterial irr::video::SOverrideMaterial::Material

The Material values.

Definition at line 18 of file SOverrideMaterial.h.

MaterialTypes

core::array<SMaterialTypeReplacement> irr::video::SOverrideMaterial::MaterialTypes

To overwrite SMaterial::MaterialType.

Definition at line 59 of file SOverrideMaterial.h.

---

The documentation for this struct was generated from the following file:

• include/irrlicht/SOverrideMaterial.h