IMeshManipulator.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_MESH_MANIPULATOR_H_INCLUDED__
#define __I_MESH_MANIPULATOR_H_INCLUDED__

#include "IReferenceCounted.h"
#include "vector3d.h"
#include "aabbox3d.h"
#include "matrix4.h"
#include "IAnimatedMesh.h"
#include "IMeshBuffer.h"
#include "SVertexManipulator.h"

namespace irr
{
namespace scene
{

        struct SMesh;


        class IMeshManipulator : public virtual IReferenceCounted
        {
        public:


                virtual void flipSurfaces(IMesh* mesh) const = 0;


                void setVertexColorAlpha(IMesh* mesh, s32 alpha) const
                {
                        apply(scene::SVertexColorSetAlphaManipulator(alpha), mesh);
                }


                void setVertexColorAlpha(IMeshBuffer* buffer, s32 alpha) const
                {
                        apply(scene::SVertexColorSetAlphaManipulator(alpha), buffer);
                }


                void setVertexColors(IMesh* mesh, video::SColor color) const
                {
                        apply(scene::SVertexColorSetManipulator(color), mesh);
                }


                void setVertexColors(IMeshBuffer* buffer, video::SColor color) const
                {
                        apply(scene::SVertexColorSetManipulator(color), buffer);
                }


                virtual void recalculateNormals(IMesh* mesh, bool smooth = false,
                                bool angleWeighted = false) const=0;


                virtual void recalculateNormals(IMeshBuffer* buffer,
                                bool smooth = false, bool angleWeighted = false) const=0;


                virtual void recalculateTangents(IMesh* mesh,
                                bool recalculateNormals=false, bool smooth=false,
                                bool angleWeighted=false) const=0;


                virtual void recalculateTangents(IMeshBuffer* buffer,
                                bool recalculateNormals=false, bool smooth=false,
                                bool angleWeighted=false) const=0;


                void scale(IMesh* mesh, const core::vector3df& factor) const
                {
                        apply(SVertexPositionScaleManipulator(factor), mesh, true);
                }


                void scale(IMeshBuffer* buffer, const core::vector3df& factor) const
                {
                        apply(SVertexPositionScaleManipulator(factor), buffer, true);
                }


                _IRR_DEPRECATED_ void scaleMesh(IMesh* mesh, const core::vector3df& factor) const {return scale(mesh,factor);}


                void scaleTCoords(scene::IMesh* mesh, const core::vector2df& factor, u32 level=1) const
                {
                        apply(SVertexTCoordsScaleManipulator(factor, level), mesh);
                }


                void scaleTCoords(scene::IMeshBuffer* buffer, const core::vector2df& factor, u32 level=1) const
                {
                        apply(SVertexTCoordsScaleManipulator(factor, level), buffer);
                }


                void transform(IMesh* mesh, const core::matrix4& m, u32 normalsUpdate = 0) const
                {
                        apply(SVertexPositionTransformManipulator(m), mesh, true);

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


                void transform(IMeshBuffer* buffer, const core::matrix4& m, u32 normalsUpdate = 0) const
                {
                        apply(SVertexPositionTransformManipulator(m), buffer, true);

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


                _IRR_DEPRECATED_ virtual void transformMesh(IMesh* mesh, const core::matrix4& m) const {return transform(mesh,m);}


                virtual void makePlanarTextureMapping(IMesh* mesh, f32 resolution=0.001f) const=0;


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


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


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


                virtual SMesh* createMeshCopy(IMesh* mesh) const = 0;


                virtual IMesh* createMeshWithTangents(IMesh* mesh,
                                bool recalculateNormals=false, bool smooth=false,
                                bool angleWeighted=false, bool recalculateTangents=true) const=0;


                virtual IMesh* createMeshWith2TCoords(IMesh* mesh) const = 0;


                virtual IMesh* createMeshWith1TCoords(IMesh* mesh) const = 0;


                virtual IMesh* createMeshUniquePrimitives(IMesh* mesh) const = 0;


                virtual IMesh* createMeshWelded(IMesh* mesh, f32 tolerance=core::ROUNDING_ERROR_f32) const = 0;


                virtual s32 getPolyCount(IMesh* mesh) const = 0;


                virtual s32 getPolyCount(IAnimatedMesh* mesh) const = 0;


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


                virtual IMesh* createForsythOptimizedMesh(const IMesh *mesh) const = 0;


                virtual void heightmapOptimizeMesh(IMesh * const mesh, const f32 tolerance = core::ROUNDING_ERROR_f32) const = 0;


                virtual void heightmapOptimizeMesh(IMeshBuffer * const mb, const f32 tolerance = core::ROUNDING_ERROR_f32) const = 0;


                template <typename Functor>
                bool apply(const Functor& func, IMeshBuffer* buffer, bool boundingBoxUpdate=false) const
                {
                        return apply_(func, buffer, boundingBoxUpdate, func);
                }



                template <typename Functor>
                bool apply(const Functor& func, IMesh* mesh, bool boundingBoxUpdate=false) const
                {
                        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;
                }

protected:

                template <typename Functor>
                bool apply_(const Functor& func, IMeshBuffer* buffer, bool boundingBoxUpdate, const IVertexManipulator& typeTest) const
                {
                        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;
                }
};

} // end namespace scene
} // end namespace irr


#endif