RenderMaterial.cpp

#include "RenderMaterial.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/ITextures.h"
 
#include "Context.h"
 
#include "Resources/MaterialManager.h"
#include "Systems/Core/CameraSystem.h"
 
#include "RenderStates.h"
#include "RenderResources.h"
 
#include "Renderer.h"
#include "Context.h"
 
#include "EffectBindings.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderMaterial");
 
  size_t calculateHash(const size_t permutationIndex,
                       const MaterialInstance* materialInstance,
                       const MeshStreamsLayout* streamsLayout,
                       const EnginePermutation* enginePermutation,
                       const RenderPassOptions& passOptions,
                       const ClipShapeType clipShape)
  {
    const Material* material = materialInstance->material;
    assert(material);
 
    size_t instanceCode = Cogs::hash(permutationIndex);
    for (const std::string& str : materialInstance->variantStrings) {
      instanceCode = Cogs::hash(str, instanceCode);
    }
 
    for (const ShaderVariantDefinition& definition : material->definition.variants) {
      if (definition.isShared) {
        instanceCode = Cogs::hash(definition.defaultValue, instanceCode);
      }
      else {
        instanceCode = Cogs::hash(materialInstance->variantSelectors[definition.index].value, instanceCode);
      }
    }
 
    assert(streamsLayout);
    if (streamsLayout->numStreams && streamsLayout->hash == 0) {
      LOG_ERROR(logger, "Non-empty MeshStreamsLayout with zero hash");
    }
    instanceCode = Cogs::hash(streamsLayout->hash, instanceCode);
    instanceCode = Cogs::hash(enginePermutation->getCode(), instanceCode);
    instanceCode = Cogs::hash(passOptions.hash, instanceCode);
    instanceCode = Cogs::hash(clipShape, instanceCode);
 
    return instanceCode;
  }
 
  ActivationResult checkEffect(RenderMaterial * renderMaterial, EffectBinding & binding)
  {
    if (!binding.renderEffect) {
      // Render effect has not been created yet.
      return ActivationResult::Postponed;
    }
 
    if (binding.renderEffect->hasFailed()) {
      if (!renderMaterial->hasFailed()) {
 
        auto * material = renderMaterial->getResource();
        LOG_ERROR(logger, "Could not initialize bindings for effect %s, failing activation.", material ? material->getName().to_string().c_str() :  "");
 
        renderMaterial->setFailed();
      }
 
      return ActivationResult::Failure;
    } if (binding.renderEffect->isReleased()) {
      LOG_ERROR(logger, "Could not initialize bindings for released effect.");
 
      renderMaterial->setFailed();
 
      return ActivationResult::Failure;
    } else if (binding.renderEffect->isDelayed()) {
      renderMaterial->setDelayed();
 
      return ActivationResult::Delayed;
    } else if (!binding.renderEffect->isActive()) {
      LOG_DEBUG(logger, "Could not initialize render material due to uninitialized effect. Re-queuing.");
 
      return ActivationResult::Postponed;
    }
 
    return ActivationResult::Success;
  }
 
  void updateBufferContents(Cogs::IGraphicsDevice * device,
                            const Material * material, EffectBinding & binding)
  {
    for (const MaterialPropertyBuffer& buffer : material->constantBuffers.buffers) {
      if (buffer.isPerInstance) continue;
 
      const MaterialPropertyBuffer& materialBuffer = material->constantBuffers.buffers[buffer.index];
      EffectBinding::Buffer& gpubuf = binding.buffers[buffer.index];
      if ((gpubuf.generation != materialBuffer.generation) && HandleIsValid(binding.bufferBindings[buffer.index])) {
        Cogs::IContext* immediateContext = device->getImmediateContext();
        immediateContext->updateBuffer(gpubuf.handle, materialBuffer.content.data(), buffer.size);
        gpubuf.generation = materialBuffer.generation;
      }
    }
  }
 
  void updateTextureBinding(const Material* material, Cogs::IGraphicsDevice* device, RenderStates* /*renderStates*/, EffectBinding& binding)
  {
    auto b = &binding;
 
    if (b->renderEffect && HandleIsValid(b->renderEffect->effectHandle) && !b->textureBindings.size()) {
      b->textureBindings.resize(material->textureProperties.size());
      b->samplerBindings.resize(material->textureProperties.size());
 
      int unit = 0;
 
      for (auto& tp : material->textureProperties) {
        b->textureBindings[tp.key] = device->getEffects()->getTextureBinding(b->renderEffect->effectHandle, tp.name, unit);
 
        if (tp.isArray) {
          b->samplerBindings[tp.key] = device->getEffects()->getSamplerStateBinding(b->renderEffect->effectHandle, tp.name.substr(0, tp.name.find("[")) + "Sampler", unit);
        }
        else {
          b->samplerBindings[tp.key] = device->getEffects()->getSamplerStateBinding(b->renderEffect->effectHandle, tp.name + "Sampler", unit);
        }
        ++unit;
      }
    }
  }
 
  void updateTextureProperties(RenderMaterial* renderMaterial, RenderResources* resources, RenderStates* renderStates, const Material* material)
  {
    const RenderSettings& settings = resources->getRenderer()->getSettings();
 
    size_t N = material->textureProperties.size();
    renderMaterial->texturePropertyStates.resize(N);
    for (size_t i = 0; i < N; i++) {
      const TextureProperty& t = material->textureProperties[i];
      if (t.isPerInstance) continue;
 
      RenderMaterial::TexturePropertyState& state = renderMaterial->texturePropertyStates[i];
      if (size_t hash = t.texture.hash(); !HandleIsValid(state.samplerState) || state.hash != hash) {
        state.hash = hash;
 
        unsigned int anisotropy = 1;
        if (t.texture.filterMode == Cogs::SamplerState::FilterMode::MinMagMipLinear) {
          anisotropy = static_cast<unsigned int>(settings.anisotropicFiltering->getInt());
        }
        const Cogs::SamplerState samplerStateDesc = {
          t.texture.sMode,
          t.texture.tMode,
          t.texture.uMode,
          t.texture.filterMode,
          Cogs::SamplerState::Never,
          anisotropy,
          { 0, 0, 0, 1 }
        };
        state.samplerState = renderStates->getSamplerState(samplerStateDesc);
        debug_assert(state.samplerState);
      }
    }
  }
 
  ActivationResult setupBinding(Cogs::IGraphicsDevice* device,
                                RenderStates* renderStates,
                                RenderMaterial* renderMaterial,
                                const Material* material,
                                Effect* /*effect*/,
                                RenderEffect* renderEffect,
                                EffectBinding& binding)
  {
    binding.renderEffect = renderEffect;
 
    auto effectResult = checkEffect(renderMaterial, binding);
 
    if (effectResult != ActivationResult::Success) return effectResult;
 
    if (binding.buffersGeneration != material->constantBuffers.buffersGeneration) {
      binding.buffersGeneration = material->constantBuffers.buffersGeneration;
 
      auto deviceBuffers = device->getBuffers();
      auto effects = device->getEffects();
 
      binding.bufferBindings.resize(material->constantBuffers.buffers.size());
      binding.buffers.resize(material->constantBuffers.buffers.size());
 
      for (auto& buffer : material->constantBuffers.buffers) {
        if (!buffer.size) continue;
 
        binding.bufferBindings[buffer.index] = effects->getConstantBufferBinding(binding.renderEffect->effectHandle, buffer.name);
 
        if (HandleIsValid(binding.bufferBindings[buffer.index]) && !buffer.isPerInstance) {
          binding.buffers[buffer.index].handle = deviceBuffers->loadBuffer(nullptr, buffer.size, Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer);
          deviceBuffers->annotate(binding.buffers[buffer.index].handle, material->definition.name + "_mat_" + std::to_string(buffer.index));
        }
      }
 
      auto& effectHandle = binding.renderEffect->effectHandle;
 
      binding.sceneBufferBinding = effects->getConstantBufferBinding(effectHandle, "SceneBuffer");
      binding.viewBufferBinding = effects->getConstantBufferBinding(effectHandle, "ViewBuffer");
      binding.animationBufferBinding = effects->getConstantBufferBinding(effectHandle, "AnimationBuffer");
 
      binding.shadowArrayBinding = effects->getTextureBinding(effectHandle, "cascadedShadowMap", 1);
      binding.shadowArrayBinding_1 = effects->getTextureBinding(effectHandle, "cascadedShadowMap_1", 1);
      binding.shadowArraySamplerBinding = effects->getSamplerStateBinding(effectHandle, "cascadedShadowMapSampler", 1);
      binding.shadowSamplerBinding = effects->getSamplerStateBinding(effectHandle, "cascadedShadowSampler", 1);
 
      binding.shadowCubeArrayBinding = effects->getTextureBinding(effectHandle, "cubeShadowMap", 2);
      binding.shadowCubeArrayBinding_1 = effects->getTextureBinding(effectHandle, "cubeShadowMap_1", 2);
      binding.shadowCubeArraySamplerBinding = effects->getSamplerStateBinding(effectHandle, "cubeShadowMapSampler", 2);
 
      binding.skyBinding = effects->getTextureBinding(effectHandle, "environmentSky", 0);
      binding.radianceBinding = effects->getTextureBinding(effectHandle, "environmentRadiance", 0);
      binding.irradianceBinding = effects->getTextureBinding(effectHandle, "environmentIrradiance", 0);
      binding.ambientIrradianceBinding = effects->getTextureBinding(effectHandle, "ambientIrradiance", 0);
      binding.brdfLUTBinding = effects->getTextureBinding(effectHandle, "brdfLUT", 0);
 
      binding.skySamplerBinding = effects->getSamplerStateBinding(effectHandle, "environmentSkySampler", 0);
      binding.radianceSamplerBinding = effects->getSamplerStateBinding(effectHandle, "environmentRadianceSampler", 0);
      binding.irradianceSamplerBinding = effects->getSamplerStateBinding(effectHandle, "environmentIrradianceSampler", 0);
      binding.ambientIrradianceSamplerBinding = effects->getSamplerStateBinding(effectHandle, "ambientIrradianceSampler", 0);
      binding.brdfLUTSamplerBinding = effects->getSamplerStateBinding(effectHandle, "brdfLUTSampler", 0);
 
      binding.objectBufferBinding = effects->getConstantBufferBinding(effectHandle, "ObjectBuffer");
 
      binding.blueNoise = effects->getTextureBinding(effectHandle, "blueNoise_LDR_RGBA", 0);
      binding.blueNoiseStable = effects->getTextureBinding(effectHandle, "blueNoiseStable_LDR_RGBA", 0);
    }
 
    updateTextureBinding(material, device, renderStates, binding);
 
    binding.effectGeneration = renderEffect->getGeneration();
    ++binding.generation;
 
    return ActivationResult::Success;
  }
 
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderMaterial::update(Material * material, IGraphicsDevice * device, RenderResources * resources, RenderStates * renderStates)
{
  auto context = resources->getContext();
  this->renderer = context->renderer;
 
  std::vector<EffectBindingInstance> stillPending;
 
  uint32_t results = 0;
  for (auto & pending : pendingBindings) {
    auto & effect = pending.effect;
    auto binding = pending.binding;
 
    auto renderEffect = resources->getRenderEffect(effect);
 
    ActivationResult result = ActivationResult::Success;
    if (renderEffect && binding->effectGeneration != renderEffect->generation) {
      result = setupBinding(device, renderStates, this, material, effect.resolve(), renderEffect, *binding);
 
      results |= static_cast<uint32_t>(result);
 
      if (result == ActivationResult::Success) {
        updateBufferContents(device, material, *binding);
        bindings.emplace_back(pending);
        continue;
      }
    }
 
    stillPending.emplace_back(pending);
  }
 
  for (auto & binding : bindings) {
    if (!HandleIsValid(binding.binding->renderEffect->effectHandle)) {
      results |= static_cast<uint32_t>(ActivationResult::Failure);
    } else {
      updateBufferContents(device, material, *binding.binding);
    }
  }
 
  pendingBindings = std::move(stillPending);
 
  const bool haveActive = (results & static_cast<uint32_t>(ActivationResult::Success)) != 0;
  const bool haveFailed = (results & static_cast<uint32_t>(ActivationResult::Failure)) != 0;
  const bool havePostponed = (results & static_cast<uint32_t>(ActivationResult::Postponed)) != 0;
  const bool haveDelayed = (results & static_cast<uint32_t>(ActivationResult::Delayed)) != 0;
 
  if (haveFailed) {
    setFailed();
 
    return ActivationResult::Failure;
  } else if (havePostponed && !haveActive) {
    return ActivationResult::Postponed;
  } else if (haveDelayed && !haveActive) {
    setDelayed();
 
    return ActivationResult::Delayed;
  }
 
  auto instances = context->materialInstanceManager->getAllocatedResources();
 
  if (uint32_t gen = material->getGeneration(); updatedGeneration != gen) {
    updatedGeneration = gen;
    updateTextureProperties(this, resources, renderStates, material);
  }
 
  // Let material instances using any updated permutations know they need to update.
  for (auto & resource : instances) {
    auto materialInstance = static_cast<MaterialInstance *>(resource);
 
    //TODO: Update permutation/variant equality logic
    if (materialInstance->material == material &&
        materialInstance->referenceCount() != 0) {
      materialInstance->setChanged();
    }
  }
 
  setActive();
 
  return ActivationResult::Success;
}
 
void Cogs::Core::RenderMaterial::release(Renderer * renderer)
{
  IBuffers* buffers = renderer->getDevice()->getBuffers();
 
  for (auto & b : bindings) {
    auto binding = b.binding;
 
    if (!binding) continue;
 
    for (auto & buffer : binding->buffers) {
      if (HandleIsValid(buffer.handle)) {
        buffers->releaseBuffer(buffer.handle);
      }
    }
 
    binding->buffers.clear();
    binding->bufferBindings.clear();
 
    renderer->getEffectBindings().deallocateBinding(binding);
  }
 
  for (auto & b : pendingBindings) {
    renderer->getEffectBindings().deallocateBinding(b.binding);
  }
 
  bindings.clear();
  pendingBindings.clear();
 
  setReleased();
}
 
Cogs::Core::EffectBinding * Cogs::Core::RenderMaterial::getBinding(const size_t permutationIndex,
                                                                   const MaterialInstance * materialInstance,
                                                                   const MeshStreamsLayout* streamsLayout,
                                                                   const EnginePermutation * enginePermutation,
                                                                   const RenderPassOptions& passOptions,
                                                                   const ClipShapeType clipShape)
{
  const size_t code = calculateHash(permutationIndex, materialInstance, streamsLayout, enginePermutation, passOptions, clipShape);
 
  for (EffectBindingInstance& b : bindings) {
    if (b.code == code) return b.binding;
  }
 
  for (EffectBindingInstance& b : pendingBindings) {
    if (b.code == code) return b.binding;
  }
 
  EffectBinding* binding = renderer->getEffectBindings().allocateBinding();
  Material* material = getResource();
  EffectHandle effect = material->getEffect(code, materialInstance, streamsLayout,  enginePermutation, passOptions, clipShape);
 
  pendingBindings.emplace_back(EffectBindingInstance{ binding, code, effect });
 
  // Perhaps update inline (?)
 
  material->setChanged();
 
  return binding;
}