ConstantBuffers.h

#pragma once
 
#include "Utilities/Strings.h"
 
#include "MaterialDefinition.h"
#include "MaterialPropertyBuffer.h"
#include "MaterialProperty.h"
#include "MaterialOptions.h"
 
namespace Cogs::Core
{
  class Context;
 
  struct ConstantBuffers
  {
    COGSCORE_DLL_API ConstantBufferKey addBuffer(const PropertyName & name, bool isPerInstance = true);
 
    void finalizeBuffer(Context* context, ConstantBufferKey bufferKey) { buffers[bufferKey].finalize(context); }
    
    template<typename T>
    VariableKey addVariable(ConstantBufferKey bufferKey, MaterialPropertyFlags flags, const StringView& name, T defaultValue, MaterialDataType type, bool isPerInstance = true, size_t dimension = static_cast<size_t>(-1))
    {
      MaterialProperty& variable = variables.emplace_back();
 
      const VariableKey key = static_cast<VariableKey>(variables.size() - 1);
 
      variable.name = name.to_string();
      variable.buffer = bufferKey;
      variable.key = key;
      variable.flags = flags;
      variable.type = type;
      variable.isPerInstance = isPerInstance;
      enforcePropertyFlags(variable, flags, &defaultValue);
      variable.setDefault(defaultValue);
 
      MaterialPropertyBuffer& buffer = buffers[bufferKey];
      if (type == MaterialDataType::Float4Array) {
        assert(dimension != static_cast<size_t>(-1) && dimension < std::numeric_limits<uint32_t>::max());
 
        std::vector<uint8_t> tmp(sizeof(glm::vec4) * dimension);
        for (size_t i = 0; i < dimension; i++) {
          std::memcpy(tmp.data() + sizeof(glm::vec4) * i, &defaultValue, sizeof(glm::vec4));
        }
 
        variable.isArray = true;
        variable.arraySize = static_cast<uint32_t>(dimension);
        variable.descriptor = buffer.addProperty(sizeof(glm::vec4), tmp.size(), tmp.data());
      }
      else if (type == MaterialDataType::Float4x4Array) {
        assert(dimension != static_cast<size_t>(-1) && dimension <= std::numeric_limits<uint32_t>::max());
 
        std::vector<uint8_t> tmp(sizeof(glm::mat4) * dimension);
        for (size_t i = 0; i < dimension; i++) {
          std::memcpy(tmp.data() + sizeof(glm::mat4) * i, &defaultValue, sizeof(glm::mat4));
        }
 
        variable.isArray = true;
        variable.arraySize = static_cast<uint32_t>(dimension);
        variable.descriptor = buffer.addProperty(sizeof(glm::vec4), tmp.size(), tmp.data());
      }
      else {
        variable.descriptor = buffer.addProperty(defaultValue);
      }
      return key;
    }
 
    template<typename T>
    void setProperty(const VariableKey key, T value)
    {
      auto & variable = variables[key];
 
      if (variable.flags != MaterialPropertyFlags::None) {
        enforcePropertyFlags(variable, variable.flags, &value);
      }
 
      buffers[variable.buffer].setValue(variable.descriptor.offset, value);
    }
 
    VariableKey getPropertyKey(const StringView & name) const
    {
      for (auto & v : variables) {
        if (name == v.name) {
          return v.key;
        }
      }
 
      return NoProperty;
    }
 
    std::vector<MaterialPropertyBuffer> buffers;
 
    std::vector<MaterialProperty> variables;
 
    uint16_t buffersGeneration = 0;
  };
}