GenerateListTask.cpp

#include "GenerateListTask.h"
 
#include "Context.h"
#include "EntityStore.h"
 
#include "Components/Core/RenderComponent.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IBuffers.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderResources.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/CustomRenderer/DebugGeometryRenderers.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/Mesh.h"
 
#include "Services/Services.h"
#include "Services/Variables.h"
#include "Services/PipelineService.h"
 
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/RenderSystem.h"
#include "Systems/Core/SubMeshRenderSystem.h"
#include "Systems/Core/InstancedMeshRenderSystem.h"
#include "Systems/Core/SpriteRenderSystem.h"
#include "Systems/Core/AnimationSystem.h"
#include "Systems/Core/StaticModelSystem.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/ClipShapeSystem.h"
 
#ifdef _WIN32
// TODO: Remove when we update past GLM 0.9.9.7
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
#include <glm/ext/matrix_clip_space.hpp>
#pragma warning(pop)
#endif
 
#include <glm/gtx/transform.hpp>
 
namespace {
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GenerateListTask");
 
  constexpr uint32_t minObjectBufferCapacity = 1024;
}
 
namespace Cogs::Core
{
  const MaterialInstance * getControllingInstance(const MaterialInstance * instance, MaterialFlags::EMaterialFlags overrideFlag)
  {
    if (instance->masterInstance && ((instance->masterInstance->getMaterialFlags() & overrideFlag) == overrideFlag)) {
      return instance->masterInstance.resolve();
    }
 
    return instance;
  }
 
  void getTransparencyState(RenderStates & /*renderStates*/, const MaterialInstance * materialInstance, RenderItem & renderItem)
  {
    const auto instance = getControllingInstance(materialInstance, MaterialFlags::OverrideAlpha);
    const auto hasTransparency = instance->hasTransparency();
    auto blendMode = instance->options.blendMode;
 
    if (blendMode == BlendMode::None && hasTransparency) blendMode = BlendMode::Blend;
 
    renderItem.blendState = (uint16_t)blendMode;
  }
 
  RenderItemFlags getMaterialFlags(const MaterialInstance * materialInstance)
  {
    RenderItemFlags flags = RenderItemFlags::None;
    flags |= (materialInstance->instanceFlags & MaterialFlags::CustomBucket) != 0 ? RenderItemFlags::CustomBucket : RenderItemFlags::None;
    flags |= materialInstance->hasTransparency() ? RenderItemFlags::Transparent : RenderItemFlags::None;
    flags |= materialInstance->isBackdrop() ? RenderItemFlags::Backdrop : RenderItemFlags::None;
    return flags;
  }
}
 
uint8_t Cogs::Core::ClipShapeCache::getIndex(Context* context, ComponentModel::ComponentHandle clipShapeHandle)
{
  assert(!ComponentModel::ComponentHandle::Empty());
 
  // See if we have already seen this
  for (size_t i = 1; i < count; i++) {
    if (handles[i] == clipShapeHandle) {
      return static_cast<uint8_t>(i);
    }
  }
 
  // Not found, create a new one unless we have created more than 16
  if (ClipShapeComponent* clipComp = clipShapeHandle.resolveComponent<ClipShapeComponent>(); clipComp) {
    const ClipShapeData& clipData = context->clipShapeSystem->getData(clipComp);
 
    switch (clipData.shape) {
    case ClipShapeType::None:
      return 0;
    case ClipShapeType::Cube:
    case ClipShapeType::InvertedCube:
      if (count < ClipShapeCache::maxClipShapes) {
        handles[count] = clipShapeHandle;
        data[count] = {
          .clipEquations = {
            clipData.planes[0],
            clipData.planes[1],
            clipData.planes[2],
            clipData.planes[3],
            clipData.planes[4],
            clipData.planes[5]
          },
          .clipShape = clipData.shape
        };
        return static_cast<uint8_t>(count++);
      }
      break;
    default:
      assert(false && "Invalid enum");
    }
    LOG_ERROR_ONCE(logger, "Exceeding max number of clip shapes");
  }
  return 0;
}
 
 
Cogs::Core::RenderItem& Cogs::Core::GenerateListTask::createRenderItem(Context* context, RenderBatch& batch, const glm::mat4* localToWorld, const RenderComponent* renderComponent)
{
  if (renderComponent && (renderComponent->layer&RenderLayers::AllReserved)!=0) {
    LOG_WARNING_ONCE(logger, "Using a reserved RenderLayer (Consider switching to RenderLayer::Custom).");
  }
 
  RenderItem& item = batch.alloc();
  item = {};
  item.cullingIndex = (uint32_t)-1;
  if (localToWorld) {
    item.worldMatrix = localToWorld;
  }
  item.flags = RenderItemFlags::None;
 
  const uint32_t objectId = renderComponent ? renderComponent->objectId : NoObjectId;
 
  if (listObjectBuffer.isInUse()) {
 
    if (listObjectBuffer.cpuCapacity == listObjectBuffer.fill) {
      listObjectBuffer.cpuCapacity = std::max(minObjectBufferCapacity,
                                              listObjectBuffer.cpuCapacity + std::min(1024u * 16u, listObjectBuffer.cpuCapacity / 2));
      listObjectBuffer.cpu.resize(size_t(listObjectBuffer.stride) * listObjectBuffer.cpuCapacity);
    }
 
    item.flags |= RenderItemFlags::ObjectBufferSlot;
    item.objectBufferSlot = listObjectBuffer.fill++;
 
    ObjectBuffer* objectBuffer = reinterpret_cast<ObjectBuffer*>((uint8_t*)(listObjectBuffer.cpu.data()) + size_t(listObjectBuffer.stride) * item.objectBufferSlot);
    if (localToWorld) {
      objectBuffer->encodeWorldMatrix(*localToWorld);
    }
    objectBuffer->encodeObjectId(objectId);
  }
  else {
    item.objectId = objectId;
  }
 
  if (renderComponent) {
    ComponentModel::ComponentHandle clipShapeHandle = renderComponent->clipShapeComponent;
    if (clipShapeHandle != ComponentModel::ComponentHandle::Empty()) {
      item.clipShapeIx = clipShapeCache.getIndex(context, clipShapeHandle);
    }
  }
  return item;
}
 
size_t Cogs::Core::GenerateListTask::generateItems(Context* context, RenderBatch& batch, Renderer* renderer, RenderSystem* renderSystem, MeshSystem* /*meshSystem*/)
{
  size_t missing = 0;
  for (const auto& renderComponent : renderSystem->pool) {
    if (!renderComponent.isVisible()) continue;
 
    auto& renderData = renderSystem->getData<MeshRenderData>(&renderComponent);
 
    const MeshComponent* meshComponent = renderData.meshComponent.resolveComponent<MeshComponent>();
    if (meshComponent == nullptr) {
      LOG_ERROR_ONCE(logger, "No mesh component defined");
      continue;
    }
 
    RenderMesh * renderMesh = renderer->getRenderResources().getRenderMesh(meshComponent->meshHandle);
 
    if (!renderMesh) {
      ++missing;
      continue;
    }
 
    Mesh * mesh = meshComponent->meshHandle.resolve();
 
    MaterialInstance * materialInstance = renderComponent.material.resolve();
 
    if (!materialInstance) {
      ++missing;
      continue;
    }
 
    RenderItem& renderBlock = createRenderItem(context, batch, &renderData.localToWorld, &renderComponent);
    renderBlock.lod = renderComponent.lod;
    renderBlock.layer = renderComponent.layer;
    renderBlock.flags |= renderComponent.castShadows() ? RenderItemFlags::CastShadows : RenderItemFlags::None;
 
    if (renderComponent.disableCulling()) {
      renderBlock.flags |= RenderItemFlags::DisableCulling;
    }
 
    renderBlock.cullingIndex = renderData.cullingIndex;
 
 
    renderBlock.meshData = renderMesh;
 
    const uint32_t meshCount = mesh->getCount();
 
    if (renderComponent.vertexCount == uint32_t(-1)) {
      renderBlock.startIndex = 0;
      renderBlock.numIndexes = meshCount;
    }
    else {
      renderBlock.startIndex = renderComponent.startIndex;
      renderBlock.numIndexes = renderComponent.vertexCount;
      if (meshCount <= renderBlock.startIndex || meshCount < renderBlock.startIndex + renderBlock.numIndexes) {
        LOG_ERROR_ONCE(logger, "RenderComponent draw range is out of bounds");
        continue;
      }
    }
    renderBlock.primitiveType = renderComponent.primitiveType != (PrimitiveType)-1 ? renderComponent.primitiveType : mesh->primitiveType;
 
    if (mesh->isMeshFlagSet(MeshFlags::Instanced)) {
      renderBlock.flags |= RenderItemFlags::Instanced;
      renderBlock.numIndexes = mesh->getCount();
      renderBlock.numInstances = mesh->getInstanceCount();
    }
 
    if (mesh->isMeshFlagSet(MeshFlags::Skinned)) {
      const AnimationComponent* animationComponent = renderComponent.getComponent<AnimationComponent>();
      if (animationComponent == nullptr) {
        LOG_ERROR_ONCE(logger, "No animation component defined");
        continue;
      }
      const AnimationData& animationData = context->animationSystem->getData(animationComponent);
      renderBlock.poseData = animationData.pose.get();
    }
 
    renderBlock.flags |= !mesh->isCCW() ? RenderItemFlags::Clockwise : RenderItemFlags::None;
    renderBlock.flags |= getMaterialFlags(materialInstance);
    renderBlock.flags |= ((renderBlock.layer & RenderLayers::Sky) != RenderLayers::None) ? RenderItemFlags::Backdrop : RenderItemFlags::None;
 
    renderBlock.materialInstance = materialInstance;
 
    getTransparencyState(renderer->getRenderStates(), materialInstance, renderBlock);
    renderBlock.drawOrder = materialInstance->options.drawOrder != 0 ? materialInstance->options.drawOrder : renderComponent.drawOrder;
  }
 
  return missing;
}
 
void Cogs::Core::GenerateListTask::initialize(RenderTaskContext* renderContext)
{
  RenderTask::initialize(renderContext);
}
 
void Cogs::Core::GenerateListTask::cleanup(RenderTaskContext* renderContext)
{
  if (HandleIsValid(listObjectBuffer.gpu)) {
    IBuffers* buffers = renderContext->device->getBuffers();
    buffers->releaseBuffer(listObjectBuffer.gpu);
    listObjectBuffer.gpu = Cogs::BufferHandle::NoHandle;
  }
}
 
void Cogs::Core::GenerateListTask::apply(RenderTaskContext * renderTaskContext)
{
  RenderInstrumentationScope(renderTaskContext->device->getImmediateContext(), SCOPE_RENDERING, "GenerateListTask::apply");
 
  clipShapeCache.handles[0] = ComponentModel::ComponentHandle::Empty();
  clipShapeCache.data[0] = ClipShapeCache::Item{
    .clipShape = ClipShapeType::None
  };
  clipShapeCache.count = 1;
 
  auto & renderList = *output.get(RenderResourceType::RenderList)->renderList;
 
  auto context = renderTaskContext->context;
  auto renderer = renderTaskContext->renderer;
 
  ICapabilities* caps = renderTaskContext->device->getCapabilities();
 
  // Init array object buffer if requested
  bool useArrayObjectBuffer = false;
  const StringView arrayObjectBufferKey = "renderer.arrayObjectBuffer";
  if(renderTaskContext->device->getType() == GraphicsDeviceType::WebGPU){
    useArrayObjectBuffer = true; // Default on for WebGPU
  }
  if (Variable* var = context->variables->get(arrayObjectBufferKey); !var->isEmpty()) {
    useArrayObjectBuffer = var->getBool();
  }
  else {
    context->variables->set(arrayObjectBufferKey, useArrayObjectBuffer);
  }
  if(useArrayObjectBuffer && renderTaskContext->device->getType() != GraphicsDeviceType::WebGPU){
    LOG_WARNING(logger, "Only WebGPU supports renderer.arrayObjectBuffer. Base instance support lacking in other backends.");
    context->variables->set(arrayObjectBufferKey, false);
    useArrayObjectBuffer = false;
  }
 
  // Init list object buffer if requested
  bool useListObjectBuffer = false;
  const StringView listObjectBufferKey = "renderer.listObjectBuffer";
  if (Variable* var = context->variables->get(listObjectBufferKey); !var->isEmpty()) {
    useListObjectBuffer = var->getBool();
  }
  else {
    context->variables->set(listObjectBufferKey, useListObjectBuffer);
  }
  if(useArrayObjectBuffer) useListObjectBuffer = false; // Don't use both array and list object buffer
  if (useListObjectBuffer && caps->getDeviceCapabilities().ConstantBufferRange) {
    listObjectBuffer.stride = std::max(uint32_t(sizeof(ObjectBuffer)), uint32_t(caps->getDeviceCapabilities().ConstantBufferOffsetAlignment));
  }
  else {
    listObjectBuffer.stride = 0;
  }
  listObjectBuffer.fill = 0;
 
  renderList.clear();
  generateItems(context, renderList.batch, renderer, context->renderSystem, context->meshSystem);
 
  for (auto & staticModel : context->staticModelSystem->pool) {
    if (!staticModel.model) continue;
 
    auto renderSystem = context->staticModelSystem->getRenderSystem(&staticModel);
    auto meshSystem = context->staticModelSystem->getMeshSystem(&staticModel);
 
    if (!renderSystem || !renderSystem->pool.size()) continue;
 
    auto batch = context->staticModelSystem->getRenderBatch(&staticModel);
 
    if (batch->generation != renderSystem->getGeneration()) {
      batch->clear();
      auto missing = generateItems(context, *batch, renderer, renderSystem, meshSystem);
      batch->missing = missing;
      batch->generation = renderSystem->getGeneration();
    }
 
    renderList.batches.emplace_back(batch);
  }
 
  for (const SubMeshRenderComponent& renderComponent : context->subMeshRenderSystem->pool) {
    if (!renderComponent.isVisible()) continue;
 
    auto & renderData = context->subMeshRenderSystem->getData<SubMeshRenderData>(&renderComponent);
 
    const MeshComponent* meshComponent = renderData.meshComponent.resolveComponent<MeshComponent>();
    if (meshComponent == nullptr) {
      LOG_ERROR_ONCE(logger, "No mesh component defined");
      continue;
    }
 
    RenderMesh * renderMesh = renderer->getRenderResources().getRenderMesh(meshComponent->meshHandle);
 
    if (!renderMesh) continue;
 
    Mesh * mesh = meshComponent->meshHandle.resolve();
    const uint32_t meshCount = mesh->getCount();
 
    size_t subMeshBegin = 0;
    size_t subMeshEnd = mesh->getSubMeshes().size();
 
    if ((0 <= renderComponent.subMesh) && (static_cast<size_t>(renderComponent.subMesh) < subMeshEnd)) {
      subMeshBegin = renderComponent.subMesh;
      subMeshEnd = subMeshBegin + 1;
    }
 
    for (size_t m = subMeshBegin; m < subMeshEnd; ++m) {
      auto & subMesh = mesh->getSubMeshes()[m];
 
      if (subMesh.numIndexes && renderMesh->streamsLayout.numStreams) {
        auto materialInstance = ((renderComponent.materials.size() > m) ? renderComponent.materials[m] : renderComponent.materials.front()).resolve();
 
        if (!materialInstance) continue;
 
        RenderItem& renderBlock = createRenderItem(context, renderList.batch, &renderData.localToWorld, &renderComponent);
        renderBlock.lod = renderComponent.lod;
        renderBlock.layer = renderComponent.layer;
        renderBlock.flags |= renderComponent.castShadows() ? RenderItemFlags::CastShadows : RenderItemFlags::None;
 
        renderBlock.cullingIndex = renderData.cullingIndex;
 
        renderBlock.meshData = renderMesh;
        if (subMesh.numIndexes == uint32_t(-1)) {
          renderBlock.startIndex = 0;
          renderBlock.numIndexes = meshCount;
        }
        else {
          renderBlock.startIndex = subMesh.startIndex;
          renderBlock.numIndexes = subMesh.numIndexes;
          if (meshCount <= renderBlock.startIndex || meshCount < renderBlock.startIndex + renderBlock.numIndexes) {
            LOG_ERROR_ONCE(logger, "SubMeshRenderComponent draw range is out of bounds");
            continue;
          }
        }
 
        renderBlock.primitiveType = subMesh.primitiveType;
 
        if (mesh->isMeshFlagSet(MeshFlags::Skinned)) {
          auto animationComponent = renderComponent.getComponent<AnimationComponent>();
          const auto & animationData = context->animationSystem->getData(animationComponent);
          renderBlock.poseData = animationData.pose.get();
        }
 
        renderBlock.flags |= !mesh->isCCW() ? RenderItemFlags::Clockwise : RenderItemFlags::None;
        renderBlock.flags |= getMaterialFlags(materialInstance);
        renderBlock.flags |= ((renderBlock.layer & RenderLayers::Sky) != RenderLayers::None) ? RenderItemFlags::Backdrop : RenderItemFlags::None;
 
        renderBlock.materialInstance = materialInstance;
 
        getTransparencyState(renderer->getRenderStates(), materialInstance, renderBlock);
        renderBlock.drawOrder = materialInstance->options.drawOrder != 0 ? materialInstance->options.drawOrder : renderComponent.drawOrder;
      }
    }
  }
 
  for (const auto & renderComponent : context->instancedMeshRenderSystem->pool) {
    if (!renderComponent.isVisible()) continue;
 
    auto & renderData = context->instancedMeshRenderSystem->getData<InstancedMeshRenderData>(&renderComponent);
 
    const MeshComponent * meshComponent = renderData.meshComponent.resolveComponent<MeshComponent>();
 
    assert(meshComponent && "No mesh component defined");
 
    RenderMesh * renderMesh = renderer->getRenderResources().getRenderMesh(meshComponent->meshHandle);
    if (!renderMesh) continue;
 
    RenderMesh * instanceRenderMesh = renderer->getRenderResources().getRenderMesh(renderComponent.instanceMesh);
    if (!instanceRenderMesh) continue;
 
    Mesh * mesh = meshComponent->meshHandle.resolve();
    Mesh * instanceMesh = renderComponent.instanceMesh.resolve();
 
    MaterialInstance * materialInstance = renderComponent.material.resolve();
    if (!materialInstance) continue;
 
    const uint32_t instanceCount = InstancedMeshRenderComponent::getRenderCount(renderComponent.startInstance, renderComponent.instanceCount, instanceMesh->getCount());
    if (instanceCount == 0) {
      continue;
    }
 
    RenderItem& renderBlock = createRenderItem(context, renderList.batch, &renderData.localToWorld, &renderComponent);
    renderBlock.lod = renderComponent.lod;
    renderBlock.layer = renderComponent.layer;
    renderBlock.flags |= renderComponent.castShadows() ? RenderItemFlags::CastShadows : RenderItemFlags::None;
    renderBlock.flags |= RenderItemFlags::Instanced;
 
    renderBlock.cullingIndex = renderData.cullingIndex;
 
    renderBlock.meshData = renderMesh;
    renderBlock.instanceData = instanceRenderMesh;
    renderBlock.startIndex = renderComponent.startIndex;
    renderBlock.numIndexes = InstancedMeshRenderComponent::getRenderCount(renderComponent.startIndex, renderComponent.vertexCount, mesh->getCount());
    renderBlock.startInstance = renderComponent.startInstance;
    renderBlock.numInstances = instanceCount;
    renderBlock.primitiveType = renderComponent.primitiveType != (PrimitiveType) - 1 ? renderComponent.primitiveType : mesh->primitiveType;
 
    if (mesh->isMeshFlagSet(MeshFlags::Skinned)) {
      auto animationComponent = renderComponent.getComponent<AnimationComponent>();
      const auto & animationData = context->animationSystem->getData(animationComponent);
      renderBlock.poseData = animationData.pose.get();
    }
 
    renderBlock.flags |= !mesh->isCCW() ? RenderItemFlags::Clockwise : RenderItemFlags::None;
    renderBlock.flags |= getMaterialFlags(materialInstance);
    renderBlock.flags |= ((renderBlock.layer & RenderLayers::Sky) != RenderLayers::None) ? RenderItemFlags::Backdrop : RenderItemFlags::None;
 
    renderBlock.materialInstance = materialInstance;
 
    getTransparencyState(renderer->getRenderStates(), materialInstance, renderBlock);
    renderBlock.drawOrder = materialInstance->options.drawOrder != 0 ? materialInstance->options.drawOrder : renderComponent.drawOrder;
  }
 
  for (const SpriteBatch& batch : context->spriteRenderSystem->getSpriteBatches()) {
    if (!batch.count) continue;
 
    RenderMesh * renderMesh = renderer->getRenderResources().getRenderMesh(batch.mesh);
 
    if (!renderMesh || !renderMesh->numVertexes) {
      continue;
    }
 
    MaterialInstance * materialInstance = batch.material.resolve();
 
    if (!materialInstance) continue;
 
    RenderItem& renderBlock = createRenderItem(context, renderList.batch, &batch.transform, nullptr);
    renderBlock.lod = batch.lod;
    renderBlock.cullingIndex = NoCullingIndex;
    renderBlock.depth = batch.depth;
 
    renderBlock.flags |= batch.flags | RenderItemFlags::Sprite;
    renderBlock.layer = RenderLayers::Overlay;
 
    renderBlock.setBounds(&batch.bbox);
 
    renderBlock.materialInstance = materialInstance;
    renderBlock.blendState = (uint16_t)batch.blendMode;
 
    renderBlock.meshData = renderMesh;
    renderBlock.startIndex = static_cast<uint32_t>(batch.start);
    renderBlock.numIndexes = static_cast<uint32_t>(batch.count);
    renderBlock.primitiveType = batch.mesh->primitiveType;
  }
 
  if (context->variables->getOrAdd("renderer.showCoordSys", false)) {
 
    static auto renderCallback = [](RenderTaskContext * taskContext, DrawContext * drawContext, const RenderItem * item)
    {
      RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "showCoordSysRender");
      auto * renderer = taskContext->renderer;
      const auto M = renderer->getProjectionMatrix(glm::frustum(-0.7f, 0.7f, -0.7f, 0.7f, 1.0f, 3.0f)) * glm::translate(glm::vec3(0,0,-2.0f)) * glm::mat4(glm::mat3(drawContext->cameraData->viewMatrix));
      auto b = drawContext->cameraData->viewportOrigin.y + drawContext->cameraData->viewportSize.y;
      auto * deviceContext = taskContext->device->getImmediateContext();
      if(renderer->getDevice()->getType() == GraphicsDeviceType::OpenGLES30 ||
         renderer->getDevice()->getType() == GraphicsDeviceType::OpenGL20)
        deviceContext->setViewport(0, 0, 80, 80);
      else
        deviceContext->setViewport(0, b - 80, 80, 80);
      drawCoordSys(taskContext, drawContext, item, M, true);
      auto & o = drawContext->cameraData->viewportOrigin;
      auto & s = drawContext->cameraData->viewportSize;
      deviceContext->setViewport(o.x, o.y, s.x, s.y);
    };
 
    auto & item = renderList.createCustom(nullptr);
    item.layer = RenderLayers::Annotations;
    item.materialInstance = getDefaultMaterialInstance(context).resolve();
    item.blendState = (uint16_t)BlendMode::None;
    item.depthState = (uint16_t)DepthMode::Disabled;
 
    item.flags |= RenderItemFlags::Custom2 | RenderItemFlags::DisableCulling;
    item.callback = renderCallback;
  }
 
  if (context->variables->getOrAdd("renderer.showFrustums", false)) {
 
    static auto renderCallback = [](RenderTaskContext * taskContext, DrawContext * drawContext, const RenderItem * item)
    {
      RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "showFrustumsRender");
      const auto * camData = item->getCallbackData<CameraData>();
      const auto M = drawContext->cameraData->viewProjection * camData->inverseViewMatrix * glm::inverse(camData->rawProjectionMatrix);
      drawOneOneWireBox(taskContext, drawContext, item, M, static_cast<unsigned>(reinterpret_cast<size_t>(item->getCallbackData2<void>())));
    };
 
    size_t o = 0;
    auto genFrustumItem = [&](CameraData* cd, size_t i)
    {
      auto & item = renderList.createCustom(nullptr);
      item.layer = RenderLayers::Annotations;
      item.materialInstance = getDefaultMaterialInstance(context).resolve();
      item.blendState = (uint16_t)BlendMode::None;
      item.depthState = (uint16_t)DepthMode::Default;
 
      item.flags |= RenderItemFlags::Custom2 | RenderItemFlags::DisableCulling;
      item.setCallbackData(cd);
      item.setCallbackData2(reinterpret_cast<void*>(i));
      item.callback = renderCallback;
      o++;
    };
 
    auto* pipeService = context->services->getService<PipelineService>();
    for (const auto* run : pipeService->runs) {
      if (run->cameraData) {
        genFrustumItem(run->cameraData, o);
      }
    }
 
    for (const auto & cameraComp : context->cameraSystem->pool) {
      if ((cameraComp.flags & CameraFlags::EnableRender) != 0) {
        auto & camData = context->cameraSystem->getData(&cameraComp);
        genFrustumItem(&camData, o);
      }
    }
    for (const auto & lightComp : context->lightSystem->pool) {
      auto & lightData = context->lightSystem->getData(&lightComp);
      if (lightData.castShadows) {
        for (unsigned i = 0; i < lightData.numViewports; i++) {
          genFrustumItem(&lightData.lightCameraData[i], i);
        }
      }
    }
  }
 
  for (auto & extension : renderer->getExtensions()) {
    extension->generateCommands(renderTaskContext, &renderList);
  }
 
  // Update list object buffer if active
  if (listObjectBuffer.isInUse()) {
 
    if (2 * std::max(minObjectBufferCapacity, listObjectBuffer.fill) < listObjectBuffer.cpuCapacity) {
      listObjectBuffer.cpuCapacity = listObjectBuffer.cpuCapacity / 2;
      listObjectBuffer.cpu.resize(size_t(listObjectBuffer.stride)* listObjectBuffer.cpuCapacity);
    }
 
    if (listObjectBuffer.gpuCapacity != listObjectBuffer.cpuCapacity) {
 
      if (listObjectBuffer.gpuCapacity == 0) {
        LOG_DEBUG(logger, "Setting up list object buffer GPU storage");
      }
 
      listObjectBuffer.gpuCapacity = listObjectBuffer.cpuCapacity;
 
      IBuffers* buffers = renderTaskContext->device->getBuffers();
 
      if (HandleIsValid(listObjectBuffer.gpu)) {
        buffers->releaseBuffer(listObjectBuffer.gpu);
        listObjectBuffer.gpu = Cogs::BufferHandle::NoHandle;
      }
 
      listObjectBuffer.gpu = buffers->loadBuffer(nullptr,
                                                    size_t(listObjectBuffer.stride) * listObjectBuffer.gpuCapacity,
                                                    Usage::Dynamic,
                                                    AccessMode::Write,
                                                    BindFlags::ConstantBuffer);
      buffers->annotate(listObjectBuffer.gpu, "ListObjectBuffer");
 
    }
 
    if (listObjectBuffer.fill) {
      IContext* immediateContext = renderTaskContext->device->getImmediateContext();
      immediateContext->updateBuffer(listObjectBuffer.gpu,
                                     listObjectBuffer.cpu.data(),
                                     size_t(listObjectBuffer.stride) * listObjectBuffer.fill);
    }
 
    renderList.listObjectBuffer = &listObjectBuffer;
  }
  else if (HandleIsValid(listObjectBuffer.gpu)) {
 
    IBuffers* buffers = renderTaskContext->device->getBuffers();
    buffers->releaseBuffer(listObjectBuffer.gpu);
    listObjectBuffer.gpu = Cogs::BufferHandle::NoHandle;
    listObjectBuffer.gpuCapacity = 0;
 
    listObjectBuffer.cpu.clear();
    listObjectBuffer.cpuCapacity = 0;
 
    LOG_DEBUG(logger, "Released list object buffer GPU storage");
  }
 
  renderList.clipShapeCache = &clipShapeCache;
}