CBatchingMesh.hpp

// A mesh used for batching many other meshes together, to reduce the number
// of draw calls. Simply add meshes into this one, with given transformations
// or positions, and then call update
 
// TODO: Adapt the VBO interface and integrate setDirty with the current VBO updates.
 
#include "IMesh.h"
#include "SMeshBuffer.h"
 
namespace irr
{
namespace scene
{
 
class CBatchingMesh : public IMesh
{
public:
    CBatchingMesh();
 
    virtual ~CBatchingMesh();
 
    bool isDirty(s32 id=-1);
 
    void update();
 
    void clear();
 
 
    void finalize();
 
 
    core::array<s32> addMesh(IMesh* mesh,
        core::vector3df pos = core::vector3df(0,0,0),
        core::vector3df rot = core::vector3df(0,0,0),
        core::vector3df scale = core::vector3df(1,1,1));
 
 
    core::array<s32> addMesh(IMesh* mesh, const core::matrix4 &transform);
 
 
    s32 addMeshBuffer(IMeshBuffer* buffer,
        core::vector3df pos = core::vector3df(0,0,0),
        core::vector3df rot = core::vector3df(0,0,0),
        core::vector3df scale = core::vector3df(1,1,1));
 
 
    s32 addMeshBuffer(IMeshBuffer* buffer, const core::matrix4 &transform);
 
    void recalculateBoundingBox();
 
 
    core::array<bool> moveMesh(const core::array<s32>& bufferIDs, const core::matrix4 &newMatrix);
 
 
    bool moveMeshBuffer(const s32 id, const core::matrix4 &newMatrix);
 
    IMeshBuffer* getSourceBuffer(s32 id);
 
    core::matrix4 getSourceBufferMatrix(s32 id);
 
    u32 getSourceBufferCount() const;
 
    /* Standard IMesh functions */
 
 
    virtual u32 getMeshBufferCount() const;
 
 
    virtual IMeshBuffer* getMeshBuffer(u32 nr) const;
 
 
    virtual IMeshBuffer* getMeshBuffer( const video::SMaterial &material) const;
 
 
    virtual const core::aabbox3d<f32>& getBoundingBox() const;
 
    virtual void setBoundingBox( const core::aabbox3df& box);
 
 
    virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue);
 
    virtual void setHardwareMappingHint(E_HARDWARE_MAPPING mapping, E_BUFFER_TYPE type);
 
    virtual void setDirty(E_BUFFER_TYPE type);
 
private:
 
    // add a buffer to the source buffers array if it doesn't already exist
    void addSourceBuffer(IMeshBuffer* source);
 
    // updates the vertices in dest buffer from the source one
    void updateDestFromSourceBuffer(u32 id);
 
    // recalculates the bounding box for the given dest buffer
    void recalculateDestBufferBoundingBox(u32 i);
 
    struct SBufferReference
    {
        SBufferReference()
          : SourceBuffer(0), DestReference(0), FirstVertex(0), VertexCount(0),
            FirstIndex(0), IndexCount(0), Initialized(false) { }
 
        IMeshBuffer* SourceBuffer;
        u32 DestReference;
        u32 FirstVertex, VertexCount, FirstIndex, IndexCount;
        core::matrix4 Transform;
        bool Initialized;
    };
 
    struct SMaterialReference
    {
        video::SMaterial Material;
        video::E_VERTEX_TYPE VertexType;
        u32 BufferIndex;
    };
 
    struct SDestBufferReference
    {
        IMeshBuffer* Buffer;
        video::E_VERTEX_TYPE VertexType;
        u32 VertexCount;
        u32 IndexCount;
        bool IsDirty;
    };
 
    core::array<IMeshBuffer*>         SourceBuffers;
 
    core::array<SBufferReference>     BufferReferences;
    core::array<SMaterialReference>   MaterialReferences;
    core::array<SDestBufferReference> DestBuffers;
 
    core::aabbox3d<f32> Box;
 
    bool IsDirty;
 
    bool IsFinal;
};
 
} // namespace scene
} // namespace irr
 
// #endif