TexAtlasRenderer.cpp

#include "Context.h"
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IRenderTargets.h"
 
#include "Resources/MaterialManager.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/RenderList.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/Tasks/RenderListTask.h"
#include "Renderer/Tasks/GenerateListTask.h"
#include "Renderer/Tasks/FilterListTask.h"
#include "TexAtlasRenderer.h"
#include "TexAtlasSystem.h"
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexAtlas");
 
  struct ConstantsNone {
    glm::vec4 corners[8];
    glm::vec4 colorNone;
  };
 
  struct ConstantsEval {
    glm::vec2 coefficents[4];
    glm::vec2 domain[2];
    glm::vec4 colorEval;
    float elevationMin;
    float elevationMax;
  };
 
  void fullScreenTriangleInit(Context* context, TexAtlasRenderer* texAtlasRenderer)
  {
    Cogs::IGraphicsDevice* device = context->device;
    Cogs::IBuffers* buffers = device->getBuffers();
 
 
    Cogs::VertexElement element{
     Cogs::VertexElement{0, Cogs::DataFormat::R32G32_FLOAT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
    };
 
    auto& fullScreenTriangle = texAtlasRenderer->fullScreenTriangle;
 
    fullScreenTriangle.streamsLayout.vertexFormats[0] = Cogs::VertexFormats::createVertexFormat(element);
    fullScreenTriangle.streamsLayout.numStreams = 1;
    fullScreenTriangle.streamsLayout.updateHash();
 
    static const float fullScreenTriangleVertexData[] = {
      -1.f, -1.f,
       3.f, -1.f,
      -1.f,  3.f
    };
    fullScreenTriangle.vertices = buffers->loadVertexBuffer(fullScreenTriangleVertexData,
                                                            sizeof(fullScreenTriangleVertexData) / sizeof(fullScreenTriangleVertexData[0]),
                                                            fullScreenTriangle.streamsLayout.vertexFormats[0]);
  }
 
  constexpr const char* atlasBlitVS_es30 = R"(#version 300 es
precision highp float;
in vec2 a_POSITION;
void main()
{
  gl_Position  = vec4(a_POSITION, 0, 1);
}
)";
 
  constexpr const char* atlasBlitPS_es30 = R"(#version 300 es
precision highp float;
precision highp sampler2DArray;
uniform Params {
  int sourceLayer;
};
uniform sampler2DArray source;
out vec4 destination;
void main()
{
  destination = texelFetch(source, ivec3(floor(gl_FragCoord.xy), sourceLayer), 0);
}
)";
 
  constexpr const char* atlasBlitVS_wgsl = R"(
const a_POSITION0_LOC = 0;
 
struct VertexOutput {
  @builtin(position) position: vec4f,
};
 
@vertex
fn main(@location(a_POSITION0_LOC) a_POSITION: vec2f) -> VertexOutput {
  var output: VertexOutput;
  output.position = vec4f(a_POSITION, 0.0, 1.0);
  return output;
}
)";
  constexpr const char* atlasBlitPS_wgsl = R"(
struct ParamsType {
  sourceLayer: i32,
};
@group(0) @binding(0) var<uniform> Params: ParamsType;
@group(0) @binding(1) var source: texture_2d_array<f32>;
 
@fragment
fn main(@builtin(position) fragCoord: vec4f) -> @location(0) vec4f {
  let coord = vec2i(floor(fragCoord.xy));
  return textureLoad(source, coord, Params.sourceLayer, 0);
}
)";
  void atlasBlitInit(Context* context, TexAtlasRenderer* texAtlasRenderer)
  {
    if (context->device->getType() != Cogs::GraphicsDeviceType::OpenGLES30 && context->device->getType() != Cogs::GraphicsDeviceType::WebGPU) {
      return;
    }
    auto& atlasBlit = texAtlasRenderer->atlasBlit;
 
    Cogs::IGraphicsDevice* device = context->device;
    Cogs::IEffects* effects = device->getEffects();
    Cogs::IBuffers* buffers = device->getBuffers();
    Cogs::ITextures* textures = device->getTextures();
    Cogs::IRenderTargets* renderTargets = device->getRenderTargets();
 
    if (device->getType() == Cogs::GraphicsDeviceType::WebGPU) {
      atlasBlit.effect = effects->loadEffectSource(atlasBlitVS_wgsl, atlasBlitPS_wgsl, Cogs::EffectFlags::WGSL);
    } else {
      atlasBlit.effect = effects->loadEffectSource(atlasBlitVS_es30, atlasBlitPS_es30);
    }
    if (HandleIsValid(atlasBlit.effect)) {
      atlasBlit.inputLayout = buffers->loadInputLayout(&texAtlasRenderer->fullScreenTriangle.streamsLayout.vertexFormats[0], 1, atlasBlit.effect);
      atlasBlit.srcTexBinding = effects->getTextureBinding(atlasBlit.effect, "source", 0);
      atlasBlit.srcSamplerBinding = effects->getSamplerStateBinding(atlasBlit.effect, "sourceSampler", 0);
      atlasBlit.paramBinding = effects->getConstantBufferBinding(atlasBlit.effect, "Params");
    }
 
    atlasBlit.paramBuffer = buffers->loadBuffer(nullptr, std::max(sizeof(uint32_t), size_t(16)), Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer);
 
    atlasBlit.samplerState = textures->loadSamplerState({
      .addressModeS = Cogs::SamplerState::AddressMode::Clamp,
      .addressModeT = Cogs::SamplerState::AddressMode::Clamp,
      .addressModeW = Cogs::SamplerState::AddressMode::Clamp,
      .filter = Cogs::SamplerState::FilterMode::MinMagMipPoint,
      .comparisonFunction = Cogs::SamplerState::ComparisonFunction::Never,
      .maxAnisotropy = 1,
      .borderColor = { 0, 0, 0, 1 }
                                                        });
 
    atlasBlit.depthStencilState = renderTargets->loadDepthStencilState({
      .depthEnabled = false,
      .writeEnabled = true,
      .depthFunction = Cogs::DepthStencilState::Always
                                                                       });
 
    atlasBlit.blendState = renderTargets->loadBlendState({
      .enabled = 0,
      .sourceBlend = Cogs::BlendState::Blend::One,
      .destinationBlend = Cogs::BlendState::Blend::Zero,
      .operation = Cogs::BlendState::BlendOperation::Add
                                                         });
  }
 
  bool atlasTileBlit(Context* context, const TexAtlasRenderer* texAtlasRenderer,
                     Cogs::TextureHandle dstTex, uint32_t dstLayer,
                     Cogs::TextureHandle srcTex, uint32_t srcLayer,
                     uint32_t w, uint32_t h)
  {
    Cogs::IGraphicsDevice* device = context->device;
    Cogs::IRenderTargets* renderTargets = device->getRenderTargets();
    Cogs::IContext* immediateContext = device->getImmediateContext();
 
    Cogs::RenderTargetViewDescription view{
      .texture = dstTex,
      .layerIndex = static_cast<uint16_t>(dstLayer),
      .numLayers = 1,
      .levelIndex = 0
    };
    Cogs::RenderTargetHandle renderTarget = renderTargets->createRenderTarget(&view, 1);
 
    if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
      Cogs::RenderPassInfo info;
      info.renderTargetHandle = renderTarget;
      info.depthStencilHandle = Cogs::DepthStencilHandle::NoHandle;
      info.loadOp[0] = Cogs::LoadOp::Clear;
      info.storeOp[0] = Cogs::StoreOp::Store;
      info.clearValue[0][0] = 0.0;
      info.clearValue[0][1] = 0.0;
      info.clearValue[0][2] = 0.0;
      info.clearValue[0][3] = 0.0;
      info.depthLoadOp = Cogs::LoadOp::Undefined;
      info.depthStoreOp = Cogs::StoreOp::Discard;
      immediateContext->beginRenderPass(info);
    }
    else {
      immediateContext->setRenderTarget(renderTarget, Cogs::DepthStencilHandle::NoHandle);
    }
    immediateContext->setViewport(0.f, 0.f, static_cast<float>(w), static_cast<float>(h));
    immediateContext->updateBuffer(texAtlasRenderer->atlasBlit.paramBuffer, &srcLayer, sizeof(uint32_t));
    immediateContext->setEffect(texAtlasRenderer->atlasBlit.effect);
    immediateContext->setInputLayout(texAtlasRenderer->atlasBlit.inputLayout);
    immediateContext->setConstantBuffer(texAtlasRenderer->atlasBlit.paramBinding, texAtlasRenderer->atlasBlit.paramBuffer);
    immediateContext->setTexture(texAtlasRenderer->atlasBlit.srcTexBinding, srcTex);
    immediateContext->setSamplerState(texAtlasRenderer->atlasBlit.srcSamplerBinding, texAtlasRenderer->atlasBlit.samplerState);
    immediateContext->setVertexBuffers(&texAtlasRenderer->fullScreenTriangle.vertices, 1);
    immediateContext->setDepthStencilState(texAtlasRenderer->atlasBlit.depthStencilState);
    immediateContext->setBlendState(texAtlasRenderer->atlasBlit.blendState);
    immediateContext->draw(Cogs::PrimitiveType::TriangleStrip, 0, 4);
 
    if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
      immediateContext->endRenderPass();
    } else {
      immediateContext->setRenderTarget(Cogs::RenderTargetHandle::NoHandle, Cogs::DepthStencilHandle::NoHandle);
    }
    renderTargets->releaseRenderTarget(renderTarget);
 
    return true;
  }
 
 
  bool renderCallbackSetup(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    const CameraData* camData = drawContext->cameraData;
    if (camData == nullptr) return false;
 
    bool useCamData = 2.f < std::min(camData->viewportSize.x, camData->viewportSize.y);
 
    Renderer* renderer = taskContext->renderer;
    float w = useCamData ? camData->viewportSize.x : (drawContext->renderTarget ? drawContext->renderTarget->width : renderer->getSize().x);
    float h = useCamData ? camData->viewportSize.y : (drawContext->renderTarget ? drawContext->renderTarget->height : renderer->getSize().y);
 
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
    iContext->setViewport(camData->viewportOrigin.x, camData->viewportOrigin.y, w, h);
    iContext->setDepthStencilState(taskContext->states->commonDepthStates[renderItem->depthState]);
    iContext->setBlendState(taskContext->states->blendStates[renderItem->blendState].handle);
 
    const RenderPassOptions passOptions = initRenderPassOptions(*camData, renderItem->materialInstance);
    iContext->setRasterizerState(taskContext->states->rasterizerStateHandles[getRasterizerState(renderer, *renderItem, passOptions, camData->flipWindingOrder, true)]);
 
    const ClipShapeCache::Item& clipShape = drawContext->clipShapeCache->data[renderItem->clipShapeIx];
 
    // Invokes updateSceneBindings
    updateViewportBuffer(taskContext, taskContext->engineBuffers->sceneBufferHandle, taskContext->engineBuffers->viewBufferHandle, drawContext->renderTarget, renderItem->viewportData ? renderItem->viewportData : drawContext->cameraData, &clipShape.clipEquations);
 
    // Invokes updateMaterialBindings(instance=false)
    applyMaterialPermutation(taskContext, drawContext, renderItem->binding, renderItem->renderMaterialInstance);
 
    // Invokes updateEnvironmentBindings,
    // Updates permutation->constant buffers
    drawContext->task->applyMaterial(*drawContext, *renderItem);
 
    // Invokes updateMaterialBindings -> applyMaterialProperties 
    applyMaterialInstance(drawContext, renderItem->binding, renderItem->renderMaterialInstance);
 
    updateSceneBindings(drawContext, drawContext->cameraData, renderItem->binding);
 
    updateMaterialBindings(drawContext, renderItem->renderMaterialInstance, renderItem->binding, true);
 
    EngineBuffers& engineBuffers = *drawContext->engineBuffers;
    const EffectBinding* bindings = renderItem->binding;
    if (HandleIsValid(bindings->objectBufferBinding)) {
      {
        Cogs::MappedBuffer<ObjectBuffer> objectBuffer(iContext, engineBuffers.objectBufferHandle, Cogs::MapMode::WriteDiscard);
        if (objectBuffer) {
          objectBuffer->worldMatrix = glm::mat4(1.f, 0.f, 0.f, 0.f,
                                                0.f, 1.f, 0.f, 0.f,
                                                0.f, 0.f, 1.f, 0.f,
                                                0.f, 0.f, 0.f, 1.f);
          objectBuffer->objectId = renderItem->objectId;
        }
      }
      iContext->setConstantBuffer(bindings->objectBufferBinding, engineBuffers.objectBufferHandle);
    }
 
    return true;
  }
 
  void renderCallbackBase(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    if (!renderCallbackSetup(taskContext, drawContext, renderItem)) return;
 
    Renderer* renderer = taskContext->renderer;
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
    TexAtlasData* texAtlasData = renderItem->getCallbackData<TexAtlasData>();
    TexAtlasRenderer* texAtlasRenderer = renderItem->getCallbackData2<TexAtlasRenderer>();
 
 
    Cogs::IEffects* effects = device->getEffects();
    iContext->setVertexBuffers(&texAtlasRenderer->wireBoxVertices, 1);
    iContext->setIndexBuffer(texAtlasRenderer->wireBoxIndices, texAtlasRenderer->wireBoxIndexStride, 0);
 
    const TexAtlas::Geometry& geo = texAtlasData->geometry;
    if (Cogs::ConstantBufferBindingHandle constBinding = effects->getConstantBufferBinding(renderItem->binding->renderEffect->effectHandle, "ConstantsEval"); HandleIsValid(constBinding)) {
      ConstantsEval constants{
        .coefficents = { 
          geo.coefficients[0],
          geo.coefficients[1],
          geo.coefficients[2],
          geo.coefficients[3]
        },
        .domain = {
          glm::vec2(0.0, 0.0),
          glm::vec2(1.0, 1.0)
        },
        .colorEval = glm::vec4(1,1,1,1),
        .elevationMin = geo.elevationMin,
        .elevationMax = geo.elevationMax
      };
      iContext->updateBuffer(texAtlasRenderer->wireBoxConstants, &constants, sizeof(constants));
      iContext->setConstantBuffer(constBinding, texAtlasRenderer->wireBoxConstants);
      iContext->drawIndexed(Cogs::PrimitiveType::LineList, 0, texAtlasRenderer->wireBoxIndexCount);
    }
  }
 
 
  void renderCallbackTiles(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    if (!renderCallbackSetup(taskContext, drawContext, renderItem)) return;
 
    Renderer* renderer = taskContext->renderer;
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
    TexAtlasData* texAtlasData = renderItem->getCallbackData<TexAtlasData>();
    TexAtlasRenderer* texAtlasRenderer = renderItem->getCallbackData2<TexAtlasRenderer>();
 
 
    Cogs::IEffects* effects = device->getEffects();
    iContext->setVertexBuffers(&texAtlasRenderer->wireBoxVertices, 1);
    iContext->setIndexBuffer(texAtlasRenderer->wireBoxIndices, texAtlasRenderer->wireBoxIndexStride, 0);
 
    static const glm::vec4 colors[8] = {
      glm::vec4(1,0,0,1),
      glm::vec4(0,1,0,1),
      glm::vec4(1,1,0,1),
      glm::vec4(0,0,1,1),
      glm::vec4(1,0,1,1),
      glm::vec4(0,1,1,1),
      glm::vec4(0.5f, 1, 0.5f, 1),
      glm::vec4(1,0.5, 0.5f, 1),
    };
 
 
    if (Cogs::ConstantBufferBindingHandle constBinding = effects->getConstantBufferBinding(renderItem->binding->renderEffect->effectHandle, "ConstantsNone"); HandleIsValid(constBinding)) {
      ConstantsNone constants;
 
      const TexAtlas::LodTree& tree = texAtlasData->tree;
      for (size_t i = 0, n = tree.tiles.size(); i < n; i++) {
        texAtlasData->geometry.calcTileCorners(constants.corners, tree.tiles[i]);
        glm::vec4 c = glm::vec4(0.f);
        for (size_t k = 0; k < 8; k++) {
          c += (1.f / 8.f) * constants.corners[k];
        }
        for (size_t k = 0; k < 8; k++) {
          constants.corners[k] = glm::mix(constants.corners[k], c, (tree.tiles[i].level + 1) / 100.f);
        }
 
        constants.colorNone = glm::mix(colors[tree.tiles[i].level & 7u], glm::vec4(0.5f, 0.5f, 0.5f, 1.f), 0.5f);
        iContext->updateBuffer(texAtlasRenderer->wireBoxConstants, &constants, sizeof(constants));
        iContext->setConstantBuffer(constBinding, texAtlasRenderer->wireBoxConstants);
        iContext->drawIndexed(Cogs::PrimitiveType::LineList, 0, texAtlasRenderer->wireBoxIndexCount);
      }
 
    }
  }
 
  void renderCallbackFrustum(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    if (!renderCallbackSetup(taskContext, drawContext, renderItem)) return;
 
    Renderer* renderer = taskContext->renderer;
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
    TexAtlasRenderer* texAtlasRenderer = renderItem->getCallbackData2<TexAtlasRenderer>();
 
 
    Cogs::IEffects* effects = device->getEffects();
    iContext->setVertexBuffers(&texAtlasRenderer->wireBoxVertices, 1);
    iContext->setIndexBuffer(texAtlasRenderer->wireBoxIndices, texAtlasRenderer->wireBoxIndexStride, 0);
 
    if (Cogs::ConstantBufferBindingHandle constBinding = effects->getConstantBufferBinding(renderItem->binding->renderEffect->effectHandle, "ConstantsNone"); HandleIsValid(constBinding)) {
      ConstantsNone constants;
 
 
      constants.colorNone = glm::vec4(0.8f, 0.8f, 1.f, 1.f);
      for (size_t i = 0; i < 8; i++) {
        constants.corners[i] = texAtlasRenderer->frustumCorners[i];
      }
      iContext->updateBuffer(texAtlasRenderer->wireBoxConstants, &constants, sizeof(constants));
      iContext->setConstantBuffer(constBinding, texAtlasRenderer->wireBoxConstants);
      iContext->drawIndexed(Cogs::PrimitiveType::LineList, 0, texAtlasRenderer->wireBoxIndexCount);
    }
  }
 
}
 
void Cogs::Core::TexAtlasRenderer::initialize(Context* context, IGraphicsDevice* device)
{
  this->device = device;
 
  debugMaterial = context->materialManager->loadMaterial("Materials/TexAtlasDebug.material");
  context->materialManager->processLoading();
  debugMaterialNoneInstance = context->materialInstanceManager->createMaterialInstance(debugMaterial);
  debugMaterialNoneInstance->setVariant("Mode", "None");
 
  debugMaterialEvalInstance = context->materialInstanceManager->createMaterialInstance(debugMaterial);
  debugMaterialEvalInstance->setVariant("Mode", "Eval");
 
  const std::array<Cogs::VertexElement, 1> elements = {
  Cogs::VertexElement{0, Cogs::DataFormat::R32G32B32_FLOAT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
  };
  wireStreamsLayout.vertexFormats[0] = VertexFormats::createVertexFormat(elements.data(), elements.size());
  wireStreamsLayout.numStreams = 1;
  wireStreamsLayout.updateHash();
 
  Cogs::IBuffers* buffers = device->getBuffers();
 
  // Create wireframe unit box geometry
  static const float boxVertexData[] = {
    0.f, 0.f, 0.f,
    1.f, 0.f, 0.f,
    1.f, 1.f, 0.f,
    0.f, 1.f, 0.f,
    0.f, 0.f, 1.f,
    1.f, 0.f, 1.f,
    1.f, 1.f, 1.f,
    0.f, 1.f, 1.f,
  };
  wireBoxVertices = buffers->loadVertexBuffer(boxVertexData, sizeof(boxVertexData) / sizeof(boxVertexData[0]), wireStreamsLayout.vertexFormats[0]);
 
  static const uint16_t boxEdgeIndexData[] = {
    0, 1,   1, 2,   2, 3,   3, 0,
    4, 5,   5, 6,   6, 7,   7, 4,
    0, 4,   1, 5,   2, 6,   3, 7
  };
  wireBoxIndexStride = static_cast<uint32_t>(sizeof(boxEdgeIndexData[0]));
  wireBoxIndexCount = static_cast<uint32_t>(sizeof(boxEdgeIndexData) / wireBoxIndexStride);
  wireBoxIndices = buffers->loadIndexBuffer(boxEdgeIndexData, wireBoxIndexCount, wireBoxIndexStride);
 
  wireBoxConstants = buffers->loadBuffer(nullptr, std::max(sizeof(ConstantsNone), sizeof(ConstantsEval)), Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer, 0);
 
  fullScreenTriangleInit(context, this);
  atlasBlitInit(context, this);
}
 
TexAtlasRenderer::~TexAtlasRenderer()
{
  if (device) {
    Cogs::IBuffers* buffers = device->getBuffers();
 
    if (HandleIsValid(wireBoxVertices)) {
      buffers->releaseVertexBuffer(wireBoxVertices);
      wireBoxVertices = Cogs::VertexBufferHandle::NoHandle;
    }
    if (HandleIsValid(wireBoxIndices)) {
      buffers->releaseIndexBuffer(wireBoxIndices);
      wireBoxIndices = Cogs::IndexBufferHandle::NoHandle;
    }
    if (HandleIsValid(wireBoxConstants)) {
      buffers->releaseBuffer(wireBoxConstants);
      wireBoxConstants = Cogs::BufferHandle::NoHandle;
    }
  }
}
 
 
void Cogs::Core::TexAtlasRenderer::handleEvent(uint32_t eventId, const DrawContext* renderingContext)
{
  switch (eventId) {
  case RenderingEvent::PreRender: {
    Context* context = renderingContext->context;
    IContext* deviceContext = renderingContext->deviceContext;
 
    RenderResources& resources = renderingContext->renderer->getRenderResources();
 
    for (const TexAtlasComponent& texAtlasComp : texAtlasSystem->pool) {
      TexAtlasData& texAtlasData = texAtlasSystem->getData(&texAtlasComp);
 
      if (texAtlasData.tilesOldTex) {
        RenderTexture* tilesOldTex = resources.getRenderTexture(texAtlasData.tilesOldTex);
        RenderTexture* tilesTex = resources.getRenderTexture(texAtlasData.tilesTex);
        if (tilesOldTex && tilesTex) {
 
          uint32_t tilesToCopy = std::min(tilesTex->description.layers,
                                          tilesOldTex->description.layers);
          for (uint32_t l = 0; l < tilesToCopy; l++) {
            atlasTileBlit(context, this,
                          tilesTex->textureHandle, l,
                          tilesOldTex->textureHandle, l,
                          tilesTex->description.width, tilesTex->description.height);
          }
          texAtlasData.tilesOldTex = TextureHandle::NoHandle;
        }
      }
 
 
      if (!texAtlasData.fetcher.loaded.empty()) {
 
        RenderTexture* tilesTex = resources.getRenderTexture(texAtlasData.tilesTex);
        if (!tilesTex || !tilesTex->textureHandle) {
          LOG_ERROR(logger, "Failed to get tile texture");
          continue;
        }
 
        for (TexAtlas::Fetcher::LoadItem& loadItem : texAtlasData.fetcher.loaded) {
          RenderTexture* itemTex = resources.getRenderTexture(loadItem.texture);
          if (!itemTex || !itemTex->textureHandle) {
            LOG_ERROR(logger, "Failed to get item texture");
            continue;
          }
 
          deviceContext->copyTexture(tilesTex->textureHandle, loadItem.slotIx, 0, 0, 0, itemTex->textureHandle, 0);
        }
        texAtlasData.fetcher.loaded.clear();
      }
 
    }
  }
  default:
    break;
  }
}
 
void Cogs::Core::TexAtlasRenderer::generateCommands(const RenderTaskContext* renderingContext, RenderList* renderList)
{
  assert(renderingContext);
 
  MaterialInstance* debugMaterialNoneInstance = this->debugMaterialNoneInstance.resolve();
  if (!debugMaterialNoneInstance) return;
 
  MaterialInstance* debugMaterialEvalInstance = this->debugMaterialEvalInstance.resolve();
  if (!debugMaterialEvalInstance) return;
 
  if (renderFrustum) {
    {
      RenderItem& renderItem = renderList->createCustom(&wireStreamsLayout);
      renderItem.layer = RenderLayers::Overlay;
      renderItem.cullingIndex = ~0u;
      renderItem.materialInstance = debugMaterialNoneInstance;
      getTransparencyState(renderingContext->renderer->getRenderStates(), debugMaterialNoneInstance, renderItem);
      renderItem.drawOrder = debugMaterialEvalInstance->options.drawOrder;
      renderItem.setCallbackData2(this);
      renderItem.callback = renderCallbackFrustum;
    }
  }
 
  for (const TexAtlasComponent& texAtlasComp : texAtlasSystem->pool) {
 
    if (!texAtlasComp.debugBox) continue;
 
    TexAtlasData& texAtlasData = texAtlasSystem->getData(&texAtlasComp);
 
    {
      RenderItem& renderItem = renderList->createCustom(&wireStreamsLayout);
      renderItem.layer = RenderLayers::Overlay;
      renderItem.cullingIndex = ~0u;
      renderItem.materialInstance = debugMaterialEvalInstance;
      getTransparencyState(renderingContext->renderer->getRenderStates(), debugMaterialEvalInstance, renderItem);
      renderItem.drawOrder = debugMaterialEvalInstance->options.drawOrder;
      renderItem.setCallbackData(&texAtlasData);
      renderItem.setCallbackData2(this);
      renderItem.callback = renderCallbackBase;
    }
 
    {
      RenderItem& renderItem = renderList->createCustom(&wireStreamsLayout);
      renderItem.layer = RenderLayers::Overlay;
      renderItem.cullingIndex = ~0u;
      renderItem.materialInstance = debugMaterialNoneInstance;
      getTransparencyState(renderingContext->renderer->getRenderStates(), debugMaterialNoneInstance, renderItem);
      renderItem.drawOrder = debugMaterialNoneInstance->options.drawOrder;
      renderItem.setCallbackData(&texAtlasData);
      renderItem.setCallbackData2(this);
      renderItem.callback = renderCallbackTiles;
    }
 
  }
}