PotreeRenderer.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 "Renderer/CustomRenderer/DebugGeometryRenderers.h"
 
#include "PotreeRenderer.h"
#include "PotreeSystem.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/glm.hpp>
 
#include <array>
 
using namespace Cogs;
using namespace Cogs::Core;
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Potree");
 
  bool setRenderItemState(float& scale, RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    const auto* camData = drawContext->cameraData;
    if (camData == nullptr) return false;
 
    scale = 1.f;
    float w = camData->viewportSize.x;
    float h = camData->viewportSize.y;
    if (drawContext->task->viewportFromTarget && drawContext->renderTarget) {
      w = float(drawContext->renderTarget->width);
      h = float(drawContext->renderTarget->height);
      scale = 0.5f*(w / std::max(1.f, camData->viewportSize.x) + h / std::max(1.f, camData->viewportSize.y));
    }
   
    Renderer* renderer = taskContext->renderer;
 
    auto* device = renderer->getDevice();
    auto* 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];
    updateViewportBuffer(taskContext, taskContext->engineBuffers->sceneBufferHandle, taskContext->engineBuffers->viewBufferHandle, drawContext->renderTarget, renderItem->viewportData ? renderItem->viewportData : drawContext->cameraData, &clipShape.clipEquations);
 
    // Invokes updateSceneBindings
    // 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);
 
    // applyMaterialPerObject, but worldMatrix is stuffed with callback pointer
    const auto bindings = renderItem->binding;
    auto& engineBuffers = *drawContext->engineBuffers;
    auto* potreeData = static_cast<PotreeData*>(renderItem->callbackData);
    // assert(HandleIsValid(bindings->objectBufferBinding));
    if(!HandleIsValid(bindings->objectBufferBinding)) return false;
    {
      Cogs::MappedBuffer<ObjectBuffer> objectBuffer(iContext, engineBuffers.objectBufferHandle, Cogs::MapMode::WriteDiscard);
      if (objectBuffer) {
        objectBuffer->worldMatrix = potreeData->worldFromOcttreeFrame;
        objectBuffer->objectId = renderItem->objectId;
      }
    }
    iContext->setConstantBuffer(bindings->objectBufferBinding, engineBuffers.objectBufferHandle);
 
    return true;
  }
 
 
  void potreeCallback(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    auto* potreeData = static_cast<PotreeData*>(renderItem->callbackData);
    if (potreeData->state != PotreeState::Running) return;
 
    float scale = 1.f;
    if (!setRenderItemState(scale, taskContext, drawContext, renderItem)) return;
 
    // We use camera viewport to control rendering for consistent look during dynamic render resolution,
    // we pass the scaling factor so that pointsize sent to the rendering API can be adjusted.
    const float w = drawContext->cameraData->viewportSize.x;
    const float h = drawContext->cameraData->viewportSize.y;
 
    Cogs::Core::Renderer* renderer = taskContext->renderer;
    Cogs::IGraphicsDevice* device = renderer->getDevice();
    Cogs::IContext* iContext = device->getImmediateContext();
 
    if (!HandleIsValid(potreeData->octtreeTexture)) {
      return;
    }
    PotreeRenderer* potreeRenderer = static_cast<PotreeRenderer*>(renderItem->callbackData2);
    PotreeSystem* potreeSystem = potreeRenderer->potreeSystem;
    bool useInstancing = potreeSystem->useInstancing;
 
    iContext->setTexture("octtree", 0, potreeData->octtreeTexture);
    iContext->setSamplerState("octtreeSampler", 0, renderer->getRenderStates().commonSamplerStates[3]);
 
    float viewScale = std::cbrt(glm::determinant(glm::mat3(potreeData->worldFromOcttreeFrame) * glm::mat3(drawContext->cameraData->viewMatrix)));
 
    Cogs::Collections::SmallVector<glm::vec4, 7> passControl;
    passControl.push_back(glm::vec4(viewScale * potreeData->modelSpaceRadius,
                                    w * viewScale * potreeData->modelSpaceRadius,
                                    2.f / (w * scale), 2.f / (h * scale)));
    for (size_t i = 0; i < potreeData->clipPlaneCount; i++) {
      passControl.push_back(potreeData->clipPlanes[i] * drawContext->cameraData->inverseViewProjectionMatrix);
    }
    glm::vec4 pointControl[2] = {
      glm::vec4(potreeData->densitySized.levelScale,
                potreeData->densitySized.scale,
                potreeData->densitySized.bias,
                0.5f),
      glm::vec4(scale, 1.f / w, 1.f / h, 0.f)
    };
    // assert(HandleIsValid(potreeData->pointParametersBuffer));
    if(!HandleIsValid(potreeData->pointParametersBuffer)) return;
    {
      Cogs::MappedBuffer<PointParameters> buffer(iContext, potreeData->pointParametersBuffer, Cogs::MapMode::WriteDiscard);
      if(buffer){ // TODO can this buffer be prefilled outside the render loop?
        buffer->passControl[0] = passControl[0];
        for (size_t i = 1; i <= potreeData->clipPlaneCount; i++) {
          buffer->passControl[i] = passControl[i];
        }
        buffer->pointControl[0] = pointControl[0];
        buffer->pointControl[1] = pointControl[1];
      }
    }
    iContext->setConstantBuffer("PointParameters", potreeData->pointParametersBuffer);
 
 
    for (auto* cell : potreeData->activeCells) {
      if (cell->pointCount && HandleIsValid(cell->pointData)) {
        if (useInstancing) {
          VertexBufferHandle handles[2] = {
            cell->pointData,
            potreeRenderer->quadVertices
          };
          iContext->setVertexBuffers(handles, 2);
          iContext->drawInstanced(Cogs::PrimitiveType::TriangleStrip, 0, 4, 0, cell->pointCount);
        }
        else {
          iContext->setVertexBuffers(&cell->pointData, 1);
          iContext->draw(Cogs::PrimitiveType::PointList, 0, cell->pointCount);
        }
      }
    }
  }
 
  void potreeBoxCallback(RenderTaskContext* taskContext, DrawContext* drawContext, const RenderItem* renderItem)
  {
    auto* potreeData = static_cast<PotreeData*>(renderItem->callbackData);
    if (potreeData->state != PotreeState::Running) return;
 
    float scale = 1.f;
    if (!setRenderItemState(scale, taskContext, drawContext, renderItem)) return;
 
    auto* renderer = taskContext->renderer;
    auto* device = renderer->getDevice();
    auto* iContext = device->getImmediateContext();
 
    auto* potreeRenderer = static_cast<PotreeRenderer*>(renderItem->callbackData2);
 
    iContext->setVertexBuffers(&potreeRenderer->boxVertices, 1);
    iContext->setIndexBuffer(potreeRenderer->boxEdgeIndices, 2, 0);
 
    for (auto* cell : potreeData->activeCells) {
      if (cell->kind != PotreeCell::Kind::RegularNode) continue;
      if (potreeData->debugBoxes == PotreeDebugBoxes::ActiveLeafCells && (cell->texOffset == 0xffffu || potreeData->octtreeTextureData[cell->texOffset].r != 0)) continue;
 
      auto color = cell->owningSubtree->l + cell->l;// cell->owningSubtree->subtreeId * 4091;
 
      glm::vec4 boxControl[3] = {
        glm::vec4(cell->tbmin, 1.f),
        glm::vec4(cell->tbmax - cell->tbmin, 1.f),
        //glm::vec4(((color >> 0) & 0x3) / 15.f, ((color >> 2) & 0x3) / 15.f,((color >> 2) & 0x3) / 3.f,1.f)
        glm::vec4(((color >> 0) & 0x1), ((color >> 1) & 0x1), ((color >> 2) & 0x1), 1.f)
      };
      if(!HandleIsValid(cell->boxParametersBuffer)){
        auto* buffers = device->getBuffers();
        cell->boxParametersBuffer = buffers->loadBuffer(nullptr, sizeof(BoxParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
      }
      //assert(HandleIsValid(cell->boxParametersBuffer));
      if(!HandleIsValid(cell->boxParametersBuffer)) continue;
      {
        Cogs::MappedBuffer<BoxParameters> buffer(iContext, cell->boxParametersBuffer, Cogs::MapMode::WriteDiscard);
        if(buffer){ // TODO can this buffer be prefilled outside the render loop?
          buffer->boxControl[0] = boxControl[0];
          buffer->boxControl[1] = boxControl[1];
          buffer->boxControl[2] = boxControl[2];
        }
      }
      iContext->setConstantBuffer("BoxParameters", cell->boxParametersBuffer);
 
      iContext->drawIndexed(Cogs::PrimitiveType::LineList, 0, potreeRenderer->boxEdgeIndexPrimitives);
    }
 
    const glm::mat4 M = drawContext->cameraData->viewProjection * potreeData->frustum;
    drawOneOneWireBox(taskContext, drawContext, nullptr, M, 0);
  }
}
 
void Cogs::Core::PotreeRenderer::initialize(Context* context, IGraphicsDevice* device)
{
  this->device = device;
  this->context = context;
  potreeSystem = ExtensionRegistry::getExtensionSystem<PotreeSystem>(context);
  IBuffers* buffers = device->getBuffers();
 
  // Create a single quad (as triangle strip) used for instancing
  std::array<Cogs::VertexElement,1> quadElements =  {
    Cogs::VertexElement{0, Cogs::DataFormat::R32G32_FLOAT, Cogs::ElementSemantic::Position, 1, Cogs::InputType::VertexData, 0}
  };
  static const float quadVertexData[][2] = {
    { -1.f, -1.f },
    { 1.f, -1.f },
    { -1.f,  1.f },
    { 1.f,  1.f }
  };
  quadStreamsLayout.vertexFormats[0] = VertexFormats::createVertexFormat(quadElements.data(), quadElements.size());
  quadStreamsLayout.numStreams = 1;
  quadStreamsLayout.updateHash();
  quadVertices = buffers->loadVertexBuffer(quadVertexData, sizeof(quadVertexData) / sizeof(quadVertexData[0]), quadStreamsLayout.vertexFormats[0]);
 
  // Create wireframe unit box geometry
  std::array<Cogs::VertexElement,1> boxElements =  {
    Cogs::VertexElement{0, Cogs::DataFormat::R32G32B32_FLOAT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
  };
  static const float boxVertexData[][3] = {
    { 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 },
  };
  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
  };
 
  boxStreamsLayout.vertexFormats[0] = VertexFormats::createVertexFormat(boxElements.data(), boxElements.size());
  boxStreamsLayout.numStreams = 1;
  boxStreamsLayout.updateHash();
  boxVertices = buffers->loadVertexBuffer(boxVertexData, sizeof(boxVertexData) / sizeof(boxVertexData[0]), boxStreamsLayout.vertexFormats[0]);
  boxEdgeIndexPrimitives = static_cast<unsigned>(sizeof(boxEdgeIndexData) / sizeof(boxEdgeIndexData[0]));
  boxEdgeIndices = buffers->loadIndexBuffer(boxEdgeIndexData, boxEdgeIndexPrimitives, sizeof(boxEdgeIndexData[0]));
}
 
void Cogs::Core::PotreeRenderer::handleEvent(uint32_t eventId, const DrawContext * renderingContext)
{
  if (!renderingContext) return;
 
  switch (eventId) {
  case RenderingEvent::PreRender: {
    IBuffers* buffers = renderingContext->device->getBuffers();
    ITextures* textures = renderingContext->device->getTextures();
    for (auto& poComp : potreeSystem->pool) {
      PotreeDataHolder& poDataHolder = potreeSystem->getData(&poComp);
      PotreeData* poData = poDataHolder.poData.get();
      assert(poData);
 
      if(!HandleIsValid(poData->pointParametersBuffer)){
        poData->pointParametersBuffer = buffers->loadBuffer(nullptr, sizeof(PointParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
      }
 
      if (HandleIsValid(poData->octtreeTexture)) {
        textures->releaseTexture(poData->octtreeTexture);
        poData->octtreeTexture = Cogs::TextureHandle::NoHandle;
      }
 
      if (poData->octtreeTextureData.size()) {
        TextureDescription desc{};
        desc.target = Cogs::ResourceDimensions::Texture2D;
        desc.width = static_cast<uint32_t>(poData->octtreeTextureData.size());
        desc.height = 1;
        desc.format = Cogs::TextureFormat::R8G8B8A8_UNORM;
        desc.flags = Cogs::TextureFlags::Default;
 
        TextureData data(poData->octtreeTextureData.data(), TextureExtent{ desc.width, 1, 1 }, 1, 1, 1, desc.format);
        poData->octtreeTexture = textures->loadTexture(desc, &data);
      }
    }
    break;
  }
  case RenderingEvent::PostRender:
    break;
 
  default:
    break;
  }
}
 
void Cogs::Core::PotreeRenderer::generateCommands(const RenderTaskContext * renderingContext, RenderList * renderList)
{
  if (!renderingContext) return;
 
  for (auto & poComp : potreeSystem->pool) {
    if (!poComp.isVisible()) continue;
 
    PotreeDataHolder& poDataHolder = potreeSystem->getData(&poComp);
    PotreeData* poData = poDataHolder.poData.get();
    assert(poData);
 
    if (poData->state != PotreeState::Running) continue;
 
    // Just skip instance if we haven't gotten metadata yet
    if (poData->streamsLayout.numStreams == 0) continue;
 
    MaterialInstance* pointMaterialInstance = poData->pointMaterial.instance.resolve();
    if (pointMaterialInstance) {
 
      assert(!HandleIsValid(poComp.pointMaterial) || poComp.pointMaterial == poData->pointMaterial.instance);
 
      RenderItem& renderItem = renderList->createCustom(&poData->streamsLayout);
 
      if (!poComp.clipShapeComponent.Empty()) {
        renderItem.clipShapeIx = renderList->clipShapeCache->getIndex(context, poComp.clipShapeComponent);
      }
 
      renderItem.lod = poComp.lod;
      renderItem.layer = poComp.layer;
      renderItem.cullingIndex = ~0u;;
      renderItem.objectId = poComp.objectId;
      renderItem.flags |= (pointMaterialInstance->instanceFlags & MaterialFlags::CustomBucket) != 0 ? RenderItemFlags::CustomBucket : RenderItemFlags::None;
      renderItem.flags |= pointMaterialInstance->hasTransparency() ? RenderItemFlags::Transparent : RenderItemFlags::None;
      renderItem.flags |= pointMaterialInstance->isBackdrop() ? RenderItemFlags::Backdrop : RenderItemFlags::None;
      renderItem.flags |= poComp.castShadows() ? RenderItemFlags::CastShadows : RenderItemFlags::None;
      renderItem.materialInstance = pointMaterialInstance;
      getTransparencyState(renderingContext->renderer->getRenderStates(), pointMaterialInstance, renderItem);
      renderItem.drawOrder = pointMaterialInstance->options.drawOrder != 0 ? pointMaterialInstance->options.drawOrder : poComp.drawOrder;
      renderItem.setCallbackData(poData);
      renderItem.setCallbackData2(this);
      renderItem.callback = potreeCallback;
    }
 
    if (poComp.debugBoxes != PotreeDebugBoxes::None) {
      MaterialInstance* boxMaterialInstance = poData->boxMaterial.instance.resolve();
      if (boxMaterialInstance) {
 
        assert(!HandleIsValid(poComp.boxMaterial) || poComp.boxMaterial == poData->boxMaterial.instance);
 
        RenderItem& renderItem = renderList->createCustom(&boxStreamsLayout);
        renderItem.lod = poComp.lod;
        renderItem.layer = poComp.layer;
        renderItem.cullingIndex = ~0u;;
        renderItem.objectId = poComp.objectId;
        renderItem.flags |= (boxMaterialInstance->instanceFlags & MaterialFlags::CustomBucket) != 0 ? RenderItemFlags::CustomBucket : RenderItemFlags::None;
        renderItem.flags |= boxMaterialInstance->hasTransparency() ? RenderItemFlags::Transparent : RenderItemFlags::None;
        renderItem.flags |= boxMaterialInstance->isBackdrop() ? RenderItemFlags::Backdrop : RenderItemFlags::None;
        renderItem.flags |= poComp.castShadows() ? RenderItemFlags::CastShadows : RenderItemFlags::None;
        renderItem.materialInstance = boxMaterialInstance;
        getTransparencyState(renderingContext->renderer->getRenderStates(), boxMaterialInstance, renderItem);
        renderItem.drawOrder = boxMaterialInstance->options.drawOrder != 0 ? boxMaterialInstance->options.drawOrder : poComp.drawOrder;
        renderItem.setCallbackData(poData);
        renderItem.setCallbackData2(this);
        renderItem.callback = potreeBoxCallback;
      }
    }
 
  }
}