RenderMaterialInstance.cpp

#include "RenderMaterialInstance.h"
 
#include "Rendering/IEffects.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IContext.h"
#include "Rendering/ITextures.h"
#include "Rendering/ICapabilities.h"
 
#include "Context.h"
 
#include "RenderStates.h"
#include "RenderResources.h"
#include "Resources/MaterialManager.h"
 
#include "Renderer.h"
#include "Engine.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderMaterialInstance");
 
  void clearBuffers(RenderMaterialInstance* that, Cogs::IBuffers* deviceBuffers)
  {
    for (auto& buffer : that->ownedBuffers) {
      if (HandleIsValid(buffer)) {
        deviceBuffers->releaseBuffer(buffer);
      }
    }
 
    for (auto& buffer : that->buffers) {
      buffer.handle = Cogs::BufferHandle::NoHandle;
      buffer.generation = 0;
    }
 
    that->ownedBuffers.clear();
  }
 
  size_t getBindingCode(const MeshStreamsLayout& streamsLayout,
                        const EnginePermutation* permutation,
                        const RenderPassOptions& passOptions,
                        ClipShapeType clipShape)
  {
    if (streamsLayout.numStreams && streamsLayout.hash == 0) {
      LOG_ERROR(logger, "MeshStreamsLayout has streams but hash is zero.");
    }
    return Cogs::hashSequence(streamsLayout.hash, permutation->getCode(), passOptions.hash, clipShape);
  }
 
  void updateBindings(RenderMaterialInstance* that,
                      MaterialInstance* materialInstance,
                      const Material* material,
                      Cogs::IGraphicsDevice* device,
                      EffectBinding* /*effectBinding*/)
  {
    Cogs::IBuffers* deviceBuffers = device->getBuffers();
    Cogs::IContext* immediateContext = device->getImmediateContext();
 
    if (that->context->variables->get("renderer.disableMaterialUpdates", false)) {
      return;
    }
 
    if (that->buffersGeneration != materialInstance->buffersGeneration) {
      that->buffersGeneration = materialInstance->buffersGeneration;
 
      // If a binding permutation has been encountered earlier with valid bindings for only a
      // subset of buffers, we may have both owned buffers and missing buffers.
      clearBuffers(that, deviceBuffers);
 
      that->buffers.resize(material->constantBuffers.buffers.size());
 
      for (auto& buffer : material->constantBuffers.buffers) {
 
        if (buffer.isPerInstance && buffer.size) {
          that->buffers[buffer.index].handle = deviceBuffers->loadBuffer(nullptr, buffer.size, Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer);
          deviceBuffers->annotate(that->buffers[buffer.index].handle, material->definition.name + "_matinst_" + std::to_string(buffer.index));
 
          that->ownedBuffers.push_back(that->buffers[buffer.index].handle);
          that->buffers[buffer.index].bound = true;
        }
      }
    }
 
    for (auto& buffer : material->constantBuffers.buffers) {
      if (!buffer.isPerInstance) continue;
 
      auto& instanceBuffer = materialInstance->buffers[buffer.index];
      RenderMaterialInstance::UpdateBuffer& updateBuffer = that->buffers[buffer.index];
 
      bool dirty = updateBuffer.generation != instanceBuffer.generation;
 
      if (dirty && HandleIsValid(updateBuffer.handle)) {
        immediateContext->updateBuffer(updateBuffer.handle, instanceBuffer.content.data(), buffer.size);
        updateBuffer.generation = instanceBuffer.generation;
      }
    }
  }
 
 
  void updateTextureProperties(RenderMaterialInstance* that,
                               MaterialInstance* materialInstance,
                               Cogs::IGraphicsDevice* /*device*/,
                               RenderStates* renderStates)
  {
    auto& settings = that->context->renderer->getSettings();
 
    // Allocate enough room to store a sampler state per texture.
    that->samplerStates.resize(materialInstance->textureVariables.size());
 
    for (auto& t : materialInstance->textureVariables) {
      if (t.dirty || !HandleIsValid(that->samplerStates[t.key])) {
        const Cogs::SamplerState state = {
          t.texture.sMode,
          t.texture.tMode,
          t.texture.uMode,
          t.texture.filterMode,
          Cogs::SamplerState::Never,
          static_cast<unsigned int>(settings.anisotropicFiltering->getInt()),
          { 0, 0, 0, 1 }
        };
 
        that->samplerStates[t.key] = renderStates->getSamplerState(state);
 
        debug_assert(HandleIsValid(that->samplerStates[t.key]));
 
        t.dirty = false;
      }
    }
  }
 
  ActivationResult checkMaterial(RenderMaterialInstance* instance, RenderMaterial* renderMaterial)
  {
    if (!renderMaterial) {
      return ActivationResult::Postponed;
    }
 
    if (renderMaterial->hasFailed()) {
      instance->setFailed();
      return ActivationResult::Failure;
    }
    else if (renderMaterial->isReleased()) {
      LOG_ERROR(logger, "Could not initialize material instance for released material.");
      instance->setFailed();
      return ActivationResult::Failure;
    }
    else if (renderMaterial->isDelayed()) {
      instance->setDelayed();
      return ActivationResult::Delayed;
    }
    else if (!renderMaterial->isActive()) {
      return ActivationResult::Postponed;
    }
 
    return ActivationResult::Success;
  }
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderMaterialInstance::update(MaterialInstance* materialInstance,
                                                                        IGraphicsDevice* device,
                                                                        RenderResources* resources,
                                                                        RenderStates* renderStates)
{
  context = resources->getContext();
 
  renderMaterial = resources->getRenderMaterial(materialInstance->material);
  
  auto checkResult = checkMaterial(this, renderMaterial);
 
  if (checkResult != ActivationResult::Success) return checkResult;
 
  updateTextureProperties(this, materialInstance, device, renderStates);
 
  if (materialInstance->permutationIndex != permutationIndex || variantGeneration != materialInstance->variantGeneration) {
    loadedBindings.clear();
  }
 
  permutationIndex = materialInstance->permutationIndex;
  variantGeneration = materialInstance->variantGeneration;
 
  std::vector<RenderEffectBinding> stillPending;
 
  for (RenderEffectBinding& pending : pendingBindings) {
 
    if (pending.variantGeneration != variantGeneration) continue;
 
    EffectBinding* binding = renderMaterial->getBinding(permutationIndex,
                                                        materialInstance,
                                                        &pending.streamsLayout,
                                                        pending.enginePermutation,
                                                        pending.passOptions,
                                                        pending.clipShape);
 
    if (binding->renderEffect &&
        HandleIsValid(binding->renderEffect->effectHandle) &&
        HandleIsValid(binding->renderEffect->inputHandle) &&
        !binding->renderEffect->isDelayed())
    {
      loadedBindings.push_back(std::move(pending));
      loadedBindings.back().variantGeneration = 0u;
    }
    else {
      stillPending.push_back(std::move(pending));
      materialInstance->setChanged();
    }
  }
 
  pendingBindings = std::move(stillPending);
 
  for (auto & loaded : loadedBindings) {
    updateBindings(this, materialInstance, materialInstance->material, device, loaded.binding);
  }
 
  setActive();
 
  return ActivationResult::Success;
}
 
 
void Cogs::Core::RenderMaterialInstance::release(Renderer * renderer)
{
  assert(!isReleased());
 
  clearBuffers(this, renderer->getDevice()->getBuffers());
 
  setReleased();
}
 
const EffectBinding* Cogs::Core::RenderMaterialInstance::checkReady(const MeshStreamsLayout& streamsLayout,
                                                                    const EnginePermutation* permutation,
                                                                    const RenderPassOptions& passOptions,
                                                                    ClipShapeType clipShape)
{
  MaterialInstance* materialInstance = getResource();
 
  // We already have an binding
  if (const EffectBinding* bindings = getBindings(streamsLayout, permutation, passOptions, clipShape); bindings) {
 
    if (!bindings->renderEffect ||
        bindings->renderEffect->isDelayed() ||
        !HandleIsValid(bindings->renderEffect->effectHandle) ||
        !HandleIsValid(bindings->renderEffect->inputHandle) ||
        bindings->buffersGeneration != materialInstance->material->constantBuffers.buffersGeneration ||
        buffersGeneration != materialInstance->buffersGeneration)
    {
      Material* material = materialInstance->material;
 
      if (bindings->renderEffect && bindings->renderEffect->isDelayed()) {
        bindings->renderEffect->requestLoad();
        context->engine->setDirty();
      }
 
      else if (renderMaterial->isDelayed() || renderMaterial->pendingBindings.size()) {
        // Ensure the material is queued for processing if it is either delayed or has pending bindings to set up.
        material->setChanged();
      }
 
      if (materialInstance->hasFailedActivation()) {
        materialInstance->setChanged();
        materialInstance->material->setChanged();
      }
 
      return nullptr;
    }
 
    return bindings;
  }
 
  // We do not have any bindings, try to get one
  else {
 
    size_t permuationCode = getBindingCode(streamsLayout, permutation, passOptions, clipShape);
 
    Material* material = materialInstance->material;
 
    EffectBinding* binding = nullptr;
    if (renderMaterial) {
      binding = renderMaterial->getBinding(permutationIndex,
                                           materialInstance,
                                           &streamsLayout,
                                           permutation,
                                           passOptions,
                                           clipShape);
    }
 
    if (binding && binding->renderEffect && binding->buffersGeneration == material->constantBuffers.buffersGeneration) {
      auto device = context->renderer->getDevice();
      updateBindings(this, materialInstance, material, device, binding);
      updateTextureProperties(this, materialInstance, device, &context->renderer->getRenderStates());
 
      loadedBindings.push_back(RenderEffectBinding{ permuationCode, streamsLayout, permutation, passOptions, clipShape, binding, 0 });
 
      return checkReady(streamsLayout, permutation, passOptions, clipShape);
    }
 
    else {
      pendingBindings.emplace_back(RenderEffectBinding{ permuationCode, streamsLayout, permutation, passOptions, clipShape, binding, variantGeneration });
                                   
      materialInstance->setChanged();
      context->engine->setDirty();
    }
    
 
    if (materialInstance->hasFailedActivation()) {
      materialInstance->setChanged();
      materialInstance->material->setChanged();
    }
 
    return nullptr;
  }
}
 
const Cogs::Core::EffectBinding * Cogs::Core::RenderMaterialInstance::getBindings(const MeshStreamsLayout& streamsLayout,
                                                                                  const EnginePermutation * permutation,
                                                                                  const RenderPassOptions& passOptions,
                                                                                  ClipShapeType clipShape) const
{
  permutation = context->renderer->getEnginePermutations().get(permutation->getIndex());
 
  size_t code = getBindingCode(streamsLayout, permutation, passOptions, clipShape);
 
  for (auto & binding : loadedBindings) {
    if (binding.permutationCode == code) return binding.binding;
  }
 
  for (auto & binding : pendingBindings) {
    if (binding.permutationCode == code) return binding.binding;
  }
 
  return nullptr;
}