IMeshBuffer.h

Go to the documentation of this file.

#ifndef __I_MESH_BUFFER_H_INCLUDED__
#define __I_MESH_BUFFER_H_INCLUDED__
 
#include "aabbox3d.h"
#include "S3DVertex.h"
#include "EPrimitiveTypes.h"
#include "EIndexType.h"
#include "SPipeline.h"
#include "SIndirectBuffer.h"
#include <vector>
 
namespace saga
{
 
namespace video
{
  class IVideoDriver;
}
 
namespace scene
{
  using MeshBufferID = std::uint32_t;
 
 
  class IMeshBuffer
  {
  public:
    virtual ~IMeshBuffer() {}
 
    virtual bool isGPUBuffer() const = 0;
 
 
    virtual std::uint64_t getID() const = 0;
 
 
    virtual void buildBuffer(video::IVideoDriver& driver, const video::PipelineHandle pipeline) = 0;
 
 
    virtual const void* getData(const video::PipelineHandle pipeline) const = 0;
 
 
    virtual std::size_t getSize(const video::PipelineHandle pipeline) const = 0;
 
 
    virtual void* getVertices() = 0;
 
    virtual void setVertexCount(const size_t count) = 0;
    
 
    virtual std::size_t getVertexCount() const = 0;
 
 
    virtual const std::uint32_t* getIndices() const = 0;
 
 
    virtual std::uint32_t* getIndices() = 0;
 
 
    virtual std::uint32_t getIndexCount() const = 0;
 
    virtual void setIndexCount(const std::uint32_t count) = 0;
 
 
    virtual const core::aabbox3df& getBoundingBox() const = 0;
 
 
    virtual void setBoundingBox(const core::aabbox3df& box) = 0;
 
    virtual void recalculateBoundingBox() = 0;
 
    virtual const glm::vec3& getPosition(std::uint32_t i) const = 0;
 
    virtual const glm::vec3& getNormal(std::uint32_t i) const = 0;
 
    virtual const glm::vec2& getTCoords(std::uint32_t i) const = 0;
 
    virtual const glm::vec3& getTangent(std::uint32_t i) const = 0;
 
    virtual const glm::vec3& getBiTangent(std::uint32_t i) const = 0;
 
    virtual std::uint32_t getIndex(std::size_t offset) const = 0;
 
 
    virtual void append(std::vector<S3DVertex>&& vertices, std::vector<uint32_t>&& indices) = 0;
 
 
    virtual void append(const IMeshBuffer* const other) = 0;
 
 
    virtual void appendAttribute(const char* buffer, const size_t size, const size_t stride) = 0;
 
 
    void setPrimitiveType(scene::E_PRIMITIVE_TYPE type)
    {
      PrimitiveType = type;
    }
 
    scene::E_PRIMITIVE_TYPE getPrimitiveType() const
    {
      return PrimitiveType;
    }
 
    E_INDEX_TYPE getIndexType() const
    {
      return IndexType;
    }
 
    void setIndexType(const E_INDEX_TYPE type)
    {
      IndexType = type;
    }
 
    void setInstanceCount(const size_t count)
    {
      InstanceCount = count;
    }
 
    std::size_t getInstanceCount() const
    {
      return InstanceCount;
    }
 
    void setBindingLocation(const int binding)
    {
      Binding = binding;
    }
 
    int getBindingLocation() const
    {
      return Binding;
    }
 
    void isNull(const bool null)
    {
      IsNull = null;
    }
 
    bool isNull() const
    {
      return IsNull;
    }
 
    virtual std::uint32_t getPrimitiveCount() const
    {
      std::uint32_t indexCount = getIndexCount();
      switch (getPrimitiveType())
      {
        case scene::E_PRIMITIVE_TYPE::POINTS:         return indexCount;
        case scene::E_PRIMITIVE_TYPE::LINE_STRIP:     return indexCount-1;
        case scene::E_PRIMITIVE_TYPE::LINE_LOOP:      return indexCount;
        case scene::E_PRIMITIVE_TYPE::LINES:          return indexCount/2;
        case scene::E_PRIMITIVE_TYPE::TRIANGLE_STRIP: return (indexCount-2);
        case scene::E_PRIMITIVE_TYPE::TRIANGLE_FAN:   return (indexCount-2);
        case scene::E_PRIMITIVE_TYPE::TRIANGLES:      return indexCount/3;
        case scene::E_PRIMITIVE_TYPE::QUAD_STRIP:     return (indexCount-2)/2;
        case scene::E_PRIMITIVE_TYPE::QUADS:          return indexCount/4;
        case scene::E_PRIMITIVE_TYPE::POLYGON:        return indexCount; // (not really primitives, that would be 1, works like line_strip)
        case scene::E_PRIMITIVE_TYPE::POINT_SPRITES:  return indexCount;
      }
      return 0;
    }
 
    bool useIndirectDraw() const
    {
      return IndirectDrawBuffer != video::NULL_GPU_RESOURCE_HANDLE;
    }
 
    auto indirectDrawBuffer() const
    {
      return IndirectDrawBuffer;
    }
 
    void setIndirectDrawBuffer(const video::IndirectBufferHandle buffer)
    {
      IndirectDrawBuffer = buffer;
    }
 
    bool useIndexedIndirectDraw() const
    {
      return IndexedIndirectDrawBuffer != video::NULL_GPU_RESOURCE_HANDLE;
    }
 
    auto indexedIndirectDrawBuffer() const
    {
      return IndexedIndirectDrawBuffer;
    }
 
    void setIndexedIndirectDrawBuffer(const video::IndexedIndirectBufferHandle buffer)
    {
      IndexedIndirectDrawBuffer = buffer;
    }
 
  protected:
    static MeshBufferID RootID;
 
    scene::E_PRIMITIVE_TYPE PrimitiveType = E_PRIMITIVE_TYPE::TRIANGLES;
 
    std::size_t InstanceCount = 1;
 
    int Binding = 0;
 
    bool IsNull = false;
 
    video::IndirectBufferHandle IndirectDrawBuffer = video::NULL_GPU_RESOURCE_HANDLE;
    
    video::IndexedIndirectBufferHandle IndexedIndirectDrawBuffer = video::NULL_GPU_RESOURCE_HANDLE;
 
    E_INDEX_TYPE IndexType = E_INDEX_TYPE::UINT32;
  };
 
} // namespace scene
} // namespace saga
 
#endif