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])) {
        unsigned int anisotropy = 1;
        if (t.texture.filterMode == Cogs::SamplerState::FilterMode::MinMagMipLinear) {
          anisotropy = static_cast<unsigned int>(settings.anisotropicFiltering->getInt());
        }
        const Cogs::SamplerState state = {
          t.texture.sMode,
          t.texture.tMode,
          t.texture.uMode,
          t.texture.filterMode,
          Cogs::SamplerState::Never,
          anisotropy,
          { 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;
  }
 
 
  const EffectBinding* checkEffectBinding(Context* context,
                                          EffectBinding* effectBinding,
                                          RenderMaterial* renderMaterial,
                                          MaterialInstance* materialInstance,
                                          Material* material,
                                          uint16_t buffersGeneration)
  {
    if (effectBinding->buffersGeneration == material->constantBuffers.buffersGeneration &&
      buffersGeneration == materialInstance->buffersGeneration)
    {
      return effectBinding;
    }
 
    if (renderMaterial->isDelayed() || !renderMaterial->pendingBindings.empty()) {
      material->setChanged();
    }
 
    if (materialInstance->hasFailedActivation()) {
      materialInstance->setChanged();
      material->setChanged();
    }
 
    context->engine->setDirty();
    return nullptr;
  }
 
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderMaterialInstance::update(MaterialInstance* materialInstance,
                                                                        IGraphicsDevice* device,
                                                                        RenderResources* resources,
                                                                        RenderStates* renderStates)
{
  context = resources->getContext();
 
  Material* material = materialInstance->material;
  assert(material);
 
  renderMaterial = resources->getRenderMaterial(materialInstance->material);
  
  auto checkResult = checkMaterial(this, renderMaterial);
 
  if (checkResult != ActivationResult::Success) return checkResult;
 
  updateTextureProperties(this, materialInstance, device, renderStates);
 
  if ((permutationIndex != materialInstance->permutationIndex) ||
      (materialVariantGeneration != material->variantGeneration) ||
      (instanceVariantGeneration != materialInstance->variantGeneration))
  {
    loadedBindings.clear();
    pendingBindings.clear();
 
    permutationIndex = materialInstance->permutationIndex;
    materialVariantGeneration = material->variantGeneration;
    instanceVariantGeneration = materialInstance->variantGeneration;
  }
 
  std::vector<RenderEffectBinding> stillPending;
 
  for (RenderEffectBinding& pending : pendingBindings) {
 
    EffectBinding* binding = renderMaterial->getBinding(permutationIndex,
                                                        materialInstance,
                                                        &pending.streamsLayout,
                                                        pending.enginePermutation,
                                                        pending.passOptions,
                                                        pending.clipShape);
 
    if (binding) {
      pending.binding = binding;
      loadedBindings.push_back(std::move(pending));
    }
    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,
                                                                    const RenderTarget* renderTarget)
{
  MaterialInstance* materialInstance = getResource();
  Material* material = materialInstance->material;
 
  permutation = context->renderer->getEnginePermutations().get(permutation->getIndex());
 
  size_t bindingCode = getBindingCode(streamsLayout, permutation, passOptions, clipShape);
 
  for (RenderEffectBinding& binding : loadedBindings) {
    if (binding.permutationCode == bindingCode) {
      return checkEffectBinding(context, binding.binding, renderMaterial, materialInstance, material, buffersGeneration);
    }
  }
 
  bool pending = false;
  for (RenderEffectBinding& binding : pendingBindings) {
    if (binding.permutationCode == bindingCode) {
      pending = true;
      break;
    }
  }
 
 
  if (renderMaterial) {
    EffectBinding* bindings = renderMaterial->getBinding(permutationIndex,
                                                         materialInstance,
                                                         &streamsLayout,
                                                         permutation,
                                                         passOptions,
                                                         clipShape);
 
    if (bindings) {
      auto device = context->renderer->getDevice();
      updateBindings(this, materialInstance, material, device, bindings);
      updateTextureProperties(this, materialInstance, device, &context->renderer->getRenderStates());
 
      loadedBindings.push_back(RenderEffectBinding { bindingCode, streamsLayout, permutation, passOptions, clipShape, bindings });
 
      if (pending) {
        for (size_t i = 0; i < pendingBindings.size(); ++i) {
          if (pendingBindings[i].permutationCode == bindingCode) {
            pendingBindings.erase(pendingBindings.begin() + static_cast<ptrdiff_t>(i));
            break;
          }
        }
      }
      return checkEffectBinding(context, bindings, renderMaterial, materialInstance, material, buffersGeneration);
    }
  }
 
  if (!pending) {
    pendingBindings.emplace_back(RenderEffectBinding{ bindingCode, streamsLayout, permutation, passOptions, clipShape, nullptr });
  }
 
  materialInstance->setChanged();
  if (materialInstance->hasFailedActivation()) {
    material->setChanged();
  }
 
  context->engine->setDirty();
  return nullptr;
}