RenderStateUpdater.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Rendering/ICapabilities.h"
 
#include "Context.h"
 
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
 
#include "Resources/Mesh.h"
#include "Resources/Skeleton.h"
#include "Resources/Animation.h"
#include "Resources/BasicBlueNoiseManager.h"
#include "RenderStateUpdater.h"
#include "RenderList.h"
 
#include "Tasks/RenderTask.h"
#include "Tasks/GenerateListTask.h"
 
#include "Resources/TextureManager.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderStateUpdater");
}
 
 
void Cogs::Core::applyMaterialProperties(const DrawContext * drawContext,
                                         const Material * /*material*/,
                                         const ConstantBufferBindingHandle & bufferBinding,
                                         const BufferHandle & constantBuffer)
{
  auto deviceContext = drawContext->deviceContext;
  if (HandleIsValid(bufferBinding)) {
    deviceContext->setConstantBuffer(bufferBinding, constantBuffer);
  }
}
 
void Cogs::Core::updateSceneBindings(const DrawContext * drawContext, const CameraData * /*cameraData*/, const EffectBinding * bindings)
{
  assert(drawContext->taskContext && "Invalid rendering context.");
 
  updateSceneBindings(drawContext->taskContext, bindings);
}
 
void Cogs::Core::updateSceneBindings(const RenderTaskContext * taskContext, const EffectBinding * bindings)
{
  const EngineBuffers* engineBuffers = &taskContext->renderer->getEngineBuffers();
  IGraphicsDevice* device = taskContext->renderer->getDevice();
  IContext* deviceContext = device->getImmediateContext();
 
  if (HandleIsValid(bindings->sceneBufferBinding)) {
    deviceContext->setConstantBuffer(bindings->sceneBufferBinding, engineBuffers->sceneBufferHandle);
  }
  if (HandleIsValid(bindings->viewBufferBinding)) {
    deviceContext->setConstantBuffer(bindings->viewBufferBinding, engineBuffers->viewBufferHandle);
  }
 
  if (HandleIsValid(bindings->blueNoise)) {
    auto& blueNoiseManager = taskContext->context->blueNoiseManager;
    blueNoiseManager->enable();
    TextureHandle blueNoise = blueNoiseManager->getBlueNoiseHandle(false)->texture;
    RenderTexture * blueNoiseTexture = taskContext->renderer->getRenderResources().getRenderTexture(blueNoise);
    if (blueNoiseTexture) {
      deviceContext->setTexture(bindings->blueNoise, blueNoiseTexture->textureHandle);
    }
  }
  if (HandleIsValid(bindings->blueNoiseStable)) {
    auto& blueNoiseManager = taskContext->context->blueNoiseManager;
    blueNoiseManager->enable();
    TextureHandle blueNoise = blueNoiseManager->getBlueNoiseHandle(true)->texture;
    RenderTexture * blueNoiseTexture = taskContext->renderer->getRenderResources().getRenderTexture(blueNoise);
    if (blueNoiseTexture) {
      deviceContext->setTexture(bindings->blueNoiseStable, blueNoiseTexture->textureHandle);
    }
  }
}
 
void Cogs::Core::updateEnvironmentBindings(const DrawContext * drawContext, const EffectBinding * bindings)
{
  IContext *deviceContext = drawContext->deviceContext;
  LightSystem *lightSystem = drawContext->context->lightSystem;
 
  bool needSkyBinding = true;
  bool needRadianceBinding = true;
  bool needIrradianceBinding = true;
  bool needAmbientIrradianceBinding = true;
 
  if (!drawContext->permutation->isShadowPass()) {
    if (HandleIsValid(bindings->shadowArrayBinding)) {
      RenderTexture * shadowTexture = drawContext->renderer->getRenderResources().getRenderTexture(lightSystem->cascadeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings->shadowArrayBinding, shadowTexture->textureHandle);
        deviceContext->setSamplerState("", 1, drawContext->taskContext->states->shadowSampler);
      }
    }
    if (HandleIsValid(bindings->shadowArrayBinding_1)) {
      RenderTexture * shadowTexture = drawContext->renderer->getRenderResources().getRenderTexture(lightSystem->cascadeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings->shadowArrayBinding_1, shadowTexture->textureHandle);
        deviceContext->setSamplerState("", 1, drawContext->taskContext->states->shadowSampler);
      }
    }
 
    if (HandleIsValid(bindings->shadowCubeArrayBinding)) {
      RenderTexture * shadowTexture = drawContext->renderer->getRenderResources().getRenderTexture(lightSystem->cubeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings->shadowCubeArrayBinding, shadowTexture->textureHandle);
        deviceContext->setSamplerState("", 2, drawContext->taskContext->states->shadowSampler);
      }
    }
    if (HandleIsValid(bindings->shadowCubeArrayBinding_1)) {
      auto shadowTexture = drawContext->renderer->getRenderResources().getRenderTexture(lightSystem->cubeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings->shadowCubeArrayBinding_1, shadowTexture->textureHandle);
        deviceContext->setSamplerState("", 2, drawContext->taskContext->states->shadowSampler);
      }
    }
 
    if (HandleIsValid(bindings->shadowSamplerBinding)) {
      deviceContext->setSamplerState(bindings->shadowSamplerBinding, drawContext->taskContext->states->shadowSampler);
    }
    if (HandleIsValid(bindings->shadowArraySamplerBinding)) {
      deviceContext->setSamplerState(bindings->shadowArraySamplerBinding, drawContext->taskContext->states->shadowSampler);
    }
    if (HandleIsValid(bindings->shadowCubeArraySamplerBinding)) {
      deviceContext->setSamplerState(bindings->shadowCubeArraySamplerBinding, drawContext->taskContext->states->shadowSampler);
    }
  }
  else {
    if (HandleIsValid(bindings->shadowSamplerBinding)) {
      deviceContext->setSamplerState(bindings->shadowSamplerBinding, drawContext->taskContext->states->shadowSampler);
    }
  }
 
  auto environmentComponent = drawContext->cameraData->environment.resolveComponent<EnvironmentComponent>();
 
  if (environmentComponent) {
    if (environmentComponent->isSubmerged(drawContext->cameraData)) {
 
      if (environmentComponent->subseaRadiance) {
        RenderTexture * subseaRadianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->subseaRadiance);
        if (subseaRadianceTexture) {
          if (subseaRadianceTexture->description.target != ResourceDimensions::TextureCube) {
            static int count = 0;
            if (count < 10) {
              LOG_ERROR(logger, "environment.subseaRadiance is not a cube texture.");
              count++;
            }
          }
          else {
            if (HandleIsValid(bindings->skyBinding)) {
              deviceContext->setTexture(bindings->skyBinding, subseaRadianceTexture->textureHandle);
              needSkyBinding = false;
            }
            if (HandleIsValid(bindings->radianceBinding)) {
              deviceContext->setTexture(bindings->radianceBinding, subseaRadianceTexture->textureHandle);
              needRadianceBinding = false;
            }
            if (HandleIsValid(bindings->irradianceBinding)) {
              deviceContext->setTexture(bindings->irradianceBinding, subseaRadianceTexture->textureHandle);
              needIrradianceBinding = false;
            }
            if (HandleIsValid(bindings->ambientIrradianceBinding)) {
              deviceContext->setTexture(bindings->ambientIrradianceBinding, subseaRadianceTexture->textureHandle);
              needAmbientIrradianceBinding = false;
            }
          }
        }
      }
    } else {
      if (environmentComponent->skyDome && HandleIsValid(bindings->skyBinding)) {
 
        if (RenderTexture * skyTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->skyDome); skyTexture) {
 
          if (skyTexture->description.target != ResourceDimensions::TextureCube) {
            static int warningCount = 0;
            if (warningCount < 10) {
              LOG_ERROR(logger, "environment.skyDome is not a cube texture.");
              warningCount++;
            }
          }
          else {
            deviceContext->setTexture(bindings->skyBinding, skyTexture->textureHandle);
            needSkyBinding = false;
          }
        }
      }
 
      if (environmentComponent->radiance && HandleIsValid(bindings->radianceBinding)) {
 
        if (RenderTexture * radianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->radiance); radianceTexture) {
 
          if (radianceTexture->description.target != ResourceDimensions::TextureCube) {
            static int warningCount = 0;
            if (warningCount < 10) {
              LOG_ERROR(logger, "environment.radiance is not a cube texture.");
              warningCount++;
            }
          }
          else {
            deviceContext->setTexture(bindings->radianceBinding, radianceTexture->textureHandle);
            needRadianceBinding = false;
          }
        }
      }
 
      if (environmentComponent->irradiance && HandleIsValid(bindings->irradianceBinding)) {
 
        if (RenderTexture * irradianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->irradiance);  irradianceTexture) {
 
          if (irradianceTexture->description.target != ResourceDimensions::TextureCube) {
            static int warningCount = 0;
            if (warningCount < 10) {
              LOG_ERROR(logger, "environment.irradiance is not a cube texture.");
              warningCount++;
            }
          }
          else {
            deviceContext->setTexture(bindings->irradianceBinding, irradianceTexture->textureHandle);
            needIrradianceBinding = false;
          }
        }
      }
 
      if (environmentComponent->ambientIrradiance && HandleIsValid(bindings->ambientIrradianceBinding)) {
        RenderTexture * ambientIrradianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->ambientIrradiance);
        if (ambientIrradianceTexture) {
 
          if (ambientIrradianceTexture->description.target != ResourceDimensions::TextureCube) {
            static int warningCount = 0;
            if (warningCount < 10) {
              LOG_ERROR(logger, "environment.ambientIrradiance is not a cube texture.");
              warningCount++;
            }
          }
          else {
            deviceContext->setTexture(bindings->ambientIrradianceBinding, ambientIrradianceTexture->textureHandle);
            needAmbientIrradianceBinding = false;
          }
        }
      }
 
      if (environmentComponent->brdfLUT && HandleIsValid(bindings->brdfLUTBinding)) {
        RenderTexture* brdfLUTTexture = drawContext->renderer->getRenderResources().getRenderTexture(environmentComponent->brdfLUT);
        if (brdfLUTTexture) {
 
          if (brdfLUTTexture->description.target != ResourceDimensions::Texture2D) {
            static int warningCount = 0;
            if (warningCount < 10) {
              LOG_ERROR(logger, "environment.brdfLUT is not a 2D texture.");
              warningCount++;
            }
          }
          else {
            deviceContext->setTexture(bindings->brdfLUTBinding, brdfLUTTexture->textureHandle);
          }
        }
      } else if (HandleIsValid(bindings->brdfLUTBinding)) {
        RenderTexture * white = drawContext->renderer->getRenderResources().getRenderTexture(drawContext->context->textureManager->white);
        deviceContext->setTexture(bindings->brdfLUTBinding, white->textureHandle);
      }
 
    }
  }
 
  if (drawContext->device->getType() == GraphicsDeviceType::WebGPU){
    // Set Dymmy textures requered for WebGPU
 
    // skyBinding
    if(HandleIsValid(bindings->skyBinding) && needSkyBinding){
      TextureHandle whiteCube = drawContext->context->textureManager->whiteCube;
      RenderTexture* skyTexture = drawContext->renderer->getRenderResources().getRenderTexture(whiteCube);
      if (skyTexture) {
        LOG_INFO_ONCE(logger, "Setting dummy environment.skyDome.");
        deviceContext->setTexture(bindings->skyBinding, skyTexture->textureHandle);
      }
    }
 
    // radianceBinding
    if(HandleIsValid(bindings->radianceBinding) && needRadianceBinding) {
      TextureHandle whiteCube = drawContext->context->textureManager->whiteCube;
      RenderTexture* radianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(whiteCube);
      if (radianceTexture) {
        LOG_INFO_ONCE(logger, "Setting dummy environment.radiance.");
        deviceContext->setTexture(bindings->radianceBinding, radianceTexture->textureHandle);
      }
    }
 
    // irradianceBinding
    if(HandleIsValid(bindings->irradianceBinding) && needIrradianceBinding) {
      TextureHandle whiteCube = drawContext->context->textureManager->whiteCube;
      RenderTexture* irradianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(whiteCube);
      if (irradianceTexture) {
        LOG_INFO_ONCE(logger, "Setting dummy environment.irradiance.");
        deviceContext->setTexture(bindings->irradianceBinding, irradianceTexture->textureHandle);
      }
    }
 
    // ambientIrradianceBinding
    if(HandleIsValid(bindings->ambientIrradianceBinding) && needAmbientIrradianceBinding) {
      TextureHandle whiteCube = drawContext->context->textureManager->whiteCube;
      RenderTexture* ambientIrradianceTexture = drawContext->renderer->getRenderResources().getRenderTexture(whiteCube);
      if (ambientIrradianceTexture) {
        LOG_INFO_ONCE(logger, "Setting dummy environment.ambientIrradiance.");
        deviceContext->setTexture(bindings->ambientIrradianceBinding, ambientIrradianceTexture->textureHandle);
      }
    }
  }
 
  SamplerState linearFiltering = {
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::FilterMode::MinMagMipLinear,
    SamplerState::ComparisonFunction::Never,
    1,
    { 0, 0, 0, 1 }
  };
 
  if (HandleIsValid(bindings->skySamplerBinding)) {
    deviceContext->setSamplerState(bindings->skySamplerBinding, drawContext->taskContext->states->getSamplerState(linearFiltering));
  }
 
 
  if (HandleIsValid(bindings->radianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings->radianceSamplerBinding, drawContext->taskContext->states->getSamplerState(linearFiltering));
  }
  if (HandleIsValid(bindings->irradianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings->irradianceSamplerBinding, drawContext->taskContext->states->getSamplerState(linearFiltering));
  }
  if (HandleIsValid(bindings->ambientIrradianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings->ambientIrradianceSamplerBinding, drawContext->taskContext->states->getSamplerState(SamplerState::DefaultState()));
  }
  if (HandleIsValid(bindings->brdfLUTSamplerBinding)) {
    SamplerState lutSamplerState = {
        SamplerState::AddressMode::Clamp,
        SamplerState::AddressMode::Clamp,
        SamplerState::AddressMode::Clamp,
        SamplerState::FilterMode::MinMagMipLinear,
        SamplerState::ComparisonFunction::Never,
        1,
        { 0, 0, 0, 1 }
    };
    deviceContext->setSamplerState(bindings->brdfLUTSamplerBinding, drawContext->taskContext->states->getSamplerState(lutSamplerState));
  }
}
 
void Cogs::Core::updateMaterialBindings(const DrawContext * drawContext, const RenderMaterialInstance * renderMaterialInstance, const EffectBinding * bindings, bool perInstance)
{
  auto deviceContext = drawContext->deviceContext;
 
  auto materialInstance = renderMaterialInstance->getResource();
  auto material = materialInstance->material;
 
  for (auto & buffer : material->constantBuffers.buffers) {
    if (buffer.isPerInstance != perInstance) continue;
 
    auto & bufferBinding = bindings->bufferBindings[buffer.index];
 
    if (perInstance) {
      applyMaterialProperties(drawContext, material, bufferBinding, renderMaterialInstance->buffers[buffer.index].handle);
    }
    else {
      applyMaterialProperties(drawContext, material, bufferBinding, bindings->buffers[buffer.index].handle);
    }
  }
 
  if (perInstance) {
    for (const TextureValue& textureProperty : materialInstance->textureVariables) {
      if (textureProperty.property->isPerInstance) {
        const Cogs::TextureBindingHandle&       textureBinding = bindings->textureBindings[textureProperty.key];
        const Cogs::SamplerStateBindingHandle&  samplerBinding = bindings->samplerBindings[textureProperty.key];
 
        RenderTexture* renderTexture = drawContext->renderer->getRenderResources().getRenderTexture(textureProperty.texture.handle);
 
        if (renderTexture) {
          deviceContext->setTexture(textureBinding, renderTexture->textureHandle);
        }
        else {
          if (HandleIsValid(textureProperty.property->texture.handle)) {
            // Render texture is not ready, fall back to default value if available.
            renderTexture = drawContext->renderer->getRenderResources().getRenderTexture(textureProperty.property->texture.handle);
            deviceContext->setTexture(textureBinding, renderTexture ? renderTexture->textureHandle : Cogs::TextureHandle::NoHandle);
          }
          else {
            deviceContext->setTexture(textureBinding, Cogs::TextureHandle::NoHandle);
          }
        }
        if (HandleIsValid(renderMaterialInstance->samplerStates[textureProperty.key])) {
          deviceContext->setSamplerState(samplerBinding, renderMaterialInstance->samplerStates[textureProperty.key]);
        }
        else {
          deviceContext->setSamplerState(samplerBinding, Cogs::SamplerStateHandle::NoHandle);
        }
      }
    }
  }
  else {
    RenderMaterial* renderMaterial = renderMaterialInstance->renderMaterial;
 
    for (size_t i = 0, N = material->textureProperties.size(); i < N; i++) {
      const TextureProperty& textureProperty = material->textureProperties[i];
      if (!textureProperty.isPerInstance) {
 
        RenderTexture* renderTexture = drawContext->renderer->getRenderResources().getRenderTexture(textureProperty.texture.handle);
        if (renderTexture) {
          deviceContext->setTexture(bindings->textureBindings[textureProperty.key], renderTexture->textureHandle);
        }
        else {
          deviceContext->setTexture(bindings->textureBindings[textureProperty.key], Cogs::TextureHandle::NoHandle);
        }
 
        const RenderMaterial::TexturePropertyState& state = renderMaterial->texturePropertyStates[i];
        if (HandleIsValid(state.samplerState)) {
          deviceContext->setSamplerState(bindings->samplerBindings[textureProperty.key], state.samplerState);
        }
        else {
          deviceContext->setSamplerState(bindings->samplerBindings[textureProperty.key], Cogs::SamplerStateHandle::NoHandle);
        }
 
      }
    }
  }
}
 
void Cogs::Core::applyMaterialPermutation(RenderTaskContext * taskContext, const DrawContext * drawContext, const EffectBinding * bindings, const RenderMaterialInstance * renderMaterialInstance)
{
  drawContext->deviceContext->setEffect(bindings->renderEffect->effectHandle);
  drawContext->deviceContext->setInputLayout(bindings->renderEffect->inputHandle);
  updateSceneBindings(taskContext, bindings);
  updateMaterialBindings(drawContext, renderMaterialInstance, bindings, false);
}
 
void Cogs::Core::applyMaterialInstance(const DrawContext * drawContext, const EffectBinding * bindings, const RenderMaterialInstance * renderMaterialInstance)
{
  updateMaterialBindings(drawContext, renderMaterialInstance, bindings, true);
}
 
size_t Cogs::Core::populateObjectBuffer(const DrawContext * drawContext, const RenderItem* items, size_t o, size_t n)
{
  auto deviceContext = drawContext->deviceContext;
  auto & engineBuffers = *drawContext->engineBuffers;
  assert(engineBuffers.objectBatch.count != 0);
 
  const auto stride = engineBuffers.objectBatch.stride;
  auto m = std::min(n - o, size_t(engineBuffers.objectBatch.count));
  if (m) {
    MappedBuffer<char> objectBatch(deviceContext, engineBuffers.objectBatch.bufferHandle, MapMode::WriteDiscard);
 
    if (objectBatch) {
      for (size_t i = 0; i < m; i++) {
        if (items[o + i].isCustom()) continue;
        auto * obj = (ObjectBuffer*)(objectBatch.get() + stride * i);
        obj->worldMatrix = *items[o + i].worldMatrix;
        obj->objectId = items[o + i].objectId;
      }
    }
  }
  return o + m;
}
 
void Cogs::Core::applyMaterialPerObjectBatched(const DrawContext * drawContext, const RenderMaterialInstance * /*renderMaterialInstance*/, const RenderItem & renderItem, size_t o)
{
  auto deviceContext = drawContext->deviceContext;
  auto & engineBuffers = *drawContext->engineBuffers;
  auto & batch = engineBuffers.objectBatch;
 
  const auto bindings = renderItem.binding;
 
  if (HandleIsValid(bindings->objectBufferBinding)) {
    deviceContext->setConstantBuffer(bindings->objectBufferBinding,
                                     batch.bufferHandle,
                                     batch.stride * uint32_t(o),
                                     batch.stride);
  }
 
  if (renderItem.poseData) {
    if (HandleIsValid(bindings->animationBufferBinding)) {
      deviceContext->updateBuffer(engineBuffers.animationBuffer, renderItem.poseData->transforms, sizeof(glm::mat4) * renderItem.poseData->numPoses);
      deviceContext->setConstantBuffer(bindings->animationBufferBinding, engineBuffers.animationBuffer);
    }
  }
}
 
 
void Cogs::Core::applyMaterialPerObject(const DrawContext * drawContext, const RenderMaterialInstance * /*renderMaterialInstance*/, const RenderItem & renderItem)
{
  auto deviceContext = drawContext->deviceContext;
  auto & engineBuffers = *drawContext->engineBuffers;
 
  const auto bindings = renderItem.binding;
 
  if (HandleIsValid(bindings->objectBufferBinding)) {
    ListObjectBuffer* unifiedObjectBuffer = drawContext->listObjectBuffer;
 
    if (unifiedObjectBuffer && renderItem.hasObjectBufferSlot() && HandleIsValid(unifiedObjectBuffer->gpu)) {
      deviceContext->setConstantBuffer(bindings->objectBufferBinding,
                                       unifiedObjectBuffer->gpu,
                                       unifiedObjectBuffer->stride * renderItem.objectBufferSlot,
                                       unifiedObjectBuffer->stride);
    }
    else {
      MappedBuffer<ObjectBuffer> objectBuffer(deviceContext,  engineBuffers.objectBufferHandle, MapMode::WriteDiscard);
      if (objectBuffer) {
        objectBuffer->worldMatrix = *renderItem.worldMatrix;
        objectBuffer->objectId = renderItem.objectId;
      }
      deviceContext->setConstantBuffer(bindings->objectBufferBinding, engineBuffers.objectBufferHandle);
    }
  }
 
  if (renderItem.poseData) {
    if (HandleIsValid(bindings->animationBufferBinding)) {
      deviceContext->updateBuffer(engineBuffers.animationBuffer, renderItem.poseData->transforms, sizeof(glm::mat4) * renderItem.poseData->numPoses);
      deviceContext->setConstantBuffer(bindings->animationBufferBinding, engineBuffers.animationBuffer);
    }
  }
}