IMeshManipulator.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_I_MESH_MANIPULATOR_HPP_INCLUDED
#define DCPP_I_MESH_MANIPULATOR_HPP_INCLUDED
 
#include <duckcpp/core/engine/IReferenceCounted.hpp>
#include <duckcpp/core/engine/vector3d.hpp>
#include <duckcpp/core/engine/aabbox3d.hpp>
#include <duckcpp/core/engine/matrix4.hpp>
#include <duckcpp/core/engine/IAnimatedMesh.hpp>
#include <duckcpp/core/engine/IMeshBuffer.hpp>
#include <duckcpp/core/engine/SVertexManipulator.hpp>
 
namespace dcpp
{
namespace scene
{
 
    class SMesh;
 
 
    class IMeshManipulator : public virtual IReferenceCounted
    {
    public:
 
 
        virtual void flipSurfaces(IMesh* mesh) const = 0;
 
 
        void setVertexColorAlpha(IMesh* mesh, dcpp::int32_kt alpha) const
        {
            apply(dcpp::scene::SVertexColorSetAlphaManipulator(alpha), mesh);
        }
 
 
        void setVertexColorAlpha(IMeshBuffer* buffer, dcpp::int32_kt alpha) const
        {
            apply(dcpp::scene::SVertexColorSetAlphaManipulator(alpha), buffer);
        }
 
 
        void setVertexColors(IMesh* mesh, dcpp::video::SColor color) const
        {
            apply(dcpp::scene::SVertexColorSetManipulator(color), mesh);
        }
 
 
        void setVertexColors(IMeshBuffer* buffer, dcpp::video::SColor color) const
        {
            apply(dcpp::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 dcpp::nub::vector3df& factor) const
        {
            apply(SVertexPositionScaleManipulator(factor), mesh, true);
        }
 
 
        void scale(IMeshBuffer* buffer, const dcpp::nub::vector3df& factor) const
        {
            apply(SVertexPositionScaleManipulator(factor), buffer, true);
        }
 
 
        DCPP_DEPRECATED void scaleMesh(IMesh* mesh, const dcpp::nub::vector3df& factor) const {return scale(mesh,factor);}
 
 
        void scaleTCoords(dcpp::scene::IMesh* mesh, const dcpp::nub::vector2df& factor, dcpp::uint32_kt level=1) const
        {
            apply(SVertexTCoordsScaleManipulator(factor, level), mesh);
        }
 
 
        void scaleTCoords(dcpp::scene::IMeshBuffer* buffer, const dcpp::nub::vector2df& factor, dcpp::uint32_kt level=1) const
        {
            apply(SVertexTCoordsScaleManipulator(factor, level), buffer);
        }
 
 
        void transform(IMesh* mesh, const dcpp::nub::matrix4& m, dcpp::uint32_kt normalsUpdate = 0, bool normalizeNormals=false) const
        {
            apply(SVertexPositionTransformManipulator(m), mesh, true);
 
            if ( normalsUpdate == 1 )
            {
                dcpp::nub::matrix4 invT;
                if ( m.getInverse(invT) )
                {
                    invT = invT.getTransposed();
                    apply(SVertexNormalRotateScaleManipulator(invT), mesh, false);
                }
            }
            if ( normalizeNormals )
            {
                apply(SVertexNormalizeNormalManipulator(), mesh, false);
            }
        }
 
 
        void transform(IMeshBuffer* buffer, const dcpp::nub::matrix4& m, dcpp::uint32_kt normalsUpdate = 0, bool normalizeNormals=false) const
        {
            apply(SVertexPositionTransformManipulator(m), buffer, true);
 
            if ( normalsUpdate == 1 )
            {
                dcpp::nub::matrix4 invT;
                if ( m.getInverse(invT) )
                {
                    invT = invT.getTransposed();
                    apply(SVertexNormalRotateScaleManipulator(invT), buffer, false);
                }
            }
            if ( normalizeNormals )
            {
                apply(SVertexNormalizeNormalManipulator(), buffer, false);
            }
        }
 
 
        DCPP_DEPRECATED virtual void transformMesh(IMesh* mesh, const dcpp::nub::matrix4& m) const {return transform(mesh,m);}
 
 
        virtual void makePlanarTextureMapping(IMesh* mesh, dcpp::float32_kt resolution=0.001f) const=0;
 
 
        virtual void makePlanarTextureMapping(dcpp::scene::IMeshBuffer* meshbuffer, dcpp::float32_kt resolution=0.001f) const=0;
 
 
        virtual void makePlanarTextureMapping(dcpp::scene::IMesh* mesh,
                dcpp::float32_kt resolutionS, dcpp::float32_kt resolutionT,
                dcpp::uint8_kt axis, const dcpp::nub::vector3df& offset) const=0;
 
 
        virtual void makePlanarTextureMapping(dcpp::scene::IMeshBuffer* buffer,
                dcpp::float32_kt resolutionS, dcpp::float32_kt resolutionT,
                dcpp::uint8_kt axis, const dcpp::nub::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, dcpp::float32_kt tolerance=dcpp::nub::ROUNDING_ERROR_Float32) const = 0;
 
 
        virtual dcpp::int32_kt getPolyCount(IMesh* mesh) const = 0;
 
 
        virtual dcpp::int32_kt getPolyCount(IAnimatedMesh* mesh) const = 0;
 
 
        virtual IAnimatedMesh * createAnimatedMesh(IMesh* mesh,
            dcpp::scene::E_ANIMATED_MESH_TYPE type = dcpp::scene::EAMT_UNKNOWN) const = 0;
 
 
        virtual IMesh* createForsythOptimizedMesh(const IMesh *mesh) const = 0;
 
 
        virtual void heightmapOptimizeMesh(IMesh * const mesh, const dcpp::float32_kt tolerance = dcpp::nub::ROUNDING_ERROR_Float32) const = 0;
 
 
        virtual void heightmapOptimizeMesh(IMeshBuffer * const mb, const dcpp::float32_kt tolerance = dcpp::nub::ROUNDING_ERROR_Float32) 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;
            dcpp::nub::aabbox3df bufferbox;
            for (dcpp::uint32_kt 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;
 
            dcpp::nub::aabbox3df bufferbox;
            for (dcpp::uint32_kt i=0; i<buffer->getVertexCount(); ++i)
            {
                switch (buffer->getVertexType())
                {
                case dcpp::video::EVT_STANDARD:
                    {
                        dcpp::video::S3DVertex* verts = (dcpp::video::S3DVertex*)buffer->getVertices();
                        func(verts[i]);
                    }
                    break;
                case dcpp::video::EVT_2TCOORDS:
                    {
                        dcpp::video::S3DVertex2TCoords* verts = (dcpp::video::S3DVertex2TCoords*)buffer->getVertices();
                        func(verts[i]);
                    }
                    break;
                case dcpp::video::EVT_TANGENTS:
                    {
                        dcpp::video::S3DVertexTangents* verts = (dcpp::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 dcpp
 
#endif