D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spMeshBuffer.hpp

Go to the documentation of this file.

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

#ifndef __SP_HWBUFFER_MESHBUFFER_H__
#define __SP_HWBUFFER_MESHBUFFER_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spGeometryStructures.hpp"
#include "Base/spMaterialStates.hpp"
#include "Base/spVertexFormat.hpp"
#include "Base/spIndexFormat.hpp"
#include "Base/spMathTriangleCutter.hpp"
#include "RenderSystem/spTextureLayer.hpp"

#include <vector>


namespace sp
{
namespace video
{


class TextureLayer;

class SP_EXPORT MeshBuffer
{
    
    public:
        
        MeshBuffer(const video::VertexFormat* VertexFormat = 0, ERendererDataTypes IndexFormat = DATATYPE_UNSIGNED_INT);
        MeshBuffer(const MeshBuffer &Other, bool isCreateMeshBuffer = true);
        virtual ~MeshBuffer();
        
        /* === Buffer functions === */
        
        virtual io::stringc getIdentifier() const;
        
        MeshBuffer* getReference();
        const MeshBuffer* getReference() const;
        
        bool sortCompare(const MeshBuffer &Other) const;
        
        bool compare(const MeshBuffer &Other) const;
        
        void setVertexFormat(const VertexFormat* Format);
        
        void setIndexFormat(ERendererDataTypes Format);
        
        void saveBackup();
        void loadBackup();
        void clearBackup();
        
        void createVertexBuffer();
        void createIndexBuffer();
        void createMeshBuffer();
        
        void deleteVertexBuffer();
        void deleteIndexBuffer();
        void deleteMeshBuffer();
        
        void updateVertexBuffer();
        void updateIndexBuffer();
        void updateMeshBuffer();
        
        void updateVertexBufferElement(u32 Index);
        void updateIndexBufferElement(u32 Index);
        
        void setPrimitiveType(const ERenderPrimitives Type);
        
        static s32 getPrimitiveSize(const ERenderPrimitives Type);
        
        s32 getPrimitiveSize() const;
        
        bool renderable() const;
        
        /* === Mesh buffer manipulation functions */
        
        u32 addVertex();
        
        void addVertices(const u32 Count);
        
        u32 addVertex(
            const dim::vector3df &Position,
            const dim::vector3df &TexCoord = 0,
            const video::color &Color = 255
        );
        
        u32 addVertex(
            const dim::vector3df &Position,
            const dim::vector3df &Normal,
            const dim::vector3df &TexCoord,
            const video::color &Color = 255,
            const f32 Fog = 0.0f
        );
        
        u32 addVertex(
            const dim::vector3df &Position,
            const dim::vector3df &Normal,
            const std::vector<dim::vector3df> &TexCoordList,
            const video::color &Color = 255,
            const f32 Fog = 0.0f
        );
        
        u32 addVertex(const scene::SMeshVertex3D &VertexData);
        
        u32 addVertex(u32 IndexA, u32 IndexB, u32 IndexC, const dim::vector3df &BarycentricCoord);
        
        bool removeVertex(const u32 Index);
        
        u32 addTriangle();
        
        void addTriangles(const u32 Count);
        
        u32 addTriangle(u32 VertexA, u32 VertexB, u32 VertexC);
        
        u32 addTriangle(const u32 Indices[3]);
        
        u32 addQuadrangle(u32 VertexA, u32 VertexB, u32 VertexC, u32 VertexD);
        
        u32 addQuadrangle(const u32 Indices[4]);
        
        u32 addPrimitiveIndex(u32 Index);
        void addIndices(const u32 Count);
        
        bool removePrimitive(const u32 Index);
        
        void clearVertices();
        void clearIndices();
        
        bool insertMeshBuffer(const MeshBuffer &Other);
        
        void setTriangleIndices(const u32 Index, const u32 (&Indices)[3]);
        
        void getTriangleIndices(const u32 Index, u32 (&Indices)[3]) const;
        
        void setPrimitiveIndex(const u32 Index, const u32 VertexIndex);
        
        u32 getPrimitiveIndex(const u32 Index) const;
        
        scene::SMeshVertex3D getVertex(const u32 Index) const;
        scene::SMeshTriangle3D getTriangle(const u32 Index) const;
        
        dim::triangle3df getTriangleCoords(const u32 Index) const;
        dim::ptriangle3df getTriangleReference(const u32 Index) const;
        
        void flipTriangles();
        
        bool cutTriangle(const u32 Index, const dim::plane3df &ClipPlane);
        
        u32 getIndexCount() const;
        u32 getTriangleCount() const;
        
        /* === Vertex manipulation functions === */
        
        void setVertexAttribute(const u32 Index, const SVertexAttribute &Attrib, const void* AttribData, u32 Size);
        
        void getVertexAttribute(const u32 Index, const SVertexAttribute &Attrib, void* AttribData, u32 Size);
        
        void setVertexCoord(const u32 Index, const dim::vector3df &Coord);
        
        dim::vector3df getVertexCoord(const u32 Index) const;
        
        void setVertexNormal(const u32 Index, const dim::vector3df &Normal);
        
        dim::vector3df getVertexNormal(const u32 Index) const;
        
        void setVertexTangent(const u32 Index, const dim::vector3df &Tangent);
        
        dim::vector3df getVertexTangent(const u32 Index) const;
        
        void setVertexBinormal(const u32 Index, const dim::vector3df &Binormal);
        
        dim::vector3df getVertexBinormal(const u32 Index) const;
        
        void setVertexColor(const u32 Index, const color &Color);
        
        color getVertexColor(const u32 Index) const;
        
        void setVertexTexCoord(const u32 Index, const dim::vector3df &TexCoord, const u8 Layer = TEXTURE_IGNORE);
        
        dim::vector3df getVertexTexCoord(const u32 Index, const u8 Layer = 0) const;
        
        void setVertexFog(const u32 Index, const f32 FogCoord);
        
        f32 getVertexFog(const u32 Index) const;
        
        /* === Mesh manipulation functions === */
        
        virtual void updateNormals(const EShadingTypes Shading = SHADING_GOURAUD);
        
        void updateTangentSpace(
            const u8 TangentLayer = TEXTURE_IGNORE, const u8 BinormalLayer = TEXTURE_IGNORE, bool UpdateNormals = true
        );
        
        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 seperateTriangles();
        
        void paint(const video::color &Color, bool CombineColors = false);
        
        /* === Texture functions === */
        
        TextureLayer* addTexture(
            Texture* Tex = 0, const u8 Layer = TEXLAYER_LAST, const ETextureLayerTypes LayerType = TEXLAYER_DEFAULT
        );
        
        template <class T> T* addTexture(Texture* Tex = 0, const u8 Layer = TEXLAYER_LAST)
        {
            T* NewTexLayer = new T();
            addTextureLayer(NewTexLayer, Tex, Layer);
            return NewTexLayer;
        }
        
        bool removeTexture(const u8 Layer = TEXLAYER_LAST, bool RemoveLayer = true);
        
        u32 removeTexture(Texture* Tex, bool RemoveLayers = true);
        
        void clearTextureLayers();
        
        TextureLayer* getTextureLayer(const u8 Layer, bool SearchLayerIndex = false) const;
        
        void textureTranslate(const u8 Layer, const dim::vector3df &Direction);
        
        void textureTransform(const u8 Layer, const dim::vector3df &Size);
        
        void textureTurn(const u8 Layer, const f32 Rotation);
        
        void setTexture(const u8 Layer, Texture* Tex);
        
        Texture* getTexture(const u8 Layer = 0) const;
        
        void setTextureMatrix(const u8 Layer, const dim::matrix4f &Matrix);
        
        dim::matrix4f getTextureMatrix(const u8 Layer) const;
        
        void setTextureEnv(const u8 Layer, const ETextureEnvTypes Type);
        
        ETextureEnvTypes getTextureEnv(const u8 Layer) const;
        
        void setMappingGen(const u8 Layer, const EMappingGenTypes Type);
        
        EMappingGenTypes getMappingGen(const u8 Layer) const;
        
        void setMappingGenCoords(const u8 Layer, s32 Coords);
        
        s32 getMappingGenCoords(const u8 Layer) const;
        
        std::vector<Texture*> getTextureList() const;
        
        void setTexturesReference(MeshBuffer* Reference);
        
        void setTexturesReference(TextureLayerListType* Reference);
        
        /* === Inline functions === */
        
        inline void setReference(MeshBuffer* ReferenceSurface)
        {
            Reference_ = ReferenceSurface;
        }
        
        inline void setHardwareInstancing(s32 InstanceCount)
        {
            InstanceCount_ = InstanceCount;
        }
        inline s32 getHardwareInstancing() const
        {
            return InstanceCount_;
        }
        
        inline void setName(const io::stringc &Name)
        {
            Name_ = Name;
        }
        inline const io::stringc& getName() const
        {
            return Name_;
        }
        
        inline void* getVertexBufferID() const
        {
            return VertexBuffer_.Reference;
        }
        inline void* getIndexBufferID() const
        {
            return IndexBuffer_.Reference;
        }
        
        inline const dim::UniversalBuffer& getVertexBuffer() const
        {
            return VertexBuffer_.RawBuffer;
        }
        inline const dim::UniversalBuffer& getIndexBuffer() const
        {
            return IndexBuffer_.RawBuffer;
        }
        
        inline const VertexFormat* getVertexFormat() const
        {
            return VertexFormat_;
        }
        inline const IndexFormat* getIndexFormat() const
        {
            return &IndexFormat_;
        }
        
        inline u32 getVertexCount() const
        {
            return VertexBuffer_.RawBuffer.getCount();
        }
        
        inline void setMeshBufferUsage(const EHWBufferUsage Usage)
        {
            setVertexBufferUsage(Usage);
            setIndexBufferUsage(Usage);
        }
        
        inline void setVertexBufferUsage(const EHWBufferUsage Usage)
        {
            VertexBuffer_.Usage = Usage;
        }
        inline EHWBufferUsage getVertexBufferUsage() const
        {
            return VertexBuffer_.Usage;
        }
        
        inline void setIndexBufferUsage(const EHWBufferUsage Usage)
        {
            IndexBuffer_.Usage = Usage;
        }
        inline EHWBufferUsage getIndexBufferUsage() const
        {
            return IndexBuffer_.Usage;
        }
        
        inline void setTextureLayerList(const TextureLayerListType &TextureLayers)
        {
            *TextureLayers_ = TextureLayers;
        }
        inline const TextureLayerListType& getTextureLayerList() const
        {
            return *TextureLayers_;
        }
        
        inline u32 getTextureCount() const
        {
            return TextureLayers_->size();
        }
        
        inline bool hasTexturesReference() const
        {
            return (&OrigTextureLayers_) != TextureLayers_;
        }
        
        inline void setIndexOffset(u32 Offset)
        {
            IndexOffset_ = Offset;
        }
        inline void addIndexOffset(u32 Offset)
        {
            IndexOffset_ += Offset;
        }
        
        inline void setIndexBufferEnable(bool Enable)
        {
            UseIndexBuffer_ = Enable;
        }
        inline bool getIndexBufferEnable() const
        {
            return UseIndexBuffer_;
        }
        
        inline void setUpdateImmediate(bool Enable)
        {
            UpdateImmediate_ = Enable;
        }
        inline bool getUpdateImmediate() const
        {
            return UpdateImmediate_;
        }
        
        inline ERenderPrimitives getPrimitiveType() const
        {
            return PrimitiveType_;
        }
        
    protected:
        
        /* === Structures === */
        
        struct SMeshBufferBackup
        {
            SMeshBufferBackup() :
                BUVertexFormat(0)
            {
            }
            ~SMeshBufferBackup()
            {
            }
            
            /* Members */
            dim::UniversalBuffer BUVertexBuffer;
            dim::UniversalBuffer BUIndexBuffer;
            
            const VertexFormat* BUVertexFormat;
            IndexFormat BUIndexFormat;
        };
        
        struct SBuffer
        {
            SBuffer() :
                Reference   (0              ),
                Validated   (false          ),
                Usage       (HWBUFFER_STATIC)
            {
            }
            SBuffer(const SBuffer &Other) :
                Reference   (0              ),
                RawBuffer   (Other.RawBuffer),
                Validated   (false          ),
                Usage       (Other.Usage    )
            {
            }
            ~SBuffer()
            {
            }
            
            /* Members */
            void* Reference;
            dim::UniversalBuffer RawBuffer;
            bool Validated;
            EHWBufferUsage Usage;
        };
        
        /* === Functions === */
        
        void convertVertexAttribute(
            const dim::UniversalBuffer &OldBuffer, u32 Index, const SVertexAttribute &OldAttrib,
            const SVertexAttribute &NewAttrib, bool isClamp = true
        );
        void fillVertexAttribute(u32 Index, const SVertexAttribute &Attrib);
        
        void setVertexAttributeBarycentric(
            u32 IndexResult, u32 IndexA, u32 IndexB, u32 IndexC,
            const SVertexAttribute &Attrib, const dim::vector3df &BarycentricCoord
        );
        
        virtual void updateNormalsFlat();
        virtual void updateNormalsGouraud();
        
        void checkIndexFormat(ERendererDataTypes &Format);
        
        /* === Inline functions === */
        
        template <typename T, typename D> inline void setDefaultVertexAttribute(
            const ERendererDataTypes Type, s32 MaxSize, u32 Index, const SVertexAttribute &Attrib, const T &Data)
        {
            if (Attrib.Type == Type)
                VertexBuffer_.RawBuffer.setBuffer(Index, Attrib.Offset, (const void*)&Data, sizeof(D) * math::Min(Attrib.Size, MaxSize));
        }
        template <typename T, typename D> inline T getDefaultVertexAttribute(
            const ERendererDataTypes Type, s32 MaxSize, u32 Index, const SVertexAttribute &Attrib) const
        {
            T Data;
            
            if (Attrib.Type == Type)
                VertexBuffer_.RawBuffer.getBuffer(Index, Attrib.Offset, (void*)&Data, sizeof(D) * math::Min(Attrib.Size, MaxSize));
            
            return Data;
        }
        
        template <typename T> inline void addTriangleIndices(const u32 VertexA, const u32 VertexB, const u32 VertexC)
        {
            IndexBuffer_.RawBuffer.add<T>((T)VertexA);
            IndexBuffer_.RawBuffer.add<T>((T)VertexB);
            IndexBuffer_.RawBuffer.add<T>((T)VertexC);
        }
        template <typename T> inline void addQuadrangleIndices(const u32 VertexA, const u32 VertexB, const u32 VertexC, const u32 VertexD)
        {
            IndexBuffer_.RawBuffer.add<T>((T)VertexA);
            IndexBuffer_.RawBuffer.add<T>((T)VertexB);
            IndexBuffer_.RawBuffer.add<T>((T)VertexC);
            IndexBuffer_.RawBuffer.add<T>((T)VertexD);
        }
        
        /* === Members === */
        
        io::stringc Name_;
        
        SBuffer VertexBuffer_;
        SBuffer IndexBuffer_;
        
        const VertexFormat* VertexFormat_;
        IndexFormat IndexFormat_;
        
        MeshBuffer* Reference_;
        
        TextureLayerListType OrigTextureLayers_;
        TextureLayerListType* TextureLayers_;
        
        u32 IndexOffset_;
        s32 InstanceCount_;
        
        ERenderPrimitives PrimitiveType_;
        bool UseIndexBuffer_;
        bool UpdateImmediate_;
        
        SMeshBufferBackup* Backup_;
        
    private:
        
        /* === Functions === */
        
        void setupDefaultBuffers();
        
        void addTextureLayer(TextureLayer* TexLayer, Texture* Tex = 0, const u8 Layer = TEXLAYER_LAST);
        void removeTextureFromLayer(TextureLayerListType::iterator &it, bool RemoveLayer);
        void sortTextureLayers();
        
};


} // /namespace video

} // /namespace sp


#endif



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