irr::video::SMaterial Class Reference

Struct for holding parameters for a material renderer. More...

#include <SMaterial.h>

Public Member Functions
	SMaterial ()
	Default constructor. Creates a solid, lit material with white colors. More...
	SMaterial (const SMaterial &other)
	Copy constructor. More...
SMaterial &	operator= (const SMaterial &other)
	Assignment operator. More...
core::matrix4 &	getTextureMatrix (u32 i)
	Gets the texture transformation matrix for level i. More...
const core::matrix4 &	getTextureMatrix (u32 i) const
	Gets the immutable texture transformation matrix for level i. More...
void	setTextureMatrix (u32 i, const core::matrix4 &mat)
	Sets the i-th texture transformation matrix. More...
ITexture *	getTexture (u32 i) const
	Gets the i-th texture. More...
void	setTexture (u32 i, ITexture *tex)
	Sets the i-th texture. More...
void	setFlag (E_MATERIAL_FLAG flag, bool value)
	Sets the Material flag to the given value. More...
bool	getFlag (E_MATERIAL_FLAG flag) const
	Gets the Material flag. More...
bool	operator!= (const SMaterial &b) const
	Inequality operator. More...
bool	operator== (const SMaterial &b) const
	Equality operator. More...
bool	isAlphaBlendOperation () const
	Check if material needs alpha blending. More...
bool	isTransparent () const

Public Attributes
SMaterialLayer	TextureLayer [MATERIAL_MAX_TEXTURES]
	Texture layer array. More...
E_MATERIAL_TYPE	MaterialType
	Type of the material. Specifies how everything is blended together. More...
SColor	AmbientColor
	How much ambient light (a global light) is reflected by this material. More...
SColor	DiffuseColor
	How much diffuse light coming from a light source is reflected by this material. More...
SColor	EmissiveColor
	Light emitted by this material. Default is to emit no light. More...
SColor	SpecularColor
	How much specular light (highlights from a light) is reflected. More...
f32	Shininess
	Value affecting the size of specular highlights. More...
f32	MaterialTypeParam
	Free parameter, dependent on the material type. More...
f32	MaterialTypeParam2
	Second free parameter, dependent on the material type. More...
f32	Thickness
	Thickness of non-3dimensional elements such as lines and points. More...
u8	ZBuffer
	Is the ZBuffer enabled? Default: ECFN_LESSEQUAL. More...
u8	AntiAliasing
	Sets the antialiasing mode. More...
u8	ColorMask:4
	Defines the enabled color planes. More...
u8	ColorMaterial:3
	Defines the interpretation of vertex color in the lighting equation. More...
E_BLEND_OPERATION	BlendOperation:4
	Store the blend operation of choice. More...
f32	BlendFactor
	Store the blend factors. More...
u8	PolygonOffsetFactor:3
	DEPRECATED. Will be removed after Irrlicht 1.9. Please use PolygonOffsetDepthBias instead. More...
E_POLYGON_OFFSET	PolygonOffsetDirection:1
	DEPRECATED. Will be removed after Irrlicht 1.9. More...
f32	PolygonOffsetDepthBias
	A constant z-buffer offset for a polygon/line/point. More...
f32	PolygonOffsetSlopeScale
	Variable Z-Buffer offset based on the slope of the polygon. More...
bool	Wireframe:1
	Draw as wireframe or filled triangles? Default: false. More...
bool	PointCloud:1
	Draw as point cloud or filled triangles? Default: false. More...
bool	GouraudShading:1
	Flat or Gouraud shading? Default: true. More...
bool	Lighting:1
	Will this material be lighted? Default: true. More...
E_ZWRITE	ZWriteEnable:2
	Is the zbuffer writable or is it read-only. Default: EZW_AUTO. More...
bool	BackfaceCulling:1
	Is backface culling enabled? Default: true. More...
bool	FrontfaceCulling:1
	Is frontface culling enabled? Default: false. More...
bool	FogEnable:1
	Is fog enabled? Default: false. More...
bool	NormalizeNormals:1
	Should normals be normalized? More...
bool	UseMipMaps:1
	Shall mipmaps be used if available. More...

Detailed Description

Struct for holding parameters for a material renderer.

Definition at line 304 of file SMaterial.h.

Constructor & Destructor Documentation

SMaterial() [1/2]

irr::video::SMaterial::SMaterial ( )

inline

Default constructor. Creates a solid, lit material with white colors.

Definition at line 308 of file SMaterial.h.

                : 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() [2/2]

irr::video::SMaterial::SMaterial ( const SMaterial &  other )

inline

Copy constructor.

Parameters

other

Material to copy from.

Definition at line 323 of file SMaterial.h.

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

Member Function Documentation

getFlag()

bool irr::video::SMaterial::getFlag ( E_MATERIAL_FLAG  flag ) const

inline

Gets the Material flag.

Parameters

flag	The flag to query.

Returns

The current value of the flag.

Definition at line 687 of file SMaterial.h.

                {
                        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;
                }

getTexture()

ITexture* irr::video::SMaterial::getTexture ( u32  i ) const

inline

Gets the i-th texture.

Parameters

i	The desired level.

Returns

Texture for texture level i, if defined, else 0.

Definition at line 587 of file SMaterial.h.

                {
                        return i < MATERIAL_MAX_TEXTURES ? TextureLayer[i].Texture : 0;
                }

getTextureMatrix() [1/2]

core::matrix4& irr::video::SMaterial::getTextureMatrix ( u32  i )

inline

Gets the texture transformation matrix for level i.

Parameters

i	The desired level. Must not be larger than MATERIAL_MAX_TEXTURES

Returns

Texture matrix for texture level i.

Definition at line 558 of file SMaterial.h.

                {
                        return TextureLayer[i].getTextureMatrix();
                }

getTextureMatrix() [2/2]

const core::matrix4& irr::video::SMaterial::getTextureMatrix ( u32  i ) const

inline

Gets the immutable texture transformation matrix for level i.

Parameters

i	The desired level.

Returns

Texture matrix for texture level i, or identity matrix for levels larger than MATERIAL_MAX_TEXTURES.

Definition at line 566 of file SMaterial.h.

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

isAlphaBlendOperation()

bool irr::video::SMaterial::isAlphaBlendOperation ( ) const

inline

Check if material needs alpha blending.

Definition at line 790 of file SMaterial.h.

                {
                        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;
                }

isTransparent()

bool irr::video::SMaterial::isTransparent ( ) const

inline

Check for some fixed-function transparent types. Still used internally, but might be deprecated soon. You probably should not use this anymore, IVideoDriver::needsTransparentRenderPass is more useful in most situations as it asks the material renders directly what they do with the material.

Definition at line 815 of file SMaterial.h.

                {
                        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;
                }

operator!=()

bool irr::video::SMaterial::operator!= ( const SMaterial &  b ) const

inline

Inequality operator.

Parameters

b	Material to compare to.

Returns

True if the materials differ, else false.

Definition at line 743 of file SMaterial.h.

                {
                        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;
                }

operator=()

SMaterial& irr::video::SMaterial::operator= ( const SMaterial &  other )

inline

Assignment operator.

Parameters

other

Material to copy from.

Definition at line 333 of file SMaterial.h.

                {
                        // 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;
                }

operator==()

bool irr::video::SMaterial::operator== ( const SMaterial &  b ) const

inline

Equality operator.

Parameters

b	Material to compare to.

Returns

True if the materials are equal, else false.

Definition at line 786 of file SMaterial.h.

                { return !(b!=*this); }

setFlag()

void irr::video::SMaterial::setFlag ( E_MATERIAL_FLAG  flag, bool  value  )

inline

Sets the Material flag to the given value.

Parameters

flag	The flag to be set.
value	The new value for the flag.

Definition at line 606 of file SMaterial.h.

                {
                        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;
                        }
                }

setTexture()

void irr::video::SMaterial::setTexture ( u32  i, ITexture *  tex  )

inline

Sets the i-th texture.

If i>=MATERIAL_MAX_TEXTURES this setting will be ignored.

Parameters

i	The desired level.
tex	Texture for texture level i.

Definition at line 596 of file SMaterial.h.

                {
                        if (i>=MATERIAL_MAX_TEXTURES)
                                return;
                        TextureLayer[i].Texture = tex;
                }

setTextureMatrix()

void irr::video::SMaterial::setTextureMatrix ( u32  i, const core::matrix4 &  mat  )

inline

Sets the i-th texture transformation matrix.

Parameters

i	The desired level.
mat	Texture matrix for texture level i.

Definition at line 577 of file SMaterial.h.

                {
                        if (i>=MATERIAL_MAX_TEXTURES)
                                return;
                        TextureLayer[i].setTextureMatrix(mat);
                }

Member Data Documentation

AmbientColor

SColor irr::video::SMaterial::AmbientColor

How much ambient light (a global light) is reflected by this material.

The default is full white, meaning objects are completely globally illuminated. Reduce this if you want to see diffuse or specular light effects.

Definition at line 388 of file SMaterial.h.

AntiAliasing

u8 irr::video::SMaterial::AntiAliasing

Sets the antialiasing mode.

Values are chosen from E_ANTI_ALIASING_MODE. Default is EAAM_SIMPLE, i.e. simple multi-sample anti-aliasing.

Definition at line 455 of file SMaterial.h.

BackfaceCulling

bool irr::video::SMaterial::BackfaceCulling

Is backface culling enabled? Default: true.

Definition at line 539 of file SMaterial.h.

BlendFactor

f32 irr::video::SMaterial::BlendFactor

Store the blend factors.

textureBlendFunc/textureBlendFuncSeparate functions should be used to write properly blending factors to this parameter. Due to historical reasons this parameter is not used for material type EMT_ONETEXTURE_BLEND which uses MaterialTypeParam instead for the blend factor. It's generally used only for materials without any blending otherwise (like EMT_SOLID). It's main use is to allow having shader materials which can enable/disable blending after they have been created. When you set this you usually also have to set BlendOperation to a value != EBO_NONE (setting it to EBO_ADD is probably the most common one value).

Definition at line 486 of file SMaterial.h.

BlendOperation

E_BLEND_OPERATION irr::video::SMaterial::BlendOperation

Store the blend operation of choice.

Values to be chosen from E_BLEND_OPERATION.

Definition at line 474 of file SMaterial.h.

ColorMask

u8 irr::video::SMaterial::ColorMask

Defines the enabled color planes.

Values are defined as or'ed values of the E_COLOR_PLANE enum. Only enabled color planes will be rendered to the current render target. Typical use is to disable all colors when rendering only to depth or stencil buffer, or using Red and Green for Stereo rendering.

Definition at line 462 of file SMaterial.h.

ColorMaterial

u8 irr::video::SMaterial::ColorMaterial

Defines the interpretation of vertex color in the lighting equation.

Values should be chosen from E_COLOR_MATERIAL. When lighting is enabled, vertex color can be used instead of the material values for light modulation. This allows to easily change e.g. the diffuse light behavior of each face. The default, ECM_DIFFUSE, will result in a very similar rendering as with lighting turned off, just with light shading.

Definition at line 470 of file SMaterial.h.

DiffuseColor

SColor irr::video::SMaterial::DiffuseColor

How much diffuse light coming from a light source is reflected by this material.

The default is full white.

Definition at line 392 of file SMaterial.h.

EmissiveColor

SColor irr::video::SMaterial::EmissiveColor

Light emitted by this material. Default is to emit no light.

Definition at line 395 of file SMaterial.h.

FogEnable

bool irr::video::SMaterial::FogEnable

Is fog enabled? Default: false.

Definition at line 545 of file SMaterial.h.

FrontfaceCulling

bool irr::video::SMaterial::FrontfaceCulling

Is frontface culling enabled? Default: false.

Definition at line 542 of file SMaterial.h.

GouraudShading

bool irr::video::SMaterial::GouraudShading

Flat or Gouraud shading? Default: true.

Definition at line 528 of file SMaterial.h.

Lighting

bool irr::video::SMaterial::Lighting

Will this material be lighted? Default: true.

Definition at line 531 of file SMaterial.h.

MaterialType

E_MATERIAL_TYPE irr::video::SMaterial::MaterialType

Type of the material. Specifies how everything is blended together.

Definition at line 382 of file SMaterial.h.

MaterialTypeParam

f32 irr::video::SMaterial::MaterialTypeParam

Free parameter, dependent on the material type.

Mostly ignored, used for example in EMT_PARALLAX_MAP_SOLID, EMT_TRANSPARENT_ALPHA_CHANNEL and EMT_ONETEXTURE_BLEND.

Definition at line 437 of file SMaterial.h.

MaterialTypeParam2

f32 irr::video::SMaterial::MaterialTypeParam2

Second free parameter, dependent on the material type.

Mostly ignored.

Definition at line 441 of file SMaterial.h.

NormalizeNormals

bool irr::video::SMaterial::NormalizeNormals

Should normals be normalized?

Always use this if the mesh lit and scaled. Default: false

Definition at line 549 of file SMaterial.h.

PointCloud

bool irr::video::SMaterial::PointCloud

Draw as point cloud or filled triangles? Default: false.

Definition at line 525 of file SMaterial.h.

PolygonOffsetDepthBias

f32 irr::video::SMaterial::PolygonOffsetDepthBias

A constant z-buffer offset for a polygon/line/point.

The range of the value is driver specific. On OpenGL you get units which are multiplied by the smallest value that is guaranteed to produce a resolvable offset. On D3D9 you can pass a range between -1 and 1. But you should likely divide it by the range of the depthbuffer. Like dividing by 65535.0 for a 16 bit depthbuffer. Thought it still might produce too large of a bias. Some article (https://aras-p.info/blog/2008/06/12/depth-bias-and-the-power-of-deceiving-yourself/) recommends multiplying by 2.0*4.8e-7 (and strangely on both 16 bit and 24 bit).

Definition at line 507 of file SMaterial.h.

PolygonOffsetDirection

E_POLYGON_OFFSET irr::video::SMaterial::PolygonOffsetDirection

DEPRECATED. Will be removed after Irrlicht 1.9.

Flag defining the direction the polygon offset is applied to. Can be to front or to back, specified by values from E_POLYGON_OFFSET.

Definition at line 498 of file SMaterial.h.

PolygonOffsetFactor

u8 irr::video::SMaterial::PolygonOffsetFactor

DEPRECATED. Will be removed after Irrlicht 1.9. Please use PolygonOffsetDepthBias instead.

Factor specifying how far the polygon offset should be made. Specifying 0 disables the polygon offset. The direction is specified separately. The factor can be from 0 to 7. Note: This probably never worked on Direct3D9 (was coded for D3D8 which had different value ranges)

Definition at line 493 of file SMaterial.h.

PolygonOffsetSlopeScale

f32 irr::video::SMaterial::PolygonOffsetSlopeScale

Variable Z-Buffer offset based on the slope of the polygon.

For polygons looking flat at a camera you could use 0 (for example in a 2D game) But in most cases you will have polygons rendered at a certain slope. The driver will calculate the slope for you and this value allows to scale that slope. The complete polygon offset is: PolygonOffsetSlopeScale*slope + PolygonOffsetDepthBias A good default here is to use 1.f if you want to push the polygons away from the camera and -1.f to pull them towards the camera.

Definition at line 516 of file SMaterial.h.

Shininess

f32 irr::video::SMaterial::Shininess

Value affecting the size of specular highlights.

A value of 20 is common. If set to 0, no specular highlights are being used. To activate, simply set the shininess of a material to a value in the range [0.5;128]:

sceneNode->getMaterial(0).Shininess = 20.0f;

You can change the color of the highlights using

sceneNode->getMaterial(0).SpecularColor.set(255,255,255,255);

The specular color of the dynamic lights (SLight::SpecularColor) will influence the the highlight color too, but they are set to a useful value by default when creating the light scene node. Here is a simple example on how to use specular highlights:

// load and display mesh
scene::IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(
smgr->getMesh("data/faerie.md2"));
node->setMaterialTexture(0, driver->getTexture("data/Faerie2.pcx")); // set diffuse texture
node->setMaterialFlag(video::EMF_LIGHTING, true); // enable dynamic lighting
node->getMaterial(0).Shininess = 20.0f; // set size of specular highlights

// add white light
scene::ILightSceneNode* light = smgr->addLightSceneNode(0,
        core::vector3df(5,5,5), video::SColorf(1.0f, 1.0f, 1.0f));

Definition at line 432 of file SMaterial.h.

SpecularColor

SColor irr::video::SMaterial::SpecularColor

How much specular light (highlights from a light) is reflected.

The default is to reflect white specular light. See SMaterial::Shininess on how to enable specular lights.

Definition at line 400 of file SMaterial.h.

TextureLayer

SMaterialLayer irr::video::SMaterial::TextureLayer[MATERIAL_MAX_TEXTURES]

Texture layer array.

Definition at line 379 of file SMaterial.h.

Thickness

f32 irr::video::SMaterial::Thickness

Thickness of non-3dimensional elements such as lines and points.

Definition at line 444 of file SMaterial.h.

UseMipMaps

bool irr::video::SMaterial::UseMipMaps

Shall mipmaps be used if available.

Sometimes, disabling mipmap usage can be useful. Default: true

Definition at line 553 of file SMaterial.h.

Wireframe

bool irr::video::SMaterial::Wireframe

Draw as wireframe or filled triangles? Default: false.

The user can access a material flag using

material.Wireframe=true 

or

material.setFlag(EMF_WIREFRAME, true); 

Definition at line 522 of file SMaterial.h.

ZBuffer

u8 irr::video::SMaterial::ZBuffer

Is the ZBuffer enabled? Default: ECFN_LESSEQUAL.

If you want to disable depth test for this material just set this parameter to ECFN_DISABLED. Values are from E_COMPARISON_FUNC.

Definition at line 450 of file SMaterial.h.

ZWriteEnable

E_ZWRITE irr::video::SMaterial::ZWriteEnable

Is the zbuffer writable or is it read-only. Default: EZW_AUTO.

If this parameter is not EZW_OFF, you probably also want to set ZBuffer to values other than ECFN_DISABLED

Definition at line 536 of file SMaterial.h.

---

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

• include/irrlicht/SMaterial.h