RendererExtension.cpp

#include "ExtensionRegistry.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderList.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/Tasks/RenderListTask.h"
#include "Renderer/Tasks/FilterListTask.h"
#include "Renderer/Tasks/GenerateListTask.h"
 
#include "Image360System.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IRenderTargets.h"
#include "Foundation/Logging/Logger.h"
 
#include <glm/glm.hpp>
 
#include <array>
 
 
namespace {
  using namespace Cogs::Core;
  using namespace Cogs::Core::Image360;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Image360");
 
  struct Constants
  {
    glm::mat4 worldFromLocal;
    glm::mat4 localFromWorld;
    float clipSpaceNearPlane;
    float valueScale;
    float valueBias;
    float depthScale;
    float depthBias;
    float baseSize;
    uint32_t noDataDepth;
  };
 
  void image360RenderCallback(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    const auto* camData = drawContext->cameraData;
    if (camData == nullptr) return;
 
    Renderer* renderer = taskContext->renderer;
 
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
    RendererExtension* im360Renderer = renderItem->getCallbackData<RendererExtension>();
    RendererExtensionData* rendererData = renderItem->getCallbackData2<RendererExtensionData>();
    if (!HandleIsValid(rendererData->encodedTreesTex)) {
      return;
    }
    if (!HandleIsValid(rendererData->value.tilesTex)) {
      return;
    }
 
    if (drawContext->task->viewportFromTarget && drawContext->renderTarget) {
      iContext->setViewport(0.f, 0.f, float(drawContext->renderTarget->width), float(drawContext->renderTarget->height));
    }
    else {
      iContext->setViewport(camData->viewportOrigin.x, camData->viewportOrigin.y, camData->viewportSize.x, camData->viewportSize.y);
    }
 
    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)]);
 
    // Invokes updateSceneBindings
    // Invokes updateMaterialBindings(instance=false)
    applyMaterialPermutation(taskContext, drawContext, drawContext->binding, renderItem->renderMaterialInstance);
 
    // INvokes updateEnvironmentBindings,
    // Updates permutation->constant buffers
    drawContext->task->applyMaterial(*drawContext, *renderItem, drawContext->binding);
 
    // Invokes updateMaterialBindings -> applyMaterialProperties 
    applyMaterialInstance(drawContext, drawContext->binding, renderItem->renderMaterialInstance);
 
    updateSceneBindings(drawContext, drawContext->cameraData, drawContext->binding);
 
    updateMaterialBindings(drawContext, renderItem->renderMaterialInstance, drawContext->binding, true);
 
    Cogs::IEffects* effects = device->getEffects();
 
    const glm::mat3 viewFromLocal = glm::mat3(drawContext->cameraData->viewMatrix) * rendererData->worldFromLocal;
    const glm::mat3 localFromView = rendererData->localFromWorld * glm::mat3(drawContext->cameraData->inverseViewMatrix);
    const float clipSpaceNearPlane = drawContext->context->variables->get("renderer.reverseDepth", false) ? 1.f : -1.f;
    const EffectBinding* bindings = drawContext->binding;
    const EngineBuffers& engineBuffers = *drawContext->engineBuffers;
 
    if (Cogs::ConstantBufferBindingHandle constantsBinding = effects->getConstantBufferBinding(bindings->renderEffect->effectHandle, "Constants"); HandleIsValid(constantsBinding)) {
      Constants constants{
        .worldFromLocal = rendererData->worldFromLocal,
        .localFromWorld = rendererData->localFromWorld,
        .clipSpaceNearPlane = clipSpaceNearPlane,
        .valueScale = rendererData->value.scale,
        .valueBias = rendererData->value.bias,
        .depthScale = rendererData->depth.scale,
        .depthBias = rendererData->depth.bias,
        .baseSize = float(rendererData->baseSize),
        .noDataDepth = rendererData->noDataDepth
      };
      iContext->updateBuffer(rendererData->constants, &constants, sizeof(constants));
      iContext->setConstantBuffer(constantsBinding, rendererData->constants);
    }
 
    if (HandleIsValid(bindings->objectBufferBinding)) {
      ObjectBuffer objectBuffer = {};
      objectBuffer.encodeObjectId(renderItem->objectId);
      iContext->updateBuffer(rendererData->constants, &objectBuffer, sizeof(objectBuffer));
      iContext->setConstantBuffer(bindings->objectBufferBinding, engineBuffers.objectBufferHandle);
    }
 
    iContext->setTexture("encodedTrees", 0, rendererData->encodedTreesTex);
    iContext->setSamplerState("encodedTreesSampler", 0, renderer->getRenderStates().commonSamplerStates[3]);
 
    if (rendererData->isValueUint) {
      iContext->setTexture("tilesValue_uint", 1, rendererData->value.tilesTex);
      iContext->setSamplerState("tilesValue_uintSampler", 1, renderer->getRenderStates().commonSamplerStates[rendererData->value.sampler]);
    }
    else
    {
      iContext->setTexture("tilesValue_srgb", 1, rendererData->value.tilesTex);
      iContext->setSamplerState("tilesValue_srgbSampler", 1, renderer->getRenderStates().commonSamplerStates[rendererData->value.sampler]);
    }
 
    iContext->setTexture("tilesDepth", 2, rendererData->depth.tilesTex);
    iContext->setSamplerState("tilesDepthSampler", 2, renderer->getRenderStates().commonSamplerStates[rendererData->depth.sampler]);
 
    iContext->setVertexBuffers(&im360Renderer->fullScreenTriangle.vertices, 1);
    iContext->draw(Cogs::PrimitiveType::TriangleList, 0, 3);
  }
 
 
  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* atlasBlitFloatPS_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* atlasBlitUIntPS_es30 = R"(#version 300 es
precision highp float;
precision highp int;
precision highp usampler2DArray;
uniform Params {
  int sourceLayer;
};
uniform usampler2DArray source;
out uvec4 destination;
void main()
{
  destination = texelFetch(source, ivec3(floor(gl_FragCoord.xy), sourceLayer), 0);
}
)";
 
 
  void atlasBlitInit(Context* context, Image360::RendererExtension* rendererExtension)
  {
    if (context->device->getType() != Cogs::GraphicsDeviceType::OpenGLES30) {
      return;
    }
    auto& atlasBlit = rendererExtension->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();
 
    // Reflection-dependent setup (input layout, bindings) for atlasBlit.f/.u is deferred to
    // RendererExtension::isReady(), which is polled until each effect's compile has settled.
    atlasBlit.f.effect = effects->loadEffectSource(atlasBlitVS_es30, atlasBlitFloatPS_es30);
    atlasBlit.u.effect = effects->loadEffectSource(atlasBlitVS_es30, atlasBlitUIntPS_es30);
 
    atlasBlit.paramBuffer = buffers->loadBuffer(nullptr, sizeof(uint32_t), 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 Image360::RendererExtension* rendererExtension,
                     Cogs::TextureHandle dstTex, uint32_t dstLayer,
                     Cogs::TextureHandle srcTex, uint32_t srcLayer,
                     uint32_t w, uint32_t h, Cogs::TextureFormat fmt)
  {
    bool formatIsFloat = true;
    switch (fmt) {
    case  Cogs::DataFormat::R8G8B8A8_UNORM:
    case  Cogs::DataFormat::R8G8B8A8_UNORM_SRGB:
      formatIsFloat = true;
      if (rendererExtension->atlasBlit.f.effectStatus != Cogs::ResourceStatus::Ready) {
        return false;
      }
      break;
    case Cogs::DataFormat::R16_UINT:
      formatIsFloat = false;
      if (rendererExtension->atlasBlit.u.effectStatus != Cogs::ResourceStatus::Ready) {
        return false;
      }
      break;
    default:
      LOG_ERROR_ONCE(logger, "Trying to blit unsupported format: %d", static_cast<uint32_t>(fmt));
      return false;
    }
 
    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(rendererExtension->atlasBlit.paramBuffer, &srcLayer, sizeof(uint32_t));
    if (formatIsFloat) {
      immediateContext->setEffect(rendererExtension->atlasBlit.f.effect);
      immediateContext->setInputLayout(rendererExtension->atlasBlit.f.inputLayout);
      immediateContext->setConstantBuffer(rendererExtension->atlasBlit.f.paramBinding, rendererExtension->atlasBlit.paramBuffer);
      immediateContext->setTexture(rendererExtension->atlasBlit.f.srcTexBinding, srcTex);
      immediateContext->setSamplerState(rendererExtension->atlasBlit.f.srcSamplerBinding, rendererExtension->atlasBlit.samplerState);
    }
    else {
      immediateContext->setEffect(rendererExtension->atlasBlit.u.effect);
      immediateContext->setInputLayout(rendererExtension->atlasBlit.u.inputLayout);
      immediateContext->setConstantBuffer(rendererExtension->atlasBlit.u.paramBinding, rendererExtension->atlasBlit.paramBuffer);
      immediateContext->setTexture(rendererExtension->atlasBlit.u.srcTexBinding, srcTex);
      immediateContext->setSamplerState(rendererExtension->atlasBlit.u.srcSamplerBinding, rendererExtension->atlasBlit.samplerState);
    }
    immediateContext->setVertexBuffers(&rendererExtension->fullScreenTriangle.vertices, 1);
    immediateContext->setDepthStencilState(rendererExtension->atlasBlit.depthStencilState);
    immediateContext->setBlendState(rendererExtension->atlasBlit.blendState);
    immediateContext->draw(Cogs::PrimitiveType::TriangleStrip, 0, 4);
 
    if(!device->getCapabilities()->getDeviceCapabilities().RenderPass){
      immediateContext->setRenderTarget(Cogs::RenderTargetHandle::NoHandle, Cogs::DepthStencilHandle::NoHandle);
    }
    renderTargets->releaseRenderTarget(renderTarget);
 
    return true;
  }
 
  // Polls a single atlasBlit shader variant (f or u) and lazily finishes its reflection-dependent
  // setup once compiled. Returns true once the variant has settled (either Ready or permanently
  // Error) so callers do not wait forever.
  bool pollAtlasBlitVariant(Image360::RendererExtension* rendererExtension, Image360::RendererExtension::AtlasBlitVariant& variant)
  {
    Cogs::IEffects* effects = rendererExtension->device->getEffects();
    Cogs::IBuffers* buffers = rendererExtension->device->getBuffers();
 
    Cogs::ResourceStatus status = effects->checkEffect(variant.effect);
 
    if (status == Cogs::ResourceStatus::Ready && variant.effectStatus != Cogs::ResourceStatus::Ready) {
      variant.inputLayout = buffers->loadInputLayout(&rendererExtension->fullScreenTriangle.streamsLayout.vertexFormats[0], 1, variant.effect);
      variant.srcTexBinding = effects->getTextureBinding(variant.effect, "source", 0);
      variant.srcSamplerBinding = effects->getSamplerStateBinding(variant.effect, "sourceSampler", 0);
      variant.paramBinding = effects->getConstantBufferBinding(variant.effect, "Params");
    }
 
    if (status == Cogs::ResourceStatus::Error && variant.effectStatus != Cogs::ResourceStatus::Error) {
      LOG_ERROR(logger, "Image360::RendererExtension: Failed to build atlas blit effect.");
    }
 
    variant.effectStatus = status;
 
    // Treat a permanently failed compile as settled too, so callers waiting for readiness don't
    // block forever - atlasTileBlit() falls back to a plain copyTexture() when status is Error.
    return status != Cogs::ResourceStatus::Pending;
  }
 
}
 
 
bool Cogs::Core::Image360::RendererExtension::isReady()
{
  if (context->device->getType() != Cogs::GraphicsDeviceType::OpenGLES30) {
    // atlasBlit isn't used on this device type (atlasBlitInit didn't load any effects), nothing to wait for.
    return true;
  }
 
  bool fSettled = pollAtlasBlitVariant(this, atlasBlit.f);
  bool uSettled = pollAtlasBlitVariant(this, atlasBlit.u);
  return fSettled && uSettled;
}
 
 
void Cogs::Core::Image360::RendererExtension::initialize(Context* context, IGraphicsDevice* device)
{
  this->device = device;
  this->context = context;
  im360System = ExtensionRegistry::getExtensionSystem<Image360System>(context);
 
  IBuffers* buffers = device->getBuffers();
 
 
  Cogs::VertexElement element{
   Cogs::VertexElement{0, Cogs::DataFormat::R32G32_FLOAT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
  };
  fullScreenTriangle.streamsLayout.vertexFormats[0] = 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]);
  atlasBlitInit(context, this);
}
 
 
void Cogs::Core::Image360::RendererExtension::release()
{
  IGraphicsDevice* device = context->renderer->getDevice();
  IBuffers* buffers = device->getBuffers();
  ITextures* textures = device->getTextures();
  if (HandleIsValid(fullScreenTriangle.vertices)) {
    buffers->releaseBuffer(fullScreenTriangle.vertices);
    fullScreenTriangle.vertices = BufferHandle::NoHandle;
  }
  for (Cogs::TextureHandle handle : texturesToRelease) {
    textures->releaseTexture(handle);
  }
  texturesToRelease.clear();
}
 
 
void Cogs::Core::Image360::RendererExtension::releaseRenderingResources(RendererExtensionData& rendererData)
{
  IGraphicsDevice* device = context->renderer->getDevice();
  ITextures* textures = device->getTextures();
  IBuffers* buffers = device->getBuffers();
 
  if (HandleIsValid(rendererData.constants)) {
    buffers->releaseBuffer(rendererData.constants);
    rendererData.constants = Cogs::BufferHandle::NoHandle;
  }
 
  if (HandleIsValid(rendererData.encodedTreesTex)) {
    textures->releaseTexture(rendererData.encodedTreesTex);
    rendererData.encodedTreesTex = Cogs::TextureHandle::NoHandle;
  }
 
  if (HandleIsValid(rendererData.value.tilesTex)) {
    textures->releaseTexture(rendererData.value.tilesTex);
    rendererData.value.tilesTex = Cogs::TextureHandle::NoHandle;
  }
 
  if (HandleIsValid(rendererData.depth.tilesTex)) {
    textures->releaseTexture(rendererData.depth.tilesTex);
    rendererData.depth.tilesTex = Cogs::TextureHandle::NoHandle;
  }
  rendererData.depth.tilesData.clear();
}
 
 
void Cogs::Core::Image360::RendererExtension::handleEvent(uint32_t eventId, const DrawContext * renderingContext)
{
  if (!renderingContext) return;
 
  switch (eventId) {
  case RenderingEvent::PreRender: {
    RenderResources & resources = renderingContext->renderer->getRenderResources();
 
    IContext* deviceContext = renderingContext->deviceContext;
    ITextures* textures = renderingContext->device->getTextures();
    IBuffers* buffers = renderingContext->device->getBuffers();
 
    // Release last frame's textures;
    for (Cogs::TextureHandle handle : texturesToRelease) {
      textures->releaseTexture(handle);
    }
    texturesToRelease.clear();
 
 
    for (Image360Component& im360Comp : im360System->pool) {
 
      Image360Data& im360Data = im360System->getData(&im360Comp);
      RendererExtensionData& rendererData = im360Data.rendererData;
 
      if ((im360Data.state == Image360Data::State::WaitingForBaseLevel) || (im360Data.state == Image360Data::State::Running))
      {
        im360Data.rendererData.baseSize = im360Data.config.baseSize;
        im360Data.rendererData.noDataDepth = im360Data.config.noDataDepth;
        if (im360Data.config.valueChannel < im360Data.config.channels.size()) {
          const Config::Channel& channel = im360Data.config.channels[im360Data.config.valueChannel];
          rendererData.value.scale = channel.scale;
          rendererData.value.bias = channel.bias;
          switch (channel.dataType) {
          case Config::Channel::DataType::U16: [[fallthrough]];
          case Config::Channel::DataType::U16_ZST:
            rendererData.value.sampler = 3;
            break;
          default:
            rendererData.value.sampler = 1;
            break;
          }
        }
        else {
          rendererData.value.scale = 1.f;
          rendererData.value.bias = 0.f;
        }
        rendererData.value.scale /= (im360Comp.valueDomainMax - im360Comp.valueDomainMin);
        rendererData.value.bias = (rendererData.value.bias - im360Comp.valueDomainMin) / (im360Comp.valueDomainMax - im360Comp.valueDomainMin);
 
 
        if (im360Data.config.hasDepth) {
          const Config::Channel& channel = im360Data.config.channels[im360Data.config.depthChannel];
          rendererData.depth.scale = channel.scale;
          rendererData.depth.bias = channel.bias;
          switch (channel.dataType) {
          case Config::Channel::DataType::U16: [[fallthrough]];
          case Config::Channel::DataType::U16_ZST:
            rendererData.depth.sampler = 3;
            break;
          default:
            rendererData.depth.sampler = 1;
            break;
          }
        }
 
        if (!HandleIsValid(rendererData.constants)) {
          rendererData.constants = buffers->loadBuffer(nullptr, sizeof(Constants), Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer, 0);
        }
 
        if (HandleIsValid(rendererData.encodedTreesTex)) {
          texturesToRelease.push_back(rendererData.encodedTreesTex);
          rendererData.encodedTreesTex = Cogs::TextureHandle::NoHandle;
        }
 
        if(!im360Data.lodTree.data.empty()) {
          TextureDescription desc{};
          desc.target = Cogs::ResourceDimensions::Texture2D;
          desc.width = static_cast<uint32_t>(im360Data.lodTree.data.size());
          desc.height = 1;
          desc.format = Cogs::TextureFormat::R16_SINT;
          desc.flags = Cogs::TextureFlags::Default;
 
          TextureData textureData(im360Data.lodTree.data.data(), TextureExtent{ desc.width, 1, 1 }, 1, 1, 1, desc.format);
          rendererData.encodedTreesTex = textures->loadTexture(desc, &textureData);
 
          if (rendererData.currentTreeSize != desc.width) {
            rendererData.currentTreeSize = desc.width;
            LOG_TRACE(logger, "Current tree size: %u", rendererData.currentTreeSize);
          }
        }
 
 
        uint32_t cacheItemCount = std::max(6u, static_cast<uint32_t>(im360Data.cache.items.size()));
        bool resizeCache = (!HandleIsValid(im360Data.rendererData.value.tilesTex) ||
                            (rendererData.gpuAllocatedCacheItemCount < cacheItemCount) ||
                            (cacheItemCount < rendererData.gpuAllocatedCacheItemCount / 2));
 
        if (resizeCache) {
 
          Cogs::ResourceDimensions target = Cogs::ResourceDimensions::Unknown;
          rendererData.gpuAllocatedCacheItemCount = cacheItemCount + (cacheItemCount + 9) / 10;  // No aggressive over-allocation since we don't grow one-by-one.
 
          rendererData.cacheLayout.cols = 1;
          rendererData.cacheLayout.rows = 1;
          rendererData.cacheLayout.layers = rendererData.gpuAllocatedCacheItemCount;
          target = Cogs::ResourceDimensions::Texture2DArray;
 
          // ------- Resize value texture
          {
            TextureDescription desc{};
            desc.target = target;
            desc.width = rendererData.cacheLayout.cols * im360Data.config.baseSize;
            desc.height = rendererData.cacheLayout.rows * im360Data.config.baseSize;
            desc.layers = rendererData.cacheLayout.layers;
            desc.flags = Cogs::TextureFlags::Default;
 
            assert(im360Data.config.valueChannel < im360Data.config.channels.size());
            switch (im360Data.config.channels[im360Data.config.valueChannel].dataType) {
 
            case Config::Channel::DataType::SRGB8_JPEG: [[fallthrough]];
            case Config::Channel::DataType::SRGB8_PNG: [[fallthrough]]; // D3D11 doesn't support 3-channel 8-bit format, probably promoted in GL anyways.
            case Config::Channel::DataType::SRGBA8_PNG:
              desc.format = Cogs::DataFormat::R8G8B8A8_UNORM_SRGB;
              break;
            case Config::Channel::DataType::U16: [[fallthrough]];
            case Config::Channel::DataType::U16_ZST:
              desc.format = Cogs::DataFormat::R16_UINT;
              break;
            default:
              assert(false && "Invalid enum value");
              break;
            }
            Cogs::TextureHandle tilesValueOldTex = rendererData.value.tilesTex;
            rendererData.value.tilesTex = textures->loadTexture(desc, nullptr);
            if (HandleIsValid(tilesValueOldTex)) {
              uint32_t toCopy = std::min(rendererData.gpuActiveCacheItemCount, rendererData.gpuAllocatedCacheItemCount);
              for (uint32_t i = 0; i < toCopy; i++) {
                if (im360Data.cache.items[i].value.state == Cache::Item::State::Resident) {
                  if (!atlasTileBlit(context, this,
                                     rendererData.value.tilesTex, i,
                                     tilesValueOldTex, i,
                                     im360Data.config.baseSize, im360Data.config.baseSize, desc.format))
                    {
                      deviceContext->copyTexture(rendererData.value.tilesTex,
                                                 i, 0, 0, 0,
                                                 tilesValueOldTex, i);
                    }
                }
              }
              texturesToRelease.push_back(tilesValueOldTex);
            }
          }
 
          // ------- Resize depth texture if enabled
          if (im360Data.config.hasDepth) {
 
            TextureDescription desc{};
            desc.target = target;
            desc.width = rendererData.cacheLayout.cols * im360Data.config.baseSize;
            desc.height = rendererData.cacheLayout.rows * im360Data.config.baseSize;
            desc.layers = rendererData.cacheLayout.layers;
            desc.flags = Cogs::TextureFlags::Default;
            switch (im360Data.config.channels[im360Data.config.depthChannel].dataType) {
            case Config::Channel::DataType::U16: [[fallthrough]];
            case Config::Channel::DataType::U16_ZST:
              desc.format = Cogs::DataFormat::R16_UINT;
              break;
            default:
              assert(false && "Invalid enum value");
              break;
            }
            Cogs::TextureHandle tilesDepthOldTex = rendererData.depth.tilesTex;
            rendererData.depth.tilesTex = textures->loadTexture(desc, nullptr);
            if (HandleIsValid(tilesDepthOldTex)) {
              uint32_t toCopy = std::min(rendererData.gpuActiveCacheItemCount, rendererData.gpuAllocatedCacheItemCount);
              for (uint32_t i = 0; i < toCopy; i++) {
                if (im360Data.cache.items[i].depth.state == Cache::Item::State::Resident) {
                  if (!atlasTileBlit(context, this,
                                     rendererData.depth.tilesTex, i,
                                     tilesDepthOldTex, i,
                                     im360Data.config.baseSize, im360Data.config.baseSize, desc.format))
                    {
                      deviceContext->copyTexture(rendererData.depth.tilesTex,
                                                 i, 0, 0, 0,
                                                 tilesDepthOldTex, i);
                    }
                }
              }
              texturesToRelease.push_back(tilesDepthOldTex);
            }
 
            rendererData.depth.tilesData.resize(rendererData.gpuAllocatedCacheItemCount);
          }
 
          LOG_DEBUG(logger, "gpuAllocatedCacheItemCount=%u", rendererData.gpuAllocatedCacheItemCount);
        }
 
        for (Fetcher::LoadItem& loadItem : im360Data.fetcher.itemsUploading) {
          Cache::Item& item = im360Data.cache.items[loadItem.slotIx];
 
          bool consumed = false;
          if (loadItem.channelIx == im360Data.config.valueChannel) {
            if (item.value.state == Cache::Item::State::Loaded) {
              uint32_t x = 0;
              uint32_t y = 0;
              uint32_t slice = loadItem.slotIx;
 
              RenderTexture* texture = resources.getRenderTexture(loadItem.texture);
              deviceContext->copyTexture(rendererData.value.tilesTex,
                                         slice, x, y, 0,
                                         texture->textureHandle, 0);
              item.value.state = Cache::Item::State::Resident;
            }
            consumed = true;
          }
          
          if (loadItem.channelIx == im360Data.config.depthChannel) {
            if (item.depth.state == Cache::Item::State::Loaded) {
              uint32_t x = 0;
              uint32_t y = 0;
              uint32_t slice = loadItem.slotIx;
 
              RenderTexture* texture = resources.getRenderTexture(loadItem.texture);
              deviceContext->copyTexture(rendererData.depth.tilesTex,
                                         slice, x, y, 0,
                                         texture->textureHandle, 0);
              item.depth.state = Cache::Item::State::Resident;
 
              size_t tileByteSize = sizeof(uint16_t) * im360Data.config.baseSize * im360Data.config.baseSize;
              if (loadItem.buffer && loadItem.buffer->size() == tileByteSize) {
 
                if (0 <= loadItem.slotIx && size_t(loadItem.slotIx) < rendererData.depth.tilesData.size()) {
                  rendererData.depth.tilesData[loadItem.slotIx] = std::move(loadItem.buffer);
                }
              }
            }
            consumed = true;
          }
 
          if (!consumed) {
            LOG_WARNING(logger, "Unexpected load item not uploaded to GPU");
          }
        }
        im360Data.fetcher.itemsUploading.clear();
 
        rendererData.gpuActiveCacheItemCount = static_cast<uint32_t>(im360Data.cache.items.size());
      }
      else {
        releaseRenderingResources(rendererData);
      }
    }
    break;
  }
 
  case RenderingEvent::PostRender:
    break;
 
  default:
    break;
  }
}
 
void Cogs::Core::Image360::RendererExtension::generateCommands(const RenderTaskContext * renderingContext, RenderList * renderList)
{
  if (!renderingContext) return;
  if (!HandleIsValid(im360System->material)) return;
 
  for (const Image360Component& im360Comp : im360System->pool) {
    if (!im360Comp.isVisible()) continue;
 
    Image360Data& im360Data = im360System->getData(&im360Comp);
    if (im360Data.state != Image360Data::State::Running) continue;
 
    if (!HandleIsValid(im360Data.materialInstance)) continue;
    const MaterialInstance* materialInstance = im360Data.materialInstance.resolve();
 
    RenderItem& renderItem = renderList->createCustom(&fullScreenTriangle.streamsLayout);
    renderItem.lod = im360Comp.lod;
    renderItem.layer = im360Comp.layer;
    renderItem.cullingIndex = ~0u;;
    renderItem.objectId = im360Comp.objectId;
    renderItem.flags |= (materialInstance->instanceFlags & MaterialFlags::CustomBucket) != 0 ? RenderItemFlags::CustomBucket : RenderItemFlags::None;
    renderItem.flags |= materialInstance->hasTransparency() ? RenderItemFlags::Transparent : RenderItemFlags::None;
    if (materialInstance->isBackdrop() || ((renderItem.layer & RenderLayers::Sky)) != RenderLayers::None) {
      renderItem.flags |= RenderItemFlags::Backdrop;
    }
    renderItem.materialInstance = materialInstance;
    getTransparencyState(renderingContext->renderer->getRenderStates(), materialInstance, renderItem);
    renderItem.drawOrder = materialInstance->options.drawOrder != 0 ? materialInstance->options.drawOrder : im360Comp.drawOrder;
    renderItem.setCallbackData(this);
    renderItem.setCallbackData2(&im360Data.rendererData);
    renderItem.callback = image360RenderCallback;
  }
}