Irrlicht 3D Engine
IMeshManipulator.h
Go to the documentation of this file.
1 // Copyright (C) 2002-2012 Nikolaus Gebhardt
2 // This file is part of the "Irrlicht Engine".
3 // For conditions of distribution and use, see copyright notice in irrlicht.h
4 
5 #ifndef __I_MESH_MANIPULATOR_H_INCLUDED__
6 #define __I_MESH_MANIPULATOR_H_INCLUDED__
7 
8 #include "IReferenceCounted.h"
9 #include "vector3d.h"
10 #include "aabbox3d.h"
11 #include "matrix4.h"
12 #include "IAnimatedMesh.h"
13 #include "IMeshBuffer.h"
14 #include "SVertexManipulator.h"
15 
16 namespace irr
17 {
18 namespace scene
19 {
20 
21  struct SMesh;
22 
24 
29  class IMeshManipulator : public virtual IReferenceCounted
30  {
31  public:
32 
34 
37  virtual void flipSurfaces(IMesh* mesh) const = 0;
38 
40 
42  void setVertexColorAlpha(IMesh* mesh, s32 alpha) const
43  {
45  }
46 
48 
50  void setVertexColorAlpha(IMeshBuffer* buffer, s32 alpha) const
51  {
53  }
54 
56 
58  void setVertexColors(IMesh* mesh, video::SColor color) const
59  {
61  }
62 
64 
66  void setVertexColors(IMeshBuffer* buffer, video::SColor color) const
67  {
69  }
70 
72 
75  virtual void recalculateNormals(IMesh* mesh, bool smooth = false,
76  bool angleWeighted = false) const=0;
77 
79 
82  virtual void recalculateNormals(IMeshBuffer* buffer,
83  bool smooth = false, bool angleWeighted = false) const=0;
84 
86 
91  virtual void recalculateTangents(IMesh* mesh,
92  bool recalculateNormals=false, bool smooth=false,
93  bool angleWeighted=false) const=0;
94 
96 
101  virtual void recalculateTangents(IMeshBuffer* buffer,
102  bool recalculateNormals=false, bool smooth=false,
103  bool angleWeighted=false) const=0;
104 
106 
108  void scale(IMesh* mesh, const core::vector3df& factor) const
109  {
110  apply(SVertexPositionScaleManipulator(factor), mesh, true);
111  }
112 
114 
116  void scale(IMeshBuffer* buffer, const core::vector3df& factor) const
117  {
118  apply(SVertexPositionScaleManipulator(factor), buffer, true);
119  }
120 
122 
125  _IRR_DEPRECATED_ void scaleMesh(IMesh* mesh, const core::vector3df& factor) const {return scale(mesh,factor);}
126 
128 
131  void scaleTCoords(scene::IMesh* mesh, const core::vector2df& factor, u32 level=1) const
132  {
133  apply(SVertexTCoordsScaleManipulator(factor, level), mesh);
134  }
135 
137 
140  void scaleTCoords(scene::IMeshBuffer* buffer, const core::vector2df& factor, u32 level=1) const
141  {
142  apply(SVertexTCoordsScaleManipulator(factor, level), buffer);
143  }
144 
146 
148  void transform(IMesh* mesh, const core::matrix4& m) const
149  {
151  }
152 
154 
156  void transform(IMeshBuffer* buffer, const core::matrix4& m) const
157  {
158  apply(SVertexPositionTransformManipulator(m), buffer, true);
159  }
160 
162 
165  _IRR_DEPRECATED_ virtual void transformMesh(IMesh* mesh, const core::matrix4& m) const {return transform(mesh,m);}
166 
168 
172  virtual void makePlanarTextureMapping(IMesh* mesh, f32 resolution=0.001f) const=0;
173 
175 
179  virtual void makePlanarTextureMapping(scene::IMeshBuffer* meshbuffer, f32 resolution=0.001f) const=0;
180 
182 
189  virtual void makePlanarTextureMapping(scene::IMesh* mesh,
190  f32 resolutionS, f32 resolutionT,
191  u8 axis, const core::vector3df& offset) const=0;
192 
194 
201  virtual void makePlanarTextureMapping(scene::IMeshBuffer* buffer,
202  f32 resolutionS, f32 resolutionT,
203  u8 axis, const core::vector3df& offset) const=0;
204 
206 
212  virtual SMesh* createMeshCopy(IMesh* mesh) const = 0;
213 
215 
231  virtual IMesh* createMeshWithTangents(IMesh* mesh,
232  bool recalculateNormals=false, bool smooth=false,
233  bool angleWeighted=false, bool recalculateTangents=true) const=0;
234 
236 
241  virtual IMesh* createMeshWith2TCoords(IMesh* mesh) const = 0;
242 
244 
249  virtual IMesh* createMeshWith1TCoords(IMesh* mesh) const = 0;
250 
252 
257  virtual IMesh* createMeshUniquePrimitives(IMesh* mesh) const = 0;
258 
260 
265  virtual IMesh* createMeshWelded(IMesh* mesh, f32 tolerance=core::ROUNDING_ERROR_f32) const = 0;
266 
268 
270  virtual s32 getPolyCount(IMesh* mesh) const = 0;
271 
273 
275  virtual s32 getPolyCount(IAnimatedMesh* mesh) const = 0;
276 
278 
284  virtual IAnimatedMesh * createAnimatedMesh(IMesh* mesh,
286 
288 
296  virtual IMesh* createForsythOptimizedMesh(const IMesh *mesh) const = 0;
297 
299 
309  virtual void heightmapOptimizeMesh(IMesh * const mesh, const f32 tolerance = core::ROUNDING_ERROR_f32) const = 0;
310 
312 
322  virtual void heightmapOptimizeMesh(IMeshBuffer * const mb, const f32 tolerance = core::ROUNDING_ERROR_f32) const = 0;
323 
325 
329  template <typename Functor>
330  bool apply(const Functor& func, IMeshBuffer* buffer, bool boundingBoxUpdate=false) const
331  {
332  return apply_(func, buffer, boundingBoxUpdate, func);
333  }
334 
335 
337 
341  template <typename Functor>
342  bool apply(const Functor& func, IMesh* mesh, bool boundingBoxUpdate=false) const
343  {
344  if (!mesh)
345  return true;
346  bool result = true;
347  core::aabbox3df bufferbox;
348  for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
349  {
350  result &= apply(func, mesh->getMeshBuffer(i), boundingBoxUpdate);
351  if (boundingBoxUpdate)
352  {
353  if (0==i)
354  bufferbox.reset(mesh->getMeshBuffer(i)->getBoundingBox());
355  else
356  bufferbox.addInternalBox(mesh->getMeshBuffer(i)->getBoundingBox());
357  }
358  }
359  if (boundingBoxUpdate)
360  mesh->setBoundingBox(bufferbox);
361  return result;
362  }
363 
364 protected:
366 
371  template <typename Functor>
372  bool apply_(const Functor& func, IMeshBuffer* buffer, bool boundingBoxUpdate, const IVertexManipulator& typeTest) const
373  {
374  if (!buffer)
375  return true;
376 
377  core::aabbox3df bufferbox;
378  for (u32 i=0; i<buffer->getVertexCount(); ++i)
379  {
380  switch (buffer->getVertexType())
381  {
382  case video::EVT_STANDARD:
383  {
384  video::S3DVertex* verts = (video::S3DVertex*)buffer->getVertices();
385  func(verts[i]);
386  }
387  break;
388  case video::EVT_2TCOORDS:
389  {
391  func(verts[i]);
392  }
393  break;
394  case video::EVT_TANGENTS:
395  {
397  func(verts[i]);
398  }
399  break;
400  }
401  if (boundingBoxUpdate)
402  {
403  if (0==i)
404  bufferbox.reset(buffer->getPosition(0));
405  else
406  bufferbox.addInternalPoint(buffer->getPosition(i));
407  }
408  }
409  if (boundingBoxUpdate)
410  buffer->setBoundingBox(bufferbox);
411  return true;
412  }
413 };
414 
415 } // end namespace scene
416 } // end namespace irr
417 
418 
419 #endif
virtual IMesh * createMeshWith2TCoords(IMesh *mesh) const =0
Creates a copy of the mesh, which will only consist of S3DVertex2TCoord vertices.
#define _IRR_DEPRECATED_
Defines a deprecated macro which generates a warning at compile time.
Definition: irrTypes.h:202
virtual void flipSurfaces(IMesh *mesh) const =0
Flips the direction of surfaces.
virtual const core::aabbox3df & getBoundingBox() const =0
Get the axis aligned bounding box of this meshbuffer.
float f32
32 bit floating point variable.
Definition: irrTypes.h:108
virtual void setBoundingBox(const core::aabbox3df &box)=0
Set axis aligned bounding box.
E_ANIMATED_MESH_TYPE
Possible types of meshes.
Definition: IMesh.h:19
Unknown animated mesh type.
Definition: IMesh.h:22
virtual s32 getPolyCount(IMesh *mesh) const =0
Get amount of polygons in mesh.
virtual const core::vector3df & getPosition(u32 i) const =0
returns position of vertex i
Everything in the Irrlicht Engine can be found in this namespace.
Definition: aabbox3d.h:12
Simple implementation of the IMesh interface.
Definition: SMesh.h:18
virtual void recalculateTangents(IMesh *mesh, bool recalculateNormals=false, bool smooth=false, bool angleWeighted=false) const =0
Recalculates tangents, requires a tangent mesh.
Vertex manipulator which scales the position of the vertex.
Vertex with two texture coordinates, video::S3DVertex2TCoords.
Definition: S3DVertex.h:25
void reset(T x, T y, T z)
Resets the bounding box to a one-point box.
Definition: aabbox3d.h:50
void scale(IMeshBuffer *buffer, const core::vector3df &factor) const
Scales the actual meshbuffer, not a scene node.
virtual IMeshBuffer * getMeshBuffer(u32 nr) const =0
Get pointer to a mesh buffer.
Class which holds the geometry of an object.
Definition: IMesh.h:71
unsigned char u8
8 bit unsigned variable.
Definition: irrTypes.h:22
virtual void makePlanarTextureMapping(IMesh *mesh, f32 resolution=0.001f) const =0
Creates a planar texture mapping on the mesh.
const f32 ROUNDING_ERROR_f32
Definition: irrMath.h:50
void transform(IMeshBuffer *buffer, const core::matrix4 &m) const
Applies a transformation to a meshbuffer.
Vertex with two texture coordinates.
Definition: S3DVertex.h:111
virtual u32 getMeshBufferCount() const =0
Get the amount of mesh buffers.
signed int s32
32 bit signed variable.
Definition: irrTypes.h:70
Struct for holding a mesh with a single material.
Definition: IMeshBuffer.h:39
void addInternalBox(const aabbox3d< T > &b)
Adds another bounding box.
Definition: aabbox3d.h:82
Vertex with a tangent and binormal vector, video::S3DVertexTangents.
Definition: S3DVertex.h:31
bool apply(const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate=false) const
Apply a manipulator on the Meshbuffer.
void setVertexColorAlpha(IMeshBuffer *buffer, s32 alpha) const
Sets the alpha vertex color value of the whole mesh to a new value.
virtual IMesh * createMeshWith1TCoords(IMesh *mesh) const =0
Creates a copy of the mesh, which will only consist of S3DVertex vertices.
Vertex manipulator which transforms the position of the vertex.
unsigned int u32
32 bit unsigned variable.
Definition: irrTypes.h:62
Standard vertex type used by the Irrlicht engine, video::S3DVertex.
Definition: S3DVertex.h:21
Interface for vertex manipulators.
virtual _IRR_DEPRECATED_ void transformMesh(IMesh *mesh, const core::matrix4 &m) const
Applies a transformation to a mesh.
bool apply_(const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate, const IVertexManipulator &typeTest) const
Apply a manipulator based on the type of the functor.
Vertex manipulator to set the alpha value of the vertex color to a fixed value.
virtual void recalculateNormals(IMesh *mesh, bool smooth=false, bool angleWeighted=false) const =0
Recalculates all normals of the mesh.
virtual IMesh * createMeshWelded(IMesh *mesh, f32 tolerance=core::ROUNDING_ERROR_f32) const =0
Creates a copy of a mesh with vertices welded.
virtual u32 getVertexCount() const =0
Get amount of vertices in meshbuffer.
standard vertex used by the Irrlicht engine.
Definition: S3DVertex.h:44
virtual void setBoundingBox(const core::aabbox3df &box)=0
Set user-defined axis aligned bounding box.
bool apply(const Functor &func, IMesh *mesh, bool boundingBoxUpdate=false) const
Apply a manipulator on the Mesh.
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.
void setVertexColorAlpha(IMesh *mesh, s32 alpha) const
Sets the alpha vertex color value of the whole mesh to a new value.
virtual IMesh * createMeshUniquePrimitives(IMesh *mesh) const =0
Creates a copy of a mesh with all vertices unwelded.
Vertex manipulator which scales the TCoords of the vertex.
Class representing a 32 bit ARGB color.
Definition: SColor.h:314
4x4 matrix. Mostly used as transformation matrix for 3d calculations.
Definition: matrix4.h:45
void setVertexColors(IMeshBuffer *buffer, video::SColor color) const
Sets the colors of all vertices to one color.
void addInternalPoint(const vector3d< T > &p)
Adds a point to the bounding box.
Definition: aabbox3d.h:74
void scale(IMesh *mesh, const core::vector3df &factor) const
Scales the actual mesh, not a scene node.
_IRR_DEPRECATED_ void scaleMesh(IMesh *mesh, const core::vector3df &factor) const
Scales the actual mesh, not a scene node.
void scaleTCoords(scene::IMeshBuffer *buffer, const core::vector2df &factor, u32 level=1) const
Scale the texture coords of a meshbuffer.
void setVertexColors(IMesh *mesh, video::SColor color) const
Sets the colors of all vertices to one color.
Base class of most objects of the Irrlicht Engine.
virtual const void * getVertices() const =0
Get access to vertex data. The data is an array of vertices.
Vertex manipulator to set color to a fixed color for all vertices.
Interface for an animated mesh.
Definition: IAnimatedMesh.h:20
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.
An interface for easy manipulation of meshes.
void transform(IMesh *mesh, const core::matrix4 &m) const
Applies a transformation to a mesh.
void scaleTCoords(scene::IMesh *mesh, const core::vector2df &factor, u32 level=1) const
Scale the texture coords of a mesh.
virtual void heightmapOptimizeMesh(IMesh *const mesh, const f32 tolerance=core::ROUNDING_ERROR_f32) const =0
Optimize the mesh with an algorithm tuned for heightmaps.
Vertex with a tangent and binormal vector.
Definition: S3DVertex.h:191
virtual SMesh * createMeshCopy(IMesh *mesh) const =0
Clones a static IMesh into a modifiable SMesh.
virtual IMesh * createForsythOptimizedMesh(const IMesh *mesh) const =0
Vertex cache optimization according to the Forsyth paper.
virtual video::E_VERTEX_TYPE getVertexType() const =0
Get type of vertex data which is stored in this meshbuffer.