IMeshBuffer.h

// 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_BUFFER_H_INCLUDED__
#define __I_MESH_BUFFER_H_INCLUDED__
 
#include "IReferenceCounted.h"
#include "SMaterial.h"
#include "aabbox3d.h"
#include "S3DVertex.h"
#include "IVertexDescriptor.h"
#include "CVertexBuffer.h"
#include "CIndexBuffer.h"
#include "EHardwareBufferFlags.h"
#include "EPrimitiveTypes.h"
 
namespace irr
{
namespace scene
{

    class IMeshBuffer : public virtual IReferenceCounted
    {
    public:
        IMeshBuffer(video::IVertexDescriptor* vertexDescriptor) : VertexDescriptor(vertexDescriptor), VertexBufferCompatible(true),
            IndexBuffer(0), PrimitiveType(EPT_TRIANGLES), BoundingBoxNeedsRecalculated(true), UseForHardwareInstancing(false)
        {
        }
 
        virtual ~IMeshBuffer() {}
 
        virtual video::IVertexDescriptor* getVertexDescriptor() const = 0;
 
        virtual bool setVertexDescriptor(video::IVertexDescriptor* vertexDescriptor) = 0;
 
        virtual bool addVertexBuffer(IVertexBuffer* vertexBuffer) = 0;
 
        virtual IVertexBuffer* getVertexBuffer(u32 id = 0) const = 0;
 
        virtual u32 getVertexBufferCount() const = 0;
 
        virtual void removeVertexBuffer(u32 id) = 0;
 
        virtual bool setVertexBuffer(IVertexBuffer* vertexBuffer, u32 id = 0) = 0;

        bool isVertexBufferCompatible() const
        {
            return VertexBufferCompatible;
        }
 
        virtual IIndexBuffer* getIndexBuffer() const = 0;
 
        virtual bool setIndexBuffer(IIndexBuffer* indexBuffer) = 0;
        
        u32 getPrimitiveCount() const
        {
            u32 primitiveCount = 0;
 
            switch (PrimitiveType)
            {
            case EPT_POINTS:
            case EPT_POINT_SPRITES:
                primitiveCount = IndexBuffer->getIndexCount();
                break;
            case scene::EPT_LINE_STRIP:
                primitiveCount = IndexBuffer->getIndexCount() - 1;
                break;
            case scene::EPT_LINE_LOOP:
                primitiveCount = IndexBuffer->getIndexCount();
                break;
            case scene::EPT_LINES:
                primitiveCount = IndexBuffer->getIndexCount() / 2;
                break;
            case scene::EPT_TRIANGLE_STRIP:
                primitiveCount = IndexBuffer->getIndexCount() - 2;
                break;
            case scene::EPT_TRIANGLE_FAN:
                primitiveCount = IndexBuffer->getIndexCount() - 2;
                break;
            case scene::EPT_TRIANGLES:
                primitiveCount = IndexBuffer->getIndexCount() / 3;
                break;
            }
 
            return primitiveCount;
        }

        E_PRIMITIVE_TYPE getPrimitiveType() const
        {
            return PrimitiveType;
        }

        void setPrimitiveType(E_PRIMITIVE_TYPE primitiveType)
        {
            PrimitiveType = primitiveType;
        }
 
        virtual video::E_VERTEX_TYPE getVertexType() const = 0;


        virtual video::SMaterial& getMaterial() = 0;


        virtual const video::SMaterial& getMaterial() const = 0;


        virtual const core::aabbox3df& getBoundingBox() const = 0;


        virtual core::aabbox3df& getBoundingBox() = 0;

        virtual void boundingBoxNeedsRecalculated() = 0;

        virtual void recalculateBoundingBox() = 0;
 
        virtual void append(IVertexBuffer* vertexBuffer, u32 vertexBufferID, IIndexBuffer* indexBuffer) = 0;


        virtual void append(IMeshBuffer* meshBuffer) = 0;

        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex(u32 id = 0) const = 0;

        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const = 0;

        virtual void setHardwareMappingHint(E_HARDWARE_MAPPING pMappingHint, E_BUFFER_TYPE type = EBT_VERTEX_AND_INDEX, u32 id = 0) = 0;

        virtual void setDirty(E_BUFFER_TYPE type = EBT_VERTEX_AND_INDEX, u32 id = 0) = 0;


        virtual u32 getChangedID_Vertex(u32 id = 0) const = 0;


        virtual u32 getChangedID_Index() const = 0;
 
        virtual core::matrix4& getTransformation() = 0;
 
        virtual void setUseForHardwareInstancing(bool b) = 0;
 
        virtual bool useForHardwareInstancing() = 0;
 
    protected:
        video::IVertexDescriptor* VertexDescriptor;
 
        // Inform if mesh buffers store compatible vertex buffers and vertex descriptor.
        bool VertexBufferCompatible;

        core::array<scene::IVertexBuffer*> VertexBuffer;

        scene::IIndexBuffer* IndexBuffer;
 
        // Primitive type.
        E_PRIMITIVE_TYPE PrimitiveType;

        video::SMaterial Material;
 
        // Inform if bounding box need recalculation.
        bool BoundingBoxNeedsRecalculated;

        core::aabbox3d<f32> BoundingBox;
 
        // Transformation.
        core::matrix4 Transformation;
 
        // UseForHardwareInstancing
        bool UseForHardwareInstancing;
    };
 
} // end namespace scene
} // end namespace irr
 
#endif