TwinVisualsTexAtlasRenderTask.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IRenderTargets.h"
#include "Rendering/ICapabilities.h"
 
#include "Context.h"
#include "ExtensionRegistry.h"
 
#include "Systems/Core/LightSystem.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderStates.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderPipelineDefinition.h"
#include "Renderer/EngineBuffers.h"
 
#include "Systems/Core/EnvironmentSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Utilities/Parsing.h"
#include "Utilities/Preprocessor.h"
#include "Resources/ResourceStore.h"
 
#include "../../TexAtlas/Source/TexAtlasComponent.h"
#include "../../TexAtlas/Source/TexAtlasSystem.h"
 
#include "TwinVisualsSystem.h"
#include "TwinVisualsComponent.h"
#include "TwinVisualsTexAtlasRenderTask.h"
 
#include <glm/gtc/color_space.hpp>
#include <sstream>
#include <regex>
#include <map>
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TwinVisuals");
 
  // Convert remaining #define directives to WGSL const expressions.
  [[nodiscard]]
  std::string convertDefinesToConst(const std::string& s) {
    std::string result;
    result.reserve(s.size());
    std::istringstream iss(s);
    std::regex e1("^\\s*#define\\s+([^\\s]+)\\s+([^\\s]+)");
    std::regex e2("^\\s*#define\\s+([^\\s]+)\\s*$");
    std::map<std::string, std::string> added;
    for (std::string line; std::getline(iss, line); ) {
      std::smatch match;
      std::string id, val;
      if (std::regex_search(line, match, e1)) {
        id = match.str(1); val = match.str(2);
      } else if (std::regex_search(line, match, e2)) {
        id = match.str(1); val = "1";
      }
      if (id.empty()) {
        result += line + "\n";
        continue;
      }
      if (added.count(id)) continue;
      result += "const " + id + " = " + val + ";\n";
      added[id] = val;
    }
    return result;
  }
 
  // Preprocess a WGSL shader with the partial preprocessor.
  [[nodiscard]]
  std::string preprocessWgslShader(RenderTaskContext* rtc, const std::string& shaderPath,
                                   const EffectDescription& desc, const std::string& suffix)
  {
    std::string src;
    for (const auto& d : desc.definitions) {
      src += "#define " + d.first + " " + d.second + "\n";
    }
    src += "#include \"" + shaderPath + "\"\n";
 
    PartialPreprocessor pp;
    if (!pp.process(rtc->context, src)) {
      LOG_ERROR(logger, "TwinVisualsTexAtlasRenderTask: Failed to preprocess %s", shaderPath.c_str());
      return {};
    }
    src.swap(pp.processed);
    src = convertDefinesToConst(src);
 
    size_t code = Cogs::hash(src);
    std::string resourcePath = "TwinVisuals/Shaders/TexAtlasTask" + suffix + "_" + std::to_string(code) + ".wgsl";
    rtc->context->resourceStore->addResource(resourcePath, src);
    return resourcePath;
  }
 
  void setupGlobalBindings(RenderTaskContext* renderTaskContext, GlobalBinding& globalBinding, Cogs::EffectHandle effect)
  {
    Cogs::IEffects* effects = renderTaskContext->device->getEffects();
 
    globalBinding.sceneBufferBinding = effects->getConstantBufferBinding(effect, "SceneBuffer");
 
    globalBinding.shadowArrayBinding   = effects->getTextureBinding(effect, "cascadedShadowMap",   1);
    globalBinding.shadowArrayBinding_1 = effects->getTextureBinding(effect, "cascadedShadowMap_1", 1);
    globalBinding.shadowCubeArrayBinding   = effects->getTextureBinding(effect, "cubeShadowMap",   2);
    globalBinding.shadowCubeArrayBinding_1 = effects->getTextureBinding(effect, "cubeShadowMap_1", 2);
    globalBinding.shadowSamplerBinding = effects->getSamplerStateBinding(effect, "cascadedShadowSampler", 2);
 
    globalBinding.linearSampler              = effects->getSamplerStateBinding(effect, "linearSampler",                0);
    globalBinding.radianceSamplerBinding     = effects->getSamplerStateBinding(effect, "environmentRadianceSampler",   0);
    globalBinding.irradianceSamplerBinding   = effects->getSamplerStateBinding(effect, "environmentIrradianceSampler", 0);
    globalBinding.ambientIrradianceSamplerBinding = effects->getSamplerStateBinding(effect, "ambientIrradianceSampler", 0);
 
    globalBinding.skyBinding = effects->getTextureBinding(effect, "environmentSky", 0);
    globalBinding.skySamplerBinding = effects->getSamplerStateBinding(effect, "environmentSkySampler", 0);
  }
 
  void applyGlobalBindings(RenderTaskContext* renderTaskContext, GlobalBinding& globalBinding)
  {
    Cogs::IContext* deviceContext = renderTaskContext->device->getImmediateContext();
    EngineBuffers* engineBuffers  = renderTaskContext->engineBuffers;
    RenderResources* resources    = renderTaskContext->resources;
    RenderStates* states          = renderTaskContext->states;
 
    if (HandleIsValid(globalBinding.sceneBufferBinding)) {
      deviceContext->setConstantBuffer(globalBinding.sceneBufferBinding, engineBuffers->sceneBufferHandle);
    }
 
    if (bool shadowsEnabled = renderTaskContext->context->variables->get("renderer.shadowsEnabled", false); shadowsEnabled) {
      LightSystem* lightSystem = renderTaskContext->context->lightSystem;
 
      if (HandleIsValid(globalBinding.shadowArrayBinding)) {
        if (RenderTexture* shadowTexture = resources->getRenderTexture(lightSystem->cascadeArray); shadowTexture) {
          deviceContext->setTexture(globalBinding.shadowArrayBinding, shadowTexture->textureHandle);
        }
      }
 
      if (HandleIsValid(globalBinding.shadowArrayBinding_1)) {
        if (RenderTexture* shadowTexture = resources->getRenderTexture(lightSystem->cascadeArray); shadowTexture) {
          deviceContext->setTexture(globalBinding.shadowArrayBinding_1, shadowTexture->textureHandle);
        }
      }
 
      if (HandleIsValid(globalBinding.shadowCubeArrayBinding)) {
        if (RenderTexture* shadowTexture = resources->getRenderTexture(lightSystem->cubeArray); shadowTexture) {
          deviceContext->setTexture(globalBinding.shadowCubeArrayBinding, shadowTexture->textureHandle);
        }
      }
 
      if (HandleIsValid(globalBinding.shadowCubeArrayBinding_1)) {
        if (RenderTexture* shadowTexture = resources->getRenderTexture(lightSystem->cubeArray); shadowTexture) {
          deviceContext->setTexture(globalBinding.shadowCubeArrayBinding_1, shadowTexture->textureHandle);
        }
      }
 
      if (HandleIsValid(globalBinding.shadowSamplerBinding)) {
        deviceContext->setSamplerState(globalBinding.shadowSamplerBinding, states->shadowSampler);
      }
    }
 
    if (HandleIsValid(globalBinding.radianceSamplerBinding)) {
      deviceContext->setSamplerState(globalBinding.radianceSamplerBinding, states->defaultSampler);
    }
    if (HandleIsValid(globalBinding.irradianceSamplerBinding)) {
      deviceContext->setSamplerState(globalBinding.irradianceSamplerBinding, states->defaultSampler);
    }
    if (HandleIsValid(globalBinding.ambientIrradianceSamplerBinding)) {
      deviceContext->setSamplerState(globalBinding.ambientIrradianceSamplerBinding, states->defaultSampler);
    }
    if (HandleIsValid(globalBinding.brdfLUTSamplerBinding)) {
      deviceContext->setSamplerState(globalBinding.brdfLUTSamplerBinding, states->defaultSampler);
    }
    if (HandleIsValid(globalBinding.linearSampler)) {
      deviceContext->setSamplerState(globalBinding.linearSampler, states->defaultSampler);
    }
 
    if (HandleIsValid(globalBinding.skyBinding)) {
      EnvironmentSystem* environmentSystem = renderTaskContext->context->environmentSystem;
      EnvironmentComponent* env = environmentSystem ? environmentSystem->getGlobalEnvironment() : nullptr;
      if (env && env->skyDome) {
        if (RenderTexture* skyTexture = renderTaskContext->renderer->getRenderResources().getRenderTexture(env->skyDome); skyTexture) {
          deviceContext->setTexture(globalBinding.skyBinding, skyTexture->textureHandle);
        }
      }
    }
    if (HandleIsValid(globalBinding.skySamplerBinding)) {
      deviceContext->setSamplerState(globalBinding.skySamplerBinding, states->defaultSampler);
    }
  }
 
  Cogs::ResourceStatus setupEffect(RenderTaskContext* renderTaskContext, TwinVisualsTexAtlasRenderTask& task, TexAtlasState& state)
  {
    const RenderSettings& renderSettings = renderTaskContext->renderer->getSettings();
    const bool reverseDepth = renderTaskContext->context->variables->get("renderer.reverseDepth", false);
 
    EffectDescription desc;
    switch (renderTaskContext->renderer->getDevice()->getType()) {
    case Cogs::GraphicsDeviceType::OpenGLES30:
      desc.vs = "TwinVisuals/Shaders/TexAtlasTaskVS.es30.glsl";
      desc.ps = "TwinVisuals/Shaders/TexAtlasTaskPS.es30.glsl";
      break;
    case Cogs::GraphicsDeviceType::WebGPU:
      desc.vs = "TwinVisuals/Shaders/TexAtlasTaskVS.wgsl";
      desc.ps = "TwinVisuals/Shaders/TexAtlasTaskPS.wgsl";
      break;
    default:
      LOG_ERROR(logger, "TwinVisualsTexAtlasRenderTask: entity does not have a TexAtlasComponent");
      task.effectStatus = Cogs::ResourceStatus::Error;
      return Cogs::ResourceStatus::Error;
    }
 
    EnginePermutation* permutation = renderTaskContext->renderer->getEnginePermutations().get("Forward");
    for (auto& d : permutation->getDefinition()->definitions) {
      desc.definitions.emplace_back(d.first, d.second);
    }
 
    if (reverseDepth) {
      desc.definitions.push_back({ "COGS_REVERSE_DEPTH", "1" });
    }
 
    // See Default.permutations for defines.
    switch (renderSettings.sRGBConversion) {
      case RenderSettings::SRGBConversion::Fast:
        desc.definitions.push_back({ "COGS_SRGB_CONVERSION_FAST", "1" });
        break;
      case RenderSettings::SRGBConversion::Approx:
        desc.definitions.push_back({ "COGS_SRGB_CONVERSION_APPROX", "1" });
        break;
      case RenderSettings::SRGBConversion::Exact:
        desc.definitions.push_back({ "COGS_SRGB_CONVERSION_EXACT", "1" });
        break;
      default:
        assert(false && "Invalid enum");
        break;
    }
 
    // See Default.permutations for defines.
    switch (renderSettings.tonemapper) {
      case RenderSettings::Tonemapper::Reinhard:
        desc.definitions.push_back({ "COGS_TONEMAP_REINHARD", "1" });
        break;
      case RenderSettings::Tonemapper::Filmic:
        desc.definitions.push_back({ "COGS_TONEMAP_FILMIC", "1" });
        break;
      case RenderSettings::Tonemapper::ACESLuminance:
        desc.definitions.push_back({ "COGS_TONEMAP_ACES_LUMINANCE", "1" });
        break;
      case RenderSettings::Tonemapper::PBRNeutral:
        desc.definitions.push_back({ "COGS_TONEMAP_PBR_NEUTRAL", "1" });
        break;
      default:
        assert(false && "Invalid enum");
        break;
    }
 
    if (renderTaskContext->context->variables->get("renderer.backBuffer.sRGB", true)) {
      desc.definitions.emplace_back("OUTPUT_SRGB", "1");
    }
    if (task.inputSrgb) {
      desc.definitions.emplace_back("INPUT_SRGB", "1");
    }
    if (task.lumaInAlpha) {
      desc.definitions.emplace_back("LUMA_IN_ALPHA", "1");
    }
 
    static const std::string keys[4] = {
      "TEX_ATLAS_LEVELS_0",
      "TEX_ATLAS_LEVELS_1",
      "TEX_ATLAS_LEVELS_2",
      "TEX_ATLAS_LEVELS_3"
    };
    for (size_t i = 0; i < 4; i++) {
      if (0 < state.levels[i]) {
        desc.definitions.emplace_back(keys[i], std::to_string(state.levels[i]));
      }
    }
 
    switch (state.style) {
      case TwinVisualsTexAtlasStyle::Grayscale:
        desc.definitions.emplace_back("TEX_ATLAS_COLORING_GRAYSCALE", "1");
        break;
      case TwinVisualsTexAtlasStyle::None:
        desc.definitions.emplace_back("TEX_ATLAS_COLORING_NONE", "1");
        break;
      case TwinVisualsTexAtlasStyle::Color:
        break;
      default:
        assert(false && "Invalid enum");
        break;
    }
 
    EnvironmentSystem* environmentSystem = renderTaskContext->context->environmentSystem;
    EnvironmentComponent* env = environmentSystem ? environmentSystem->getGlobalEnvironment() : nullptr;
    if (env && env->skyDome) {
      desc.definitions.emplace_back("SKY_CUBEMAP", "1");
    }
 
    // For WebGPU, run the partial preprocessor to handle #ifdef/#include in WGSL
    if (renderTaskContext->renderer->getDevice()->getType() == Cogs::GraphicsDeviceType::WebGPU) {
      std::string vsPath = preprocessWgslShader(renderTaskContext, desc.vs, desc, "VS");
      std::string psPath = preprocessWgslShader(renderTaskContext, desc.ps, desc, "PS");
      if (vsPath.empty() || psPath.empty()) {
        LOG_ERROR(logger, "TwinVisualsTexAtlasRenderTask: Failed to preprocess WGSL shaders");
        task.effectStatus = Cogs::ResourceStatus::Error;
        return Cogs::ResourceStatus::Error;
      }
      desc.vs = vsPath;
      desc.ps = psPath;
      desc.definitions.clear();
    }
 
    CachedEffect* effect = renderTaskContext->renderer->getEffectCache().loadEffect(renderTaskContext, desc);
 
    Cogs::IEffects* effects = renderTaskContext->device->getEffects();
    Cogs::ResourceStatus status = HandleIsValid(effect->handle) ? effects->checkEffect(effect->handle) : Cogs::ResourceStatus::Error;
 
    if (status == Cogs::ResourceStatus::Ready && (task.effect != effect || task.effectStatus != Cogs::ResourceStatus::Ready)) {
      setupGlobalBindings(renderTaskContext, task.globalBinding, effect->handle);
    }
 
    if (status == Cogs::ResourceStatus::Error && task.effectStatus != Cogs::ResourceStatus::Error) {
      LOG_ERROR(logger, "TwinVisualsTexAtlasRenderTask: Invalid tex atlas effect handle.");
    }
 
    task.effect = effect;
    task.effectStatus = status;
    return status;
  }
}
 
Cogs::Core::TwinVisualsTexAtlasRenderTask::TwinVisualsTexAtlasRenderTask(
    RenderTaskContext* renderTaskContext,
    TexAtlasSystem* texAtlasSystem,
    TwinVisualsSystem* twinVisualsSystem,
    const RenderTaskDefinition& renderTaskDefinition,
    const PipelineOptions& /*pipelineOptions*/)
: texAtlasSystem(texAtlasSystem)
, twinVisualsSystem(twinVisualsSystem)
{
  assert(texAtlasSystem);
  assert(twinVisualsSystem);
  const bool reverseDepth = renderTaskContext->context->variables->get("renderer.reverseDepth", false);
 
  bool depthTest = true;
  bool depthWrite = true;
  for (const auto& p : renderTaskDefinition.parameters) {
    if (p.key == "clear") {
      p.asBool(clearColor);
    } else if (p.key == "blendMode") {
      blendMode = parseEnum<BlendMode>(p.value, blendMode);
    } else if (p.key == "depthTest") {
      p.asBool(depthTest);
    }
    else if (p.key == "writeDepth") {
      p.asBool(depthWrite);
    } else if (p.key == "inputSrgb") {
      p.asBool(inputSrgb);
    }
    else if (p.key == "outputSrgb") {
      p.asBool(outputSrgb);
    } else if (p.key == "lumaInAlpha") {
      p.asBool(lumaInAlpha);
    } else if (p.key == "viewportFromTarget") {
      p.asBool(viewportFromTarget);
    }
  }
 
  Cogs::IGraphicsDevice* device = renderTaskContext->renderer->getDevice();
  Cogs::IBuffers* buffers = device->getBuffers();
  Cogs::IRenderTargets* renderTargets = device->getRenderTargets();
 
  DepthStencilState depthState{};
  if (depthTest) {
    depthState = {
      .depthEnabled = true,
      .writeEnabled = depthWrite,
      // Do depth test, but we use OrEqual so ground-plane that goes beyond farplane can use far-plane depth and win the tie.
      .depthFunction = reverseDepth ? DepthStencilState::GreaterOrEqual : DepthStencilState::LessOrEqual
    };
  }
  else if (depthWrite) {
    depthState = {
      .depthEnabled = true,
      .writeEnabled = true,
      .depthFunction = DepthStencilState::Always
    };
  }
  else {
    depthState = {
      .depthEnabled = false,
      .writeEnabled = false,
      .depthFunction = DepthStencilState::Always
    };
  }
  depthStencilStateHandle = renderTargets->loadDepthStencilState(depthState);
 
  constants = buffers->loadBuffer(nullptr, sizeof(TexAtlasState::constants), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
}
 
Cogs::ResourceStatus Cogs::Core::TwinVisualsTexAtlasRenderTask::checkReady(RenderTaskContext* renderTaskContext)
{
  state = TexAtlasState{};
  RenderResources& renderResources = renderTaskContext->renderer->getRenderResources();
 
  const glm::dvec3 origin = renderTaskContext->context->transformSystem->getOrigin();
 
  size_t ix = 0;
  if (TwinVisualsComponent* tvComp = twinVisualsSystem->globalTwinVisualsComponent; tvComp) {
    state.style = tvComp->texAtlasStyle;
 
    // Calculate shift to use in shader
    const float c = std::cos(tvComp->gridRotation);
    const float s = std::sin(tvComp->gridRotation);
    glm::dvec2 o = glm::dvec2(origin) - tvComp->gridOrigin;
    glm::dmat2 R(c, s,
                -s, c);
    glm::vec2 shift = glm::vec2(fract((1.0 / double(tvComp->gridSpacingMaj)) * (R * o)));
 
    state.constants.backgroundColor = glm::convertSRGBToLinear(renderTaskContext->renderer->getBackgroundColor());
    state.constants.groundColor = tvComp->groundColor;
    state.constants.hazeColor = glm::vec4(tvComp->hazeColor,
                                          tvComp->hazeIntensity);
    state.constants.opaqueness = tvComp->groundOpaqueness;
    state.constants.groundElevation = float(tvComp->groundElevation - origin.z);
    state.constants.gridRotationCos = c;
    state.constants.gridRotationSin = s;
    state.constants.gridOffsetX = shift.x;
    state.constants.gridOffsetY = shift.y;
    state.constants.gridLineColorMaj = tvComp->gridLineColorMaj;
    state.constants.gridLineColorMin = tvComp->gridLineColorMin;
    state.constants.gridScaleMaj =  tvComp->gridEnable ? (1.f / tvComp->gridSpacingMaj) : 0.f;
    state.constants.lineWidthMaj = tvComp->gridLineWidthMaj;
    state.constants.lineWidthMin = tvComp->gridLineWidthMin;
    state.constants.fadeTweakMaj = tvComp->gridFadeTweakMaj;
    state.constants.fadeTweakMin = tvComp->gridFadeTweakMin;
 
    for (const WeakEntityPtr& weakEntity : tvComp->texAtlases) {
      if (ix >= 4) break;
 
      EntityPtr entity = weakEntity.lock();
      if (!entity) continue;
 
      TexAtlasComponent* texAtlasComp = entity->getComponent<TexAtlasComponent>();
      if (!texAtlasComp) {
        if (firstRun) {
          LOG_ERROR(logger, "TwinVisualsTexAtlasRenderTask: entity does not have a TexAtlasComponent");
        }
        continue;
      }
 
      TexAtlasData& texAtlasData = texAtlasSystem->getData(texAtlasComp);
      texAtlasData.inUse = true;
 
      RenderTexture* treeTex  = renderResources.getRenderTexture(texAtlasData.treeTex);
      RenderTexture* tilesTex = renderResources.getRenderTexture(texAtlasData.tilesTex);
      if (!treeTex || !tilesTex) continue;
 
      state.constants.floatCoeffs[ix] = texAtlasData.floatCoefficients;
      state.constants.intCoeffs[ix]   = texAtlasData.intCoefficients;
      state.tilesTex[ix] = tilesTex->textureHandle;
      state.treeTex[ix]  = treeTex->textureHandle;
      state.levels[ix]   = texAtlasData.levels;
      ix++;
    }
  }
 
  firstRun = false;
 
  return setupEffect(renderTaskContext, *this, state);
}
 
void Cogs::Core::TwinVisualsTexAtlasRenderTask::apply(RenderTaskContext* renderTaskContext)
{
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  RenderStates& renderStates = renderTaskContext->renderer->getRenderStates();
 
  RenderList* renderList    = input.get(RenderResourceType::RenderList)->renderList;
  RenderTarget* renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  updateEngineBuffers(renderTaskContext, renderTarget, renderList->viewportData, nullptr);
 
  IGraphicsDevice* device    = renderTaskContext->renderer->getDevice();
  IContext* deviceContext    = device->getImmediateContext();
  deviceContext->setEffect(effect->handle);
 
  if(renderTaskContext->device->getCapabilities()->getDeviceCapabilities().RenderPass){
    RenderPassInfo info;
    info.renderTargetHandle = renderTarget->renderTargetHandle;
    info.depthStencilHandle = DepthStencilHandle::NoHandle;
    info.loadOp[0] = clearColor ? LoadOp::Clear : LoadOp::Load;
    info.storeOp[0] = StoreOp::Store;
    glm::vec4 color = renderTarget->getClearColor();
    info.clearValue[0][0] = color[0];
    info.clearValue[0][1] = color[1];
    info.clearValue[0][2] = color[2];
    info.clearValue[0][3] = color[3];
    info.depthLoadOp = LoadOp::Load;
    info.depthStoreOp = StoreOp::Discard;
    deviceContext->beginRenderPass(info);
  }
  else{
    deviceContext->setRenderTarget(renderTarget->renderTargetHandle, DepthStencilHandle::NoHandle);
 
    if (clearColor) {
      deviceContext->clearRenderTarget(glm::value_ptr(renderTarget->getClearColor()));
    }
  }
 
  if (viewportFromTarget) {
    deviceContext->setViewport(0.0f, 0.0f, static_cast<float>(renderTarget->width), static_cast<float>(renderTarget->height));
  } else {
    deviceContext->setViewport(0, 0, renderTaskContext->renderer->getSize().x, renderTaskContext->renderer->getSize().y);
  }
  deviceContext->setDepthStencilState(depthStencilStateHandle);
  deviceContext->setRasterizerState(renderTaskContext->states->defaultRasterizerStateHandle);
  deviceContext->setBlendState(renderTaskContext->states->blendStates[size_t(blendMode)].handle);
  deviceContext->setVertexBuffers(nullptr, 0, nullptr, nullptr);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
 
  applyGlobalBindings(renderTaskContext, globalBinding);
 
  deviceContext->updateBuffer(constants, &state.constants, sizeof(TexAtlasState::constants));
  deviceContext->setConstantBuffer("TexAtlasCoefficients", constants);
 
  static const std::string texAtlasTilesTextureName[4] = {
    "texAtlasTiles0",
    "texAtlasTiles1",
    "texAtlasTiles2",
    "texAtlasTiles3"
  };
  static const std::string texAtlasTilesSamplerName[4] = {
    "texAtlasTiles0Sampler",
    "texAtlasTiles1Sampler",
    "texAtlasTiles2Sampler",
    "texAtlasTiles3Sampler"
  };
  static const std::string texAtlasTreeTextureName[4] = {
    "texAtlasTree0",
    "texAtlasTree1",
    "texAtlasTree2",
    "texAtlasTree3"
  };
  static const std::string texAtlasTreeSamplerName[4] = {
    "texAtlasTree0Sampler",
    "texAtlasTree1Sampler",
    "texAtlasTree2Sampler",
    "texAtlasTree3Sampler"
  };
 
  for (size_t i = 0; i < 4; i++) {
    deviceContext->setTexture(texAtlasTilesTextureName[i], uint32_t(i), state.tilesTex[i]);
    deviceContext->setSamplerState(texAtlasTilesSamplerName[i], uint32_t(i), renderStates.commonSamplerStates[1]); // Clamp + MinMagMipLinear
    deviceContext->setTexture(texAtlasTreeTextureName[i], uint32_t(i), state.treeTex[i]);
    deviceContext->setSamplerState(texAtlasTreeSamplerName[i], uint32_t(i), renderStates.commonSamplerStates[3]); // Clamp + MinMagMipPoint
  }
 
  if (RenderTaskResource* color = input.get(RenderResourceType::RenderTexture, "ColorTexture"); color && color->renderTexure) {
    deviceContext->setTexture("colorTexture", 5,  color->renderTexure->textureHandle);
    deviceContext->setSamplerState("colorTextureSampler", 5, renderStates.commonSamplerStates[1]); // Clamp + MinMagMipLinear
  }
  if (RenderTaskResource* depth = input.get(RenderResourceType::RenderTexture, "DepthTexture"); depth && depth->renderTexure) {
    deviceContext->setTexture("depthTexture", 6, depth->renderTexure->textureHandle);
    deviceContext->setSamplerState("depthTextureSampler", 6, renderStates.commonSamplerStates[3]); // Clamp + MinMagMipPoint
  }
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
  if (renderTaskContext->device->getCapabilities()->getDeviceCapabilities().RenderPass) {
    deviceContext->endRenderPass();
  }
}
 
void Cogs::Core::TwinVisualsTexAtlasRenderTask::cleanup(RenderTaskContext* renderTaskContext)
{
  Cogs::IGraphicsDevice* device = renderTaskContext->renderer->getDevice();
  Cogs::IBuffers* buffers = device->getBuffers();
  Cogs::IRenderTargets* renderTargets = device->getRenderTargets();
  if (HandleIsValid(constants)) {
    buffers->releaseBuffer(constants);
    constants = Cogs::BufferHandle::NoHandle;
  }
  if (HandleIsValid(depthStencilStateHandle)) {
    renderTargets->releaseDepthStencilState(depthStencilStateHandle);
    depthStencilStateHandle = Cogs::DepthStencilStateHandle::NoHandle;
  }
}