EngineBindGroups.cpp

#include "EngineBindGroups.h"
 
#include "Context.h"
#include "Renderer.h"
#include "RenderTarget.h"
 
#include "Rendering/IContext.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
#include "Tasks/RenderTask.h"
 
#include "RenderResources.h"
#include "RenderTexture.h"
 
#include "Resources/TextureManager.h"
#include "Resources/ShaderBuilderHelpersWebGPU.h"
 
#include "Rendering/IBindGroups.h"
 
void Cogs::Core::initializeEngineBindGroups(IBindGroups * bindGroups, EngineBindGroups & engineBindGroups)
{
  if (!bindGroups) return;
 
  const BindGroupSetDescription & desc = getEngineBindGroupDescription();
  const BindGroupDescription & lightTextures = desc.groups[static_cast<size_t>(BindGroup::LightTextures)];
  if (lightTextures.numEntries == 0) return;
 
  engineBindGroups.lightTextures = bindGroups->createBindGroup(&lightTextures);
  if (!HandleIsValid(engineBindGroups.lightTextures)) return;
 
  BindGroupHandle handle = engineBindGroups.lightTextures;
  engineBindGroups.skyBinding = bindGroups->getTextureBinding(handle, "environmentSky");
  engineBindGroups.radianceBinding = bindGroups->getTextureBinding(handle, "environmentRadiance");
  engineBindGroups.irradianceBinding = bindGroups->getTextureBinding(handle, "environmentIrradiance");
  engineBindGroups.ambientIrradianceBinding = bindGroups->getTextureBinding(handle, "ambientIrradiance");
  engineBindGroups.brdfLUTBinding = bindGroups->getTextureBinding(handle, "brdfLUT");
  engineBindGroups.shadowArrayBinding = bindGroups->getTextureBinding(handle, "cascadedShadowMap");
  engineBindGroups.shadowCubeArrayBinding = bindGroups->getTextureBinding(handle, "cubeShadowMap");
 
  engineBindGroups.linearSamplerBinding = bindGroups->getSamplerBinding(handle, "linearSampler");
  engineBindGroups.linearClampSampler = bindGroups->getSamplerBinding(handle, "linearClampSampler");
  engineBindGroups.pointSampler = bindGroups->getSamplerBinding(handle, "pointSampler");
  engineBindGroups.pointClampSampler = bindGroups->getSamplerBinding(handle, "pointClampSampler");
  engineBindGroups.shadowSamplerBinding = bindGroups->getSamplerBinding(handle, "shadowSampler");
}
 
void Cogs::Core::updateLightTexturesBindGroup(RenderTaskContext* taskContext)
{
  IGraphicsDevice* device = taskContext->renderer->getDevice();
  IBindGroups* bindGroups = device->getBindGroups();
  IContext* deviceContext = device->getImmediateContext();
  if (!bindGroups) return;
 
  EngineBindGroups& engineBindGroups = taskContext->renderer->getEngineBindGroups();
  if (!HandleIsValid(engineBindGroups.lightTextures)) return;
 
  BindGroupHandle handle = engineBindGroups.lightTextures;
  RenderResources& renderResources = taskContext->renderer->getRenderResources();
  TextureManager* textureManager = taskContext->context->textureManager;
 
  // Every entry in the bind group must be bound to something, so unresolved environment/shadow
  // slots fall back to the same dummy white/whiteDepth textures used previously by the per-effect
  // WebGPU dummy-texture path in updateEnvironmentBindings.
  Cogs::TextureHandle skyTexture = Cogs::TextureHandle::NoHandle;
  Cogs::TextureHandle radianceTexture = Cogs::TextureHandle::NoHandle;
  Cogs::TextureHandle irradianceTexture = Cogs::TextureHandle::NoHandle;
  Cogs::TextureHandle ambientIrradianceTexture = Cogs::TextureHandle::NoHandle;
  Cogs::TextureHandle brdfLUTTexture = Cogs::TextureHandle::NoHandle;
 
  const EnvironmentComponent* environmentComponent = taskContext->context->environmentSystem->getGlobalEnvironment();
  if (environmentComponent) {
    if (environmentComponent->isSubmerged(taskContext->cameraData)) {
      if (environmentComponent->subseaRadiance) {
        RenderTexture* subseaRadianceTexture = renderResources.getRenderTexture(environmentComponent->subseaRadiance);
        if (subseaRadianceTexture && subseaRadianceTexture->description.target == ResourceDimensions::TextureCube) {
          skyTexture = subseaRadianceTexture->textureHandle;
          radianceTexture = subseaRadianceTexture->textureHandle;
          irradianceTexture = subseaRadianceTexture->textureHandle;
          ambientIrradianceTexture = subseaRadianceTexture->textureHandle;
        }
      }
    } else {
      if (environmentComponent->skyDome) {
        RenderTexture* tex = renderResources.getRenderTexture(environmentComponent->skyDome);
        if (tex && tex->description.target == ResourceDimensions::TextureCube) skyTexture = tex->textureHandle;
      }
      if (environmentComponent->radiance) {
        RenderTexture* tex = renderResources.getRenderTexture(environmentComponent->radiance);
        if (tex && tex->description.target == ResourceDimensions::TextureCube) radianceTexture = tex->textureHandle;
      }
      if (environmentComponent->irradiance) {
        RenderTexture* tex = renderResources.getRenderTexture(environmentComponent->irradiance);
        if (tex && tex->description.target == ResourceDimensions::TextureCube) irradianceTexture = tex->textureHandle;
      }
      if (environmentComponent->ambientIrradiance) {
        RenderTexture* tex = renderResources.getRenderTexture(environmentComponent->ambientIrradiance);
        if (tex && tex->description.target == ResourceDimensions::TextureCube) ambientIrradianceTexture = tex->textureHandle;
      }
      if (environmentComponent->brdfLUT) {
        RenderTexture* tex = renderResources.getRenderTexture(environmentComponent->brdfLUT);
        if (tex && tex->description.target == ResourceDimensions::Texture2D) brdfLUTTexture = tex->textureHandle;
      }
    }
  }
 
  if (!HandleIsValid(skyTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteCube)) skyTexture = tex->textureHandle;
  }
  if (!HandleIsValid(radianceTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteCube)) radianceTexture = tex->textureHandle;
  }
  if (!HandleIsValid(irradianceTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteCube)) irradianceTexture = tex->textureHandle;
  }
  if (!HandleIsValid(ambientIrradianceTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteCube)) ambientIrradianceTexture = tex->textureHandle;
  }
  if (!HandleIsValid(brdfLUTTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->white)) brdfLUTTexture = tex->textureHandle;
  }
 
  Cogs::TextureHandle shadowArrayTexture = Cogs::TextureHandle::NoHandle;
  if (RenderTexture* tex = renderResources.getRenderTexture(taskContext->context->lightSystem->cascadeArray)) shadowArrayTexture = tex->textureHandle;
  if (!HandleIsValid(shadowArrayTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteDepthArray)) shadowArrayTexture = tex->textureHandle;
  }
 
  Cogs::TextureHandle shadowCubeArrayTexture = Cogs::TextureHandle::NoHandle;
  if (RenderTexture* tex = renderResources.getRenderTexture(taskContext->context->lightSystem->cubeArray)) shadowCubeArrayTexture = tex->textureHandle;
  if (!HandleIsValid(shadowCubeArrayTexture)) {
    if (RenderTexture* tex = renderResources.getRenderTexture(textureManager->whiteDepthCube)) shadowCubeArrayTexture = tex->textureHandle;
  }
  bindGroups->setTexture(handle, engineBindGroups.skyBinding, skyTexture);
  bindGroups->setTexture(handle, engineBindGroups.radianceBinding, radianceTexture);
  bindGroups->setTexture(handle, engineBindGroups.irradianceBinding, irradianceTexture);
  bindGroups->setTexture(handle, engineBindGroups.ambientIrradianceBinding, ambientIrradianceTexture);
  bindGroups->setTexture(handle, engineBindGroups.brdfLUTBinding, brdfLUTTexture);
  bindGroups->setTexture(handle, engineBindGroups.shadowArrayBinding, shadowArrayTexture);
  bindGroups->setTexture(handle, engineBindGroups.shadowCubeArrayBinding, shadowCubeArrayTexture);
 
  bindGroups->setSamplerState(handle, engineBindGroups.linearSamplerBinding, taskContext->states->defaultSampler);
  bindGroups->setSamplerState(handle, engineBindGroups.linearClampSampler, taskContext->states->commonSamplerStates[1]);
  bindGroups->setSamplerState(handle, engineBindGroups.pointSampler, taskContext->states->commonSamplerStates[2]);
  bindGroups->setSamplerState(handle, engineBindGroups.pointClampSampler, taskContext->states->commonSamplerStates[3]);
  bindGroups->setSamplerState(handle, engineBindGroups.shadowSamplerBinding, taskContext->states->shadowSampler);
  
  deviceContext->setBindGroup(engineBindGroups.lightTextures, static_cast<uint32_t>(BindGroup::LightTextures));
 
}