irr::scene::IMeshManipulator Class Reference

An interface for easy manipulation of meshes. More...

#include <IMeshManipulator.h>

Inheritance diagram for irr::scene::IMeshManipulator:

Public Member Functions
virtual void	flipSurfaces (IMesh *mesh) const =0
	Flips the direction of surfaces. More...
void	setVertexColorAlpha (IMesh *mesh, s32 alpha) const
	Sets the alpha vertex color value of the whole mesh to a new value. More...
void	setVertexColorAlpha (IMeshBuffer *buffer, s32 alpha) const
	Sets the alpha vertex color value of the whole mesh to a new value. More...
void	setVertexColors (IMesh *mesh, video::SColor color) const
	Sets the colors of all vertices to one color. More...
void	setVertexColors (IMeshBuffer *buffer, video::SColor color) const
	Sets the colors of all vertices to one color. More...
virtual void	recalculateNormals (IMesh *mesh, bool smooth=false, bool angleWeighted=false) const =0
	Recalculates all normals of the mesh. More...
virtual void	recalculateNormals (IMeshBuffer *buffer, bool smooth=false, bool angleWeighted=false) const =0
	Recalculates all normals of the mesh buffer. More...
virtual void	recalculateTangents (IMesh *mesh, bool recalculateNormals=false, bool smooth=false, bool angleWeighted=false) const =0
	Recalculates tangents, requires a tangent mesh. More...
virtual void	recalculateTangents (IMeshBuffer *buffer, bool recalculateNormals=false, bool smooth=false, bool angleWeighted=false) const =0
	Recalculates tangents, requires a tangent mesh buffer. More...
void	scale (IMesh *mesh, const core::vector3df &factor) const
	Scales the actual mesh, not a scene node. More...
void	scale (IMeshBuffer *buffer, const core::vector3df &factor) const
	Scales the actual meshbuffer, not a scene node. More...
_IRR_DEPRECATED_ void	scaleMesh (IMesh *mesh, const core::vector3df &factor) const
	Scales the actual mesh, not a scene node. More...
void	scaleTCoords (scene::IMesh *mesh, const core::vector2df &factor, u32 level=1) const
	Scale the texture coords of a mesh. More...
void	scaleTCoords (scene::IMeshBuffer *buffer, const core::vector2df &factor, u32 level=1) const
	Scale the texture coords of a meshbuffer. More...
void	transform (IMesh *mesh, const core::matrix4 &m, u32 normalsUpdate=0) const
	Applies a transformation to a mesh. More...
void	transform (IMeshBuffer *buffer, const core::matrix4 &m, u32 normalsUpdate=0) const
	Applies a transformation to a meshbuffer. More...
virtual _IRR_DEPRECATED_ void	transformMesh (IMesh *mesh, const core::matrix4 &m) const
	Applies a transformation to a mesh. More...
virtual void	makePlanarTextureMapping (IMesh *mesh, f32 resolution=0.001f) const =0
	Creates a planar texture mapping on the mesh. More...
virtual void	makePlanarTextureMapping (scene::IMeshBuffer *meshbuffer, f32 resolution=0.001f) const =0
	Creates a planar texture mapping on the meshbuffer. More...
virtual void	makePlanarTextureMapping (scene::IMesh *mesh, f32 resolutionS, f32 resolutionT, u8 axis, const core::vector3df &offset) const =0
	Creates a planar texture mapping on the buffer. More...
virtual void	makePlanarTextureMapping (scene::IMeshBuffer *buffer, f32 resolutionS, f32 resolutionT, u8 axis, const core::vector3df &offset) const =0
	Creates a planar texture mapping on the meshbuffer. More...
virtual SMesh *	createMeshCopy (IMesh *mesh) const =0
	Clones a static IMesh into a modifiable SMesh. More...
virtual IMesh *	createMeshWithTangents (IMesh *mesh, bool recalculateNormals=false, bool smooth=false, bool angleWeighted=false, bool recalculateTangents=true) const =0
	Creates a copy of the mesh, which will only consist of S3DVertexTangents vertices. More...
virtual IMesh *	createMeshWith2TCoords (IMesh *mesh) const =0
	Creates a copy of the mesh, which will only consist of S3DVertex2TCoord vertices. More...
virtual IMesh *	createMeshWith1TCoords (IMesh *mesh) const =0
	Creates a copy of the mesh, which will only consist of S3DVertex vertices. More...
virtual IMesh *	createMeshUniquePrimitives (IMesh *mesh) const =0
	Creates a copy of a mesh with all vertices unwelded. More...
virtual IMesh *	createMeshWelded (IMesh *mesh, f32 tolerance=core::ROUNDING_ERROR_f32) const =0
	Creates a copy of a mesh with vertices welded. More...
virtual s32	getPolyCount (IMesh *mesh) const =0
	Get amount of polygons in mesh. More...
virtual s32	getPolyCount (IAnimatedMesh *mesh) const =0
	Get amount of polygons in mesh. More...
virtual IAnimatedMesh *	createAnimatedMesh (IMesh *mesh, scene::E_ANIMATED_MESH_TYPE type=scene::EAMT_UNKNOWN) const =0
	Create a new AnimatedMesh and adds the mesh to it. More...
virtual IMesh *	createForsythOptimizedMesh (const IMesh *mesh) const =0
	Vertex cache optimization according to the Forsyth paper. More...
virtual void	heightmapOptimizeMesh (IMesh *const mesh, const f32 tolerance=core::ROUNDING_ERROR_f32) const =0
	Optimize the mesh with an algorithm tuned for heightmaps. More...
virtual void	heightmapOptimizeMesh (IMeshBuffer *const mb, const f32 tolerance=core::ROUNDING_ERROR_f32) const =0
	Optimize the meshbuffer with an algorithm tuned for heightmaps. More...
template<typename Functor >
bool	apply (const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate=false) const
	Apply a manipulator on the Meshbuffer. More...
template<typename Functor >
bool	apply (const Functor &func, IMesh *mesh, bool boundingBoxUpdate=false) const
	Apply a manipulator on the Mesh. More...
Public Member Functions inherited from irr::IReferenceCounted
	IReferenceCounted ()
	Constructor. More...
virtual	~IReferenceCounted ()
	Destructor. More...
void	grab () const
	Grabs the object. Increments the reference counter by one. More...
bool	drop () const
	Drops the object. Decrements the reference counter by one. More...
s32	getReferenceCount () const
	Get the reference count. More...
const c8 *	getDebugName () const
	Returns the debug name of the object. More...

Protected Member Functions
template<typename Functor >
bool	apply_ (const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate, const IVertexManipulator &typeTest) const
	Apply a manipulator based on the type of the functor. More...
Protected Member Functions inherited from irr::IReferenceCounted
void	setDebugName (const c8 *newName)
	Sets the debug name of the object. More...

Detailed Description

An interface for easy manipulation of meshes.

Scale, set alpha value, flip surfaces, and so on. This exists for fixing problems with wrong imported or exported meshes quickly after loading. It is not intended for doing mesh modifications and/or animations during runtime.

Definition at line 29 of file IMeshManipulator.h.

Member Function Documentation

apply() [1/2]

template<typename Functor >

bool irr::scene::IMeshManipulator::apply ( const Functor &  func, IMeshBuffer *  buffer, bool  boundingBoxUpdate = false  ) const

inline

Apply a manipulator on the Meshbuffer.

Parameters

func	A functor defining the mesh manipulation.
buffer	The Meshbuffer to apply the manipulator to.
boundingBoxUpdate	Specifies if the bounding box should be updated during manipulation.

Returns

True if the functor was successfully applied, else false.

Definition at line 356 of file IMeshManipulator.h.

                {
                        return apply_(func, buffer, boundingBoxUpdate, func);
                }

apply() [2/2]

template<typename Functor >

bool irr::scene::IMeshManipulator::apply ( const Functor &  func, IMesh *  mesh, bool  boundingBoxUpdate = false  ) const

inline

Apply a manipulator on the Mesh.

Parameters

func	A functor defining the mesh manipulation.
mesh	The Mesh to apply the manipulator to.
boundingBoxUpdate	Specifies if the bounding box should be updated during manipulation.

Returns

True if the functor was successfully applied, else false.

Definition at line 368 of file IMeshManipulator.h.

                {
                        if (!mesh)
                                return true;
                        bool result = true;
                        core::aabbox3df bufferbox;
                        for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
                        {
                                result &= apply(func, mesh->getMeshBuffer(i), boundingBoxUpdate);
                                if (boundingBoxUpdate)
                                {
                                        if (0==i)
                                                bufferbox.reset(mesh->getMeshBuffer(i)->getBoundingBox());
                                        else
                                                bufferbox.addInternalBox(mesh->getMeshBuffer(i)->getBoundingBox());
                                }
                        }
                        if (boundingBoxUpdate)
                                mesh->setBoundingBox(bufferbox);
                        return result;
                }

apply_()

template<typename Functor >

bool irr::scene::IMeshManipulator::apply_ ( const Functor &  func, IMeshBuffer *  buffer, bool  boundingBoxUpdate, const IVertexManipulator &  typeTest  ) const

inlineprotected

Apply a manipulator based on the type of the functor.

Parameters

func	A functor defining the mesh manipulation.
buffer	The Meshbuffer to apply the manipulator to.
boundingBoxUpdate	Specifies if the bounding box should be updated during manipulation.
typeTest	Unused parameter, which handles the proper call selection based on the type of the Functor which is passed in two times.

Returns

True if the functor was successfully applied, else false.

Definition at line 398 of file IMeshManipulator.h.

                {
                        if (!buffer)
                                return true;

                        core::aabbox3df bufferbox;
                        for (u32 i=0; i<buffer->getVertexCount(); ++i)
                        {
                                switch (buffer->getVertexType())
                                {
                                case video::EVT_STANDARD:
                                        {
                                                video::S3DVertex* verts = (video::S3DVertex*)buffer->getVertices();
                                                func(verts[i]);
                                        }
                                        break;
                                case video::EVT_2TCOORDS:
                                        {
                                                video::S3DVertex2TCoords* verts = (video::S3DVertex2TCoords*)buffer->getVertices();
                                                func(verts[i]);
                                        }
                                        break;
                                case video::EVT_TANGENTS:
                                        {
                                                video::S3DVertexTangents* verts = (video::S3DVertexTangents*)buffer->getVertices();
                                                func(verts[i]);
                                        }
                                        break;
                                }
                                if (boundingBoxUpdate)
                                {
                                        if (0==i)
                                                bufferbox.reset(buffer->getPosition(0));
                                        else
                                                bufferbox.addInternalPoint(buffer->getPosition(i));
                                }
                        }
                        if (boundingBoxUpdate)
                                buffer->setBoundingBox(bufferbox);
                        return true;
                }

createAnimatedMesh()

virtual IAnimatedMesh* irr::scene::IMeshManipulator::createAnimatedMesh ( IMesh *  mesh, scene::E_ANIMATED_MESH_TYPE  type = scene::EAMT_UNKNOWN  ) const

pure virtual

Create a new AnimatedMesh and adds the mesh to it.

Parameters

mesh	Input mesh
type	The type of the animated mesh to create.

Returns

Newly created animated mesh with mesh as its only content. When you don't need the animated mesh anymore, you should call IAnimatedMesh::drop(). See IReferenceCounted::drop() for more information.

createForsythOptimizedMesh()

virtual IMesh* irr::scene::IMeshManipulator::createForsythOptimizedMesh ( const IMesh *  mesh ) const

pure virtual

Vertex cache optimization according to the Forsyth paper.

More information can be found at http://home.comcast.net/~tom_forsyth/papers/fast_vert_cache_opt.html

The function is thread-safe (read: you can optimize several meshes in different threads).

Parameters

mesh	Source mesh for the operation.

Returns

A new mesh optimized for the vertex cache.

createMeshCopy()

virtual SMesh* irr::scene::IMeshManipulator::createMeshCopy ( IMesh *  mesh ) const

pure virtual

Clones a static IMesh into a modifiable SMesh.

All meshbuffers in the returned SMesh are of type SMeshBuffer or SMeshBufferLightMap.

Parameters

mesh	Mesh to copy.

Returns

Cloned mesh. If you no longer need the cloned mesh, you should call SMesh::drop(). See IReferenceCounted::drop() for more information.

createMeshUniquePrimitives()

virtual IMesh* irr::scene::IMeshManipulator::createMeshUniquePrimitives ( IMesh *  mesh ) const

pure virtual

Creates a copy of a mesh with all vertices unwelded.

Parameters

mesh	Input mesh

Returns

Mesh consisting only of unique faces. All vertices which were previously shared are now duplicated. If you no longer need the cloned mesh, you should call IMesh::drop(). See IReferenceCounted::drop() for more information.

createMeshWelded()

virtual IMesh* irr::scene::IMeshManipulator::createMeshWelded ( IMesh *  mesh, f32  tolerance = core::ROUNDING_ERROR_f32  ) const

pure virtual

Creates a copy of a mesh with vertices welded.

Parameters

mesh	Input mesh
tolerance	The threshold for vertex comparisons.

Returns

Mesh without redundant vertices. If you no longer need the cloned mesh, you should call IMesh::drop(). See IReferenceCounted::drop() for more information.

createMeshWith1TCoords()

virtual IMesh* irr::scene::IMeshManipulator::createMeshWith1TCoords ( IMesh *  mesh ) const

pure virtual

Creates a copy of the mesh, which will only consist of S3DVertex vertices.

Parameters

mesh	Input mesh

Returns

Mesh consisting only of S3DVertex vertices. If you no longer need the cloned mesh, you should call IMesh::drop(). See IReferenceCounted::drop() for more information.

createMeshWith2TCoords()

virtual IMesh* irr::scene::IMeshManipulator::createMeshWith2TCoords ( IMesh *  mesh ) const

pure virtual

Creates a copy of the mesh, which will only consist of S3DVertex2TCoord vertices.

Parameters

mesh	Input mesh

Returns

Mesh consisting only of S3DVertex2TCoord vertices. If you no longer need the cloned mesh, you should call IMesh::drop(). See IReferenceCounted::drop() for more information.

createMeshWithTangents()

virtual IMesh* irr::scene::IMeshManipulator::createMeshWithTangents ( IMesh *  mesh, bool  recalculateNormals = false, bool  smooth = false, bool  angleWeighted = false, bool  recalculateTangents = true  ) const

pure virtual

Creates a copy of the mesh, which will only consist of S3DVertexTangents vertices.

This is useful if you want to draw tangent space normal mapped geometry because it calculates the tangent and binormal data which is needed there.

Parameters

mesh	Input mesh
recalculateNormals	The normals are recalculated if set, otherwise the original ones are kept. Note that keeping the normals may introduce inaccurate tangents if the normals are very different to those calculated from the faces.
smooth	The normals/tangents are smoothed across the meshbuffer's faces if this flag is set.
angleWeighted	Improved smoothing calculation used
recalculateTangents	Whether are actually calculated, or just the mesh with proper type is created.

Returns

Mesh consisting only of S3DVertexTangents vertices. If you no longer need the cloned mesh, you should call IMesh::drop(). See IReferenceCounted::drop() for more information.

flipSurfaces()

virtual void irr::scene::IMeshManipulator::flipSurfaces ( IMesh *  mesh ) const

pure virtual

Flips the direction of surfaces.

Changes backfacing triangles to frontfacing triangles and vice versa.

Parameters

mesh	Mesh on which the operation is performed.

getPolyCount() [1/2]

virtual s32 irr::scene::IMeshManipulator::getPolyCount ( IMesh *  mesh ) const

pure virtual

Get amount of polygons in mesh.

Parameters

mesh	Input mesh

Returns

Number of polygons in mesh.

getPolyCount() [2/2]

virtual s32 irr::scene::IMeshManipulator::getPolyCount ( IAnimatedMesh *  mesh ) const

pure virtual

Get amount of polygons in mesh.

Parameters

mesh	Input mesh

Returns

Number of polygons in mesh.

heightmapOptimizeMesh() [1/2]

virtual void irr::scene::IMeshManipulator::heightmapOptimizeMesh ( IMesh *const  mesh, const f32  tolerance = core::ROUNDING_ERROR_f32  ) const

pure virtual

Optimize the mesh with an algorithm tuned for heightmaps.

This differs from usual simplification methods in two ways:

• it's intended to be lossless
• it has special care for the borders, which are useful with heightmap tiles

This function is thread-safe. Remember to weld afterwards - this function only moves vertices, it does not weld.

Parameters

mesh	Mesh to operate on.

heightmapOptimizeMesh() [2/2]

virtual void irr::scene::IMeshManipulator::heightmapOptimizeMesh ( IMeshBuffer *const  mb, const f32  tolerance = core::ROUNDING_ERROR_f32  ) const

pure virtual

Optimize the meshbuffer with an algorithm tuned for heightmaps.

This differs from usual simplification methods in two ways:

• it's intended to be lossless
• it has special care for the borders, which are useful with heightmap tiles

This function is thread-safe. Remember to weld afterward - this function only moves vertices, it does not weld.

Parameters

mb	Meshbuffer to operate on.

makePlanarTextureMapping() [1/4]

virtual void irr::scene::IMeshManipulator::makePlanarTextureMapping ( IMesh *  mesh, f32  resolution = 0.001f  ) const

pure virtual

Creates a planar texture mapping on the mesh.

Parameters

mesh	Mesh on which the operation is performed.
resolution	resolution of the planar mapping. This is the value specifying which is the relation between world space and texture coordinate space.

makePlanarTextureMapping() [2/4]

virtual void irr::scene::IMeshManipulator::makePlanarTextureMapping ( scene::IMeshBuffer *  meshbuffer, f32  resolution = 0.001f  ) const

pure virtual

Creates a planar texture mapping on the meshbuffer.

Parameters

meshbuffer	Buffer on which the operation is performed.
resolution	resolution of the planar mapping. This is the value specifying which is the relation between world space and texture coordinate space.

makePlanarTextureMapping() [3/4]

virtual void irr::scene::IMeshManipulator::makePlanarTextureMapping ( scene::IMesh *  mesh, f32  resolutionS, f32  resolutionT, u8  axis, const core::vector3df &  offset  ) const

pure virtual

Creates a planar texture mapping on the buffer.

This method is currently implemented towards the LWO planar mapping. A more general biasing might be required.

Parameters

mesh	Mesh on which the operation is performed.
resolutionS	Resolution of the planar mapping in horizontal direction. This is the ratio between object space and texture space.
resolutionT	Resolution of the planar mapping in vertical direction. This is the ratio between object space and texture space.
axis	The axis along which the texture is projected. The allowed values are 0 (X), 1(Y), and 2(Z).
offset	Vector added to the vertex positions (in object coordinates).

makePlanarTextureMapping() [4/4]

virtual void irr::scene::IMeshManipulator::makePlanarTextureMapping ( scene::IMeshBuffer *  buffer, f32  resolutionS, f32  resolutionT, u8  axis, const core::vector3df &  offset  ) const

pure virtual

Creates a planar texture mapping on the meshbuffer.

This method is currently implemented towards the LWO planar mapping. A more general biasing might be required.

Parameters

buffer	Buffer on which the operation is performed.
resolutionS	Resolution of the planar mapping in horizontal direction. This is the ratio between object space and texture space.
resolutionT	Resolution of the planar mapping in vertical direction. This is the ratio between object space and texture space.
axis	The axis along which the texture is projected. The allowed values are 0 (X), 1(Y), and 2(Z).
offset	Vector added to the vertex positions (in object coordinates).

recalculateNormals() [1/2]

virtual void irr::scene::IMeshManipulator::recalculateNormals ( IMesh *  mesh, bool  smooth = false, bool  angleWeighted = false  ) const

pure virtual

Recalculates all normals of the mesh.

Parameters

mesh	Mesh on which the operation is performed.
smooth	If the normals shall be smoothed.
angleWeighted	If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision.

recalculateNormals() [2/2]

virtual void irr::scene::IMeshManipulator::recalculateNormals ( IMeshBuffer *  buffer, bool  smooth = false, bool  angleWeighted = false  ) const

pure virtual

Recalculates all normals of the mesh buffer.

Parameters

buffer	Mesh buffer on which the operation is performed.
smooth	If the normals shall be smoothed.
angleWeighted	If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision.

recalculateTangents() [1/2]

virtual void irr::scene::IMeshManipulator::recalculateTangents ( IMesh *  mesh, bool  recalculateNormals = false, bool  smooth = false, bool  angleWeighted = false  ) const

pure virtual

Recalculates tangents, requires a tangent mesh.

Parameters

mesh	Mesh on which the operation is performed.
recalculateNormals	If the normals shall be recalculated, otherwise original normals of the mesh are used unchanged.
smooth	If the normals shall be smoothed.
angleWeighted	If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision.

recalculateTangents() [2/2]

virtual void irr::scene::IMeshManipulator::recalculateTangents ( IMeshBuffer *  buffer, bool  recalculateNormals = false, bool  smooth = false, bool  angleWeighted = false  ) const

pure virtual

Recalculates tangents, requires a tangent mesh buffer.

Parameters

buffer	Meshbuffer on which the operation is performed.
recalculateNormals	If the normals shall be recalculated, otherwise original normals of the buffer are used unchanged.
smooth	If the normals shall be smoothed.
angleWeighted	If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision.

scale() [1/2]

void irr::scene::IMeshManipulator::scale ( IMesh *  mesh, const core::vector3df &  factor  ) const

inline

Scales the actual mesh, not a scene node.

Parameters

mesh	Mesh on which the operation is performed.
factor	Scale factor for each axis.

Definition at line 108 of file IMeshManipulator.h.

                {
                        apply(SVertexPositionScaleManipulator(factor), mesh, true);
                }

scale() [2/2]

void irr::scene::IMeshManipulator::scale ( IMeshBuffer *  buffer, const core::vector3df &  factor  ) const

inline

Scales the actual meshbuffer, not a scene node.

Parameters

buffer	Meshbuffer on which the operation is performed.
factor	Scale factor for each axis.

Definition at line 116 of file IMeshManipulator.h.

                {
                        apply(SVertexPositionScaleManipulator(factor), buffer, true);
                }

scaleMesh()

_IRR_DEPRECATED_ void irr::scene::IMeshManipulator::scaleMesh ( IMesh *  mesh, const core::vector3df &  factor  ) const

inline

Scales the actual mesh, not a scene node.

Deprecated:

Use scale() instead. This method may be removed by Irrlicht 1.9

Parameters

mesh	Mesh on which the operation is performed.
factor	Scale factor for each axis.

Definition at line 125 of file IMeshManipulator.h.

{return scale(mesh,factor);}

scaleTCoords() [1/2]

void irr::scene::IMeshManipulator::scaleTCoords ( scene::IMesh *  mesh, const core::vector2df &  factor, u32  level = 1  ) const

inline

Scale the texture coords of a mesh.

Parameters

mesh	Mesh on which the operation is performed.
factor	Vector which defines the scale for each axis.
level	Number of texture coord, starting from 1. Support for level 2 exists for LightMap buffers.

Definition at line 131 of file IMeshManipulator.h.

                {
                        apply(SVertexTCoordsScaleManipulator(factor, level), mesh);
                }

scaleTCoords() [2/2]

void irr::scene::IMeshManipulator::scaleTCoords ( scene::IMeshBuffer *  buffer, const core::vector2df &  factor, u32  level = 1  ) const

inline

Scale the texture coords of a meshbuffer.

Parameters

buffer	Meshbuffer on which the operation is performed.
factor	Vector which defines the scale for each axis.
level	Number of texture coord, starting from 1. Support for level 2 exists for LightMap buffers.

Definition at line 140 of file IMeshManipulator.h.

                {
                        apply(SVertexTCoordsScaleManipulator(factor, level), buffer);
                }

setVertexColorAlpha() [1/2]

void irr::scene::IMeshManipulator::setVertexColorAlpha ( IMesh *  mesh, s32  alpha  ) const

inline

Sets the alpha vertex color value of the whole mesh to a new value.

Parameters

mesh	Mesh on which the operation is performed.
alpha	New alpha value. Must be a value between 0 and 255.

Definition at line 42 of file IMeshManipulator.h.

                {
                        apply(scene::SVertexColorSetAlphaManipulator(alpha), mesh);
                }

setVertexColorAlpha() [2/2]

void irr::scene::IMeshManipulator::setVertexColorAlpha ( IMeshBuffer *  buffer, s32  alpha  ) const

inline

Sets the alpha vertex color value of the whole mesh to a new value.

Parameters

buffer	Meshbuffer on which the operation is performed.
alpha	New alpha value. Must be a value between 0 and 255.

Definition at line 50 of file IMeshManipulator.h.

                {
                        apply(scene::SVertexColorSetAlphaManipulator(alpha), buffer);
                }

setVertexColors() [1/2]

void irr::scene::IMeshManipulator::setVertexColors ( IMesh *  mesh, video::SColor  color  ) const

inline

Sets the colors of all vertices to one color.

Parameters

mesh	Mesh on which the operation is performed.
color	New color.

Definition at line 58 of file IMeshManipulator.h.

                {
                        apply(scene::SVertexColorSetManipulator(color), mesh);
                }

setVertexColors() [2/2]

void irr::scene::IMeshManipulator::setVertexColors ( IMeshBuffer *  buffer, video::SColor  color  ) const

inline

Sets the colors of all vertices to one color.

Parameters

buffer	Meshbuffer on which the operation is performed.
color	New color.

Definition at line 66 of file IMeshManipulator.h.

                {
                        apply(scene::SVertexColorSetManipulator(color), buffer);
                }

transform() [1/2]

void irr::scene::IMeshManipulator::transform ( IMesh *  mesh, const core::matrix4 &  m, u32  normalsUpdate = 0  ) const

inline

Applies a transformation to a mesh.

Parameters

mesh	Mesh on which the operation is performed.
m	transformation matrix.
normalsUpdate	When 0 - don't update normals. When 1 - update normals with inverse transposed of the transformation matrix

Definition at line 151 of file IMeshManipulator.h.

                {
                        apply(SVertexPositionTransformManipulator(m), mesh, true);

                        if ( normalsUpdate == 1 )
                        {
                                core::matrix4 invT;
                                if ( m.getInverse(invT) )
                                {
                                        invT = invT.getTransposed();
                                        apply(SVertexNormalTransformManipulator(invT), mesh, false);
                                }
                        }
                }

transform() [2/2]

void irr::scene::IMeshManipulator::transform ( IMeshBuffer *  buffer, const core::matrix4 &  m, u32  normalsUpdate = 0  ) const

inline

Applies a transformation to a meshbuffer.

Parameters

buffer	Meshbuffer on which the operation is performed.
m	transformation matrix.
normalsUpdate	When 0 - don't update normals. When 1 - update normals with inverse transposed of the transformation matrix

Definition at line 172 of file IMeshManipulator.h.

                {
                        apply(SVertexPositionTransformManipulator(m), buffer, true);

                        if ( normalsUpdate == 1 )
                        {
                                core::matrix4 invT;
                                if ( m.getInverse(invT) )
                                {
                                        invT = invT.getTransposed();
                                        apply(SVertexNormalTransformManipulator(invT), buffer, false);
                                }
                        }
                }

transformMesh()

virtual _IRR_DEPRECATED_ void irr::scene::IMeshManipulator::transformMesh ( IMesh *  mesh, const core::matrix4 &  m  ) const

inlinevirtual

Applies a transformation to a mesh.

Deprecated:

Use transform() instead. This method may be removed by Irrlicht 1.9

Parameters

mesh	Mesh on which the operation is performed.
m	transformation matrix.

Definition at line 191 of file IMeshManipulator.h.

{return transform(mesh,m);}

---

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

• include/irrlicht/IMeshManipulator.h