MaterialBuilder.cpp

#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ICapabilities.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "MaterialBuilder.h"
 
#include "EffectManager.h"
 
#include "Context.h"
 
#include "TextureManager.h"
 
#include "ShaderBuilder.h"
#include "Renderer/IRenderer.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MaterialBuilder");
 
}
 
bool Cogs::Core::applyConstantBuffers(class Context * context, const MaterialProperties & materialProperties, ConstantBuffers & constantBuffers)
{
  for (auto & buffer : materialProperties.buffers) {
    auto bufferKey = constantBuffers.addBuffer(buffer.name, buffer.isPerInstance);
 
    for (auto & parsedValue : buffer.values) {
      auto & propertyName = parsedValue.name;
 
      auto flags = parsedValue.flags;
 
      switch (parsedValue.type) {
      case MaterialDataType::Float:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.floatValue, MaterialDataType::Float, buffer.isPerInstance);
        break;
      case MaterialDataType::Float2:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float2Value, MaterialDataType::Float2, buffer.isPerInstance);
        break;
      case MaterialDataType::Float3:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float3Value, MaterialDataType::Float3, buffer.isPerInstance);
        break;
      case MaterialDataType::Float4:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float4Value, MaterialDataType::Float4, buffer.isPerInstance);
        break;
      case MaterialDataType::Float4x4:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float4x4Value, MaterialDataType::Float4x4, buffer.isPerInstance);
        break;
      case MaterialDataType::Float4Array:
        if (parsedValue.dimension != static_cast<size_t>(-1)) {
          constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float4Value, MaterialDataType::Float4Array, buffer.isPerInstance, parsedValue.dimension);
        }
        else {
          LOG_WARNING(logger, "Constant buffer float4[]-member must have a known size");
          return false;
        }
        break;
      case MaterialDataType::Float4x4Array:
        if (parsedValue.dimension != static_cast<size_t>(-1)) {
          constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.float4x4Value, MaterialDataType::Float4x4Array, buffer.isPerInstance, parsedValue.dimension);
        }
        else {
          LOG_WARNING(logger, "Constant buffer float4x4[]-member must have a known size");
          return false;
        }
        break;
      case MaterialDataType::Bool:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.boolValue, MaterialDataType::Bool, buffer.isPerInstance);
        break;
      case MaterialDataType::Int:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.intValue, MaterialDataType::Int, buffer.isPerInstance);
        break;
      case MaterialDataType::Int2:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.int2Value, MaterialDataType::Int2, buffer.isPerInstance);
        break;
      case MaterialDataType::Int3:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.int3Value, MaterialDataType::Int3, buffer.isPerInstance);
        break;
      case MaterialDataType::Int4:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.int4Value, MaterialDataType::Int4, buffer.isPerInstance);
        break;
      case MaterialDataType::UInt:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.uintValue, MaterialDataType::UInt, buffer.isPerInstance);
        break;
      case MaterialDataType::UInt2:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.uint2Value, MaterialDataType::UInt2, buffer.isPerInstance);
        break;
      case MaterialDataType::UInt3:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.uint3Value, MaterialDataType::UInt3, buffer.isPerInstance);
        break;
      case MaterialDataType::UInt4:
        constantBuffers.addVariable(bufferKey, flags, propertyName, parsedValue.uint4Value, MaterialDataType::UInt4, buffer.isPerInstance);
        break;
      default:
        LOG_WARNING(logger, "Unsupported constant buffer type %s", DataTypeNames[size_t(parsedValue.type)]);
        return false;
      }
    }
 
    constantBuffers.finalizeBuffer(context, bufferKey);
  }
  return true;
}
 
bool Cogs::Core::applyMaterialProperties(Context * context, const MaterialProperties & materialProperties, Material & material)
{
  if (!applyConstantBuffers(context, materialProperties, material.constantBuffers)) return false;
 
  if (!materialProperties.buffers.size()) {
    // If no buffers were added, bump buffers generation to still invalidate bindings to built-in
    // buffers like scene and environment data.
    material.constantBuffers.buffersGeneration++;
  }
 
  TextureHandle defaultTexture[] = {
    context->textureManager->white,
    context->textureManager->whiteCube,
    TextureHandle::NoHandle,
    TextureHandle::NoHandle,
  };
 
  for (const MaterialTextureDefinition& texture : materialProperties.textures) {
    assert((size_t)texture.dimensions < sizeof(defaultTexture)/sizeof(defaultTexture[0]));
    if(texture.isArray){
      for(uint32_t i=0; i<texture.arraySize; i++){
        VariableKey key = material.addTextureProperty(texture.name+'['+std::to_string(i)+']', 
                                                      defaultTexture[static_cast<size_t>(texture.dimensions)],
                                                      texture.dimensions, 
                                                      SamplerState::AddressMode::Wrap,
                                                      SamplerState::FilterMode::MinMagMipLinear,
                                                      texture.isPerInstance, texture.isArray, texture.arraySize);
 
        if (texture.isSrgb) {
          material.textureProperties[key].flags |= MaterialPropertyFlags::sRGB;
        }
      }
    }
    else{
      VariableKey key = material.addTextureProperty(texture.name,
                                                    defaultTexture[static_cast<size_t>(texture.dimensions)],
                                                    texture.dimensions,
                                                    SamplerState::AddressMode::Wrap,
                                                    SamplerState::FilterMode::MinMagMipLinear,
                                                    texture.isPerInstance,
                                                    texture.isArray,
                                                    texture.arraySize);
      if (texture.isSrgb) {
        material.textureProperties[key].flags |= MaterialPropertyFlags::sRGB;
      }
    }
  }
  return true;
}
 
bool Cogs::Core::applyMaterialDefinition(class Context * context, const MaterialDefinition & materialDefinition, Material & material)
{
  material.setName(materialDefinition.name);
 
  material.enginePermutationMask = materialDefinition.enginePermutationMask;
 
  for (auto & opt : materialDefinition.options) {
    applyMaterialOption(material.options, opt.first, opt.second);
  }
 
  if (!applyMaterialProperties(context, materialDefinition.properties, material)) return false;
 
  return true;
}