VertexFormat.h

#pragma once
 
#include "Common.h"
#include "DataFormat.h"
 
#include <vector>
 
namespace Cogs
{
  enum class ElementSemantic : uint16_t
  {
    Position, 
    Normal, 
    Color, 
    TextureCoordinate, 
    Tangent, 
    InstanceVector, 
    InstanceMatrix, 
    Semantic_Size // Provided for size comparisons.
  };
 
  enum class InputType : uint16_t
  {
    VertexData = 0, 
    InstanceData, 
  };
 
  struct VertexElement
  {
    uint16_t offset;           
    DataFormat format;         
    ElementSemantic semantic;  
    uint16_t semanticIndex;    
    InputType inputType;       
    uint16_t instanceStep;     
  };
 
  struct PackedVertexElement
  {
    DataFormat format;         
    ElementSemantic semantic;  
    uint16_t semanticIndex;    
    InputType inputType;       
    uint16_t instanceStep;     
  };
 
  struct VertexFormat
  {
    std::vector<VertexElement> elements;
 
    size_t hash = 0;
 
    uint32_t size = 0;
  };
 
  struct COGSRENDERING_DLL_API VertexFormats
  {
    static VertexFormatHandle createVertexFormat(const VertexElement * elements, size_t count);
    static VertexFormatHandle createVertexFormat(const PackedVertexElement * elements, size_t count);
    static inline VertexFormatHandle createVertexFormat(const VertexElement & element) { return createVertexFormat(&element, 1); }
 
    static const VertexFormat * getVertexFormat(VertexFormatHandle handle);
  };
 
  StringView COGSRENDERING_DLL_API getElementSemanticName(ElementSemantic semantic);
 
  inline uint32_t COGSRENDERING_DLL_API getSize(const Cogs::VertexFormat & vertexFormat)
  {
    return vertexFormat.size;
  }
  inline uint32_t COGSRENDERING_DLL_API getSize(VertexFormatHandle vertexFormatHandle)
  {
    return getSize(*VertexFormats::getVertexFormat(vertexFormatHandle));
  }
  inline size_t COGSRENDERING_DLL_API getHash(const Cogs::VertexFormat & vertexFormat)
  {
    return vertexFormat.hash;
  }
  inline size_t COGSRENDERING_DLL_API getHash(VertexFormatHandle vertexFormatHandle)
  {
    return getHash(*VertexFormats::getVertexFormat(vertexFormatHandle));
  }
 
  inline size_t hash(const VertexElement& element, size_t hashValue = Cogs::hash()) {
    hashValue = Cogs::hash(element.offset, hashValue);
    hashValue = Cogs::hash(static_cast<uint16_t>(element.format), hashValue);
    hashValue = Cogs::hash(static_cast<uint16_t>(element.semantic), hashValue);
    hashValue = Cogs::hash(element.semanticIndex, hashValue);
    hashValue = Cogs::hash(static_cast<uint16_t>(element.inputType), hashValue);
    hashValue = Cogs::hash(element.instanceStep, hashValue);
 
    return hashValue;
  }
 
  inline size_t hash(const Cogs::VertexFormat& format, size_t hashValue = Cogs::hash()) {
    for (const VertexElement& element : format.elements) {
      hashValue = Cogs::hash(element, hashValue);
    }
    return hashValue;
  }
}