D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/spSceneMesh.hpp

Go to the documentation of this file.

/*
 * Mesh scene node header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SCENE_MESH_H__
#define __SP_SCENE_MESH_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spMaterialStates.hpp"
#include "Base/spMeshBuffer.hpp"
#include "Base/spViewFrustum.hpp"
#include "Base/spTreeNodeQuad.hpp"
#include "Base/spTreeNodeOct.hpp"
#include "Base/spTreeNodeBSP.hpp"
#include "SceneGraph/spMaterialNode.hpp"
#include "RenderSystem/spTextureBase.hpp"

#include <limits.h>
#include <vector>
#include <list>
#include <map>


namespace sp
{
namespace scene
{


/*
 * Macros
 */

static const u32 MESHBUFFER_IGNORE = UINT_MAX; 


/*
 * Pre-declarations
 */

class Mesh;
class Camera;
class SceneGraph;

struct SPickingObject;
struct SCollisionObject;


class SP_EXPORT Mesh : public MaterialNode
{
    
    public:
        
        Mesh();
        virtual ~Mesh();
        
        /* === Functions === */
        
        virtual bool compareMeshBuffers(const Mesh* Other) const;
        
        /* === Texturing === */
        
        void addTexture(
            video::Texture* Tex, const u8 Layer = video::TEXLAYER_LAST,
            const video::ETextureLayerTypes LayerType = video::TEXLAYER_DEFAULT
        );
        
        void textureAutoMap(
            const u8 Layer, const f32 Density = 1.0, const u32 MeshBufferIndex = MESHBUFFER_IGNORE,
            bool GlobalProjection = true, bool AllowNegativeTexCoords = false
        );
        
        std::vector<video::Texture*> getTextureList() const;
        u32 getTextureCount() const;
        
        /* === Mesh buidling === */
        
        virtual void updateNormals();
        
        void updateTangentSpace(
            const u8 TangentLayer = video::TEXTURE_IGNORE, const u8 BinormalLayer = video::TEXTURE_IGNORE, bool UpdateNormals = true
        );
        
        void updateVertexBuffer();
        void updateIndexBuffer();
        void updateMeshBuffer();
        
        void meshTranslate(const dim::vector3df &Direction);
        void meshTransform(const dim::vector3df &Size);
        void meshTransform(const dim::matrix4f &Matrix);
        void meshTurn(const dim::vector3df &Rotation);
        
        void meshFlip();
        void meshFlip(bool isXAxis, bool isYAxis, bool isZAxis);
        
        void meshFit(const dim::vector3df &Position, const dim::vector3df &Size);
        void meshSpherify(f32 Factor);
        void meshTwist(f32 Rotation);
        
        void mergeFamily(bool isDeleteChildren = true);
        
        dim::vector3df centerOrigin();
        
        void seperateTriangles();
        
        void flipTriangles();
        
        bool getMeshBoundingBox(dim::vector3df &Min, dim::vector3df &Max, bool isGlobal = false) const;
        dim::aabbox3df getMeshBoundingBox(bool isGlobal = false) const;
        f32 getMeshBoundingSphere(bool isGlobal = false) const;
        
        /* === LOD sub meshes (level-of-detail optimization) === */
        
        void addLODSubMesh(Mesh* LODSubMesh, bool isCopyMaterials = false);
        void clearLODSubMeshes();
        
        void setLODSubMeshList(const std::vector<Mesh*> &LODSubMeshList);
        
        void setLODDistance(f32 Distance);
        
        void setLOD(bool Enable);
        
        /* === Mesh buffers === */
        
        video::MeshBuffer* createMeshBuffer(
            const video::VertexFormat* VertexFormat = 0,
            const video::ERendererDataTypes IndexFormat = video::DATATYPE_UNSIGNED_SHORT
        );
        
        void deleteMeshBuffer(const u32 Index);
        
        void deleteMeshBuffers();
        
        void mergeMeshBuffers();
        
        void optimizeTransparency(); // !!! TODO !!!
        
        /* === Vertices === */
        
        u32 getVertexCount() const;
        u32 getTriangleCount() const;
        
        u32 getOrigVertexCount() const;
        u32 getOrigTriangleCount() const;
        
        void setReference(Mesh* ReferenceMesh, bool CopyLocation = false, bool CopyMaterial = false);
        
        Mesh* getReference();
        const Mesh* getReference() const;
        
        void paint(const video::color &Color, bool CombineColors = false);
        
        void setShading(const video::EShadingTypes Type, bool UpdateImmediate = false);
        
        /* === Rendering & copying === */
        
        void copy(const Mesh* Other);
        
        Mesh* copy() const;
        
        virtual void render();
        
        /* === Inline functions === */
        
        inline video::MeshBuffer* getMeshBuffer(const u32 Index)
        {
            return Index < SurfaceList_->size() ? (*SurfaceList_)[Index] : 0;
        }
        inline const video::MeshBuffer* getMeshBuffer(const u32 Index) const
        {
            return Index < SurfaceList_->size() ? (*SurfaceList_)[Index] : 0;
        }
        
        inline video::MeshBuffer* getOrigMeshBuffer(const u32 Index)
        {
            return Index < OrigSurfaceList_.size() ? OrigSurfaceList_[Index] : 0;
        }
        inline const video::MeshBuffer* getOrigMeshBuffer(const u32 Index) const
        {
            return Index < OrigSurfaceList_.size() ? OrigSurfaceList_[Index] : 0;
        }
        
        inline video::MeshBuffer* getLastMeshBuffer()
        {
            return !OrigSurfaceList_.empty() ? OrigSurfaceList_[OrigSurfaceList_.size() - 1] : 0;
        }
        inline const video::MeshBuffer* getLastMeshBuffer() const
        {
            return !OrigSurfaceList_.empty() ? OrigSurfaceList_[OrigSurfaceList_.size() - 1] : 0;
        }
        
        inline u32 getMeshBufferCount() const
        {
            return SurfaceList_->size();
        }
        inline u32 getOrigMeshBufferCount() const
        {
            return OrigSurfaceList_.size();
        }
        
        inline const std::vector<video::MeshBuffer*>& getMeshBufferList() const
        {
            return *SurfaceList_;
        }
        
        inline void setRenderCallback(const video::UserRenderCallback &RenderCallback)
        {
            UserRenderProc_ = RenderCallback;
        }
        
        inline const std::vector<Mesh*>& getLODSubMeshList() const
        {
            return LODSubMeshList_;
        }
        inline f32 getLODDistance() const
        {
            return LODSubMeshDistance_;
        }
        inline bool getLOD() const
        {
            return UseLODSubMeshes_;
        }
        
        inline bool isInstanced() const
        {
            return Reference_ != 0;
        }
        
    protected:
        
        friend class SceneGraph;
        friend class SimpleSceneManager;
        friend struct SCollisionSystemObject;
        friend struct SPickingObject;
        friend struct SCollisionObject;
        
        friend bool cmpObjectMeshes(Mesh* &obj1, Mesh* &obj2);
        
        /* === Functions === */
        
        u32 updateLevelOfDetail();
        
        void copyMesh(Mesh* NewMesh) const;
        
        /* === Members === */
        
        std::vector<video::MeshBuffer*> OrigSurfaceList_;
        std::vector<video::MeshBuffer*> * SurfaceList_, * LODSurfaceList_;
        
        bool UseLODSubMeshes_;
        f32 LODSubMeshDistance_;
        std::vector<Mesh*> LODSubMeshList_;
        
        Mesh* Reference_;
        
        video::UserRenderCallback UserRenderProc_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================