Buffer.hpp

#ifndef BUFFER_H
#define BUFFER_H
#include "pch.hpp"
#include "Base.hpp"
#include "Shader.hpp"
#include "Mesh.hpp"
 
namespace Engine {
  struct BufferElement {
    std::string name;
    ShaderDataType type;
    uint32_t offset;
    uint32_t size;
    bool normalized;
 
    BufferElement(ShaderDataType type, const std::string& name, bool norm = false)
      : name(name), type(type),
      size(ShaderDataTypeSize(type)),
      offset(0), normalized(norm) {
 
      }
 
    uint32_t GetComponentCount() const {
      switch(type) {
        case ShaderDataType::Int:
        case ShaderDataType::Bool:
        case ShaderDataType::Float: return 1;
        case ShaderDataType::Int2:
        case ShaderDataType::Float2: return 2;
        case ShaderDataType::Int3:
        case ShaderDataType::Float3: return 3;
        case ShaderDataType::Int4:
        case ShaderDataType::Float4: return 4;
        case ShaderDataType::Mat3: return 3 * 3;
        case ShaderDataType::Mat4: return 4 * 4;
        default: Log::Warn("BUFFER ELEMENTS","Unknown ShaderDataType"); return 0;
      }
      return 0;
    }
 
 
  };
 
 
  class BufferLayout {
    private:
      std::vector<BufferElement> m_Elements;
      uint32_t m_Stride = 0;
 
    public:
      inline const std::vector<BufferElement>& GetElements() const { return m_Elements; }
      inline const uint32_t GetStride() const { return m_Stride; }
 
      BufferLayout(const std::initializer_list<BufferElement>&  elements)
        : m_Elements(elements) {
          CalculateOffsetsAndStride();
        }
      BufferLayout() {}
 
      std::vector<BufferElement>::iterator begin() { return m_Elements.begin(); }
      std::vector<BufferElement>::iterator end() { return m_Elements.end(); }
 
    private:
      void CalculateOffsetsAndStride() {
        uint32_t offset = 0;
        m_Stride = 0;
        for (auto& e : m_Elements) {
          e.offset = offset;
          offset += e.size;
          m_Stride += e.size;
        }
      }
 
 
  };
 
  class VertexBuffer {
 
    public:
      VertexBuffer(){};
      virtual ~VertexBuffer(){};
 
      virtual void Bind() = 0;
      virtual void Unbind() = 0;
 
      virtual void Load(float verts[], std::size_t size) = 0;
 
      virtual std::size_t GetSize() = 0;
  };
 
  class IndexBuffer {
    public:
      IndexBuffer(){};
      virtual ~IndexBuffer(){};
 
      virtual void Bind() = 0;
      virtual void Unbind() = 0;
 
      virtual void Load(unsigned int inds[], std::size_t size) = 0;
 
      virtual std::size_t GetSize() = 0;
  };
}
#endif