OctRenderer.cpp

#include "Renderer/Tasks/RenderListTask.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/Tasks/FilterListTask.h"
#include "Resources/VertexFormats.h"
#include "Resources/MaterialManager.h"
#include "Components/Core/RenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Renderer/Tasks/RenderListTask.h"
#include "ExtensionRegistry.h"
 
#include "OctRenderer.h"
#include "../Systems/OctSystem.h"
 
#include "Rendering/RasterizerState.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IRenderTargets.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <unordered_map>
#include <iterator>
 
namespace {
  using namespace Cogs;
  using namespace Cogs::Core;
 
  struct InstanceData
  {
    glm::vec4 min;  // .w is age shift
    glm::vec4 max;  // .w is currently unused.
    glm::vec4 texpos;
    //glm::u16vec4 key;
    glm::uvec4 key;
  };
 
  struct OctParams
  {
    glm::vec3 eye_local;
    float valueMin;
    glm::vec3 lightdir_local;
    float valueScale; // 1.0/(max-min)
    float turbidity;
    float ageScale;
  };
 
  struct DebugConstants
  {
    glm::mat4 projectionMatrix;
    glm::mat4 viewMatrix;
    glm::mat4 worldMatrix;
    glm::vec4 diffuseColor;
  };
 
  static const uint32_t indices[] = {
    0, 1, 2,
    1, 3, 2,
 
    4, 6, 5,
    5, 6, 7,
 
    0, 4, 1,
    1, 4, 5,
 
    0, 2, 6, 
    6, 4, 0,
 
    1, 7, 3,
    1, 5, 7,
 
    3, 6, 2,
    3, 7, 6
  };
 
  static const uint32_t edgeIndices[] = {
    0, 1, 0, 2, 0, 4,
    1, 3, 1, 5,
    2, 3, 2, 6,
    3, 7,
    4, 5, 4, 6,
    5, 7,
    6, 7
  };
 
  static const glm::vec3 positions[] = {
    glm::vec3(0, 0, 0),
    glm::vec3(1, 0, 0),
    glm::vec3(0, 1, 0),
    glm::vec3(1, 1, 0),
 
    glm::vec3(0, 0, 1),
    glm::vec3(1, 0, 1),
    glm::vec3(0, 1, 1),
    glm::vec3(1, 1, 1),
  };
 
  static const glm::vec4 boxColor[4] = {
    glm::vec4(0.4f, 1.0f, 0.2f, 1.0f),
    glm::vec4(0.4f, 1.0f, 1.0f, 1.0f),
    glm::vec4(0.4f, 0.4f, 1.0f, 1.0f),
    glm::vec4(1.0f, 0.4f, 1.0f, 1.0f),
  };
 
  static void octtreeDebugRenderCallback(RenderTaskContext * taskContext, DrawContext * drawContext, const RenderItem * item)
  {
    RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_VOLUMETRIC, "Octtree::debugRenderCallback");
    auto * device = drawContext->device;
    auto * context = drawContext->deviceContext;
    const auto * octtreeData = (Volumetric::OctData*)item->callbackData;
    const auto * transComp = octtreeData->comp->getComponent<TransformComponent>();
    auto & worldFromLocal = drawContext->context->transformSystem->getLocalToWorld(transComp);
 
    Volumetric::OctSystem* octSys = octtreeData->comp->system;
    if (!octSys->isDebugEffectReady(drawContext->context)) {
      return;
    }
 
    //context->setRasterizerState(drawContext->renderer->renderStates.getRasterizerState(Cogs::RasterizerState::DefaultState()));
    context->setRasterizerState(taskContext->states->rasterizerStateHandles[drawContext->renderer->getRenderStates().getRasterizerState(Cogs::RasterizerState::DefaultState())]);
    context->setDepthStencilState(drawContext->renderer->getRenderStates().commonDepthStates[RenderStates::noWriteDepthStencilState]);
    context->setBlendState(drawContext->renderer->getRenderStates().blendStates[size_t(BlendMode::None)].handle);
 
    auto cubeIndices = device->getBuffers()->loadIndexBuffer(edgeIndices, sizeof(edgeIndices) / sizeof(uint32_t), sizeof(uint32_t));
    drawContext->deviceContext->setIndexBuffer(cubeIndices);
 
    Cogs::VertexBufferHandle cubeVertices = device->getBuffers()->loadVertexBuffer(positions,
                                                                                   sizeof(positions) / sizeof(glm::vec3),
                                                                                   Cogs::Core::VertexFormats::Pos3f); // format is Vec3f
    uint32_t strides[] = { sizeof(glm::vec3) };
    drawContext->deviceContext->setVertexBuffers(&cubeVertices, 1, strides, nullptr);
 
    context->setInputLayout(octSys->inputLayoutHandle);
    context->setEffect(octSys->effectHandle);
 
    Cogs::BufferHandle constantBuffer = device->getBuffers()->loadBuffer(nullptr, sizeof(DebugConstants), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
    auto renderNode = [&](const Volumetric::NodeBlock&  node)
    {
      glm::mat4 world =
        worldFromLocal *
        Volumetric::OctSystem::LocalFromIndexSpaceTransform(*octtreeData->comp, *octtreeData)*
        glm::translate(glm::mat4(), glm::vec3(node.extentMin)) *
        glm::scale(glm::mat4(), glm::vec3(node.extentMax - node.extentMin));
 
      //world = glm::translate(world, glm::vec3(octtreeData->shift.x + node.extentMin.x,
      //                                        octtreeData->shift.y + node.extentMin.y,
      //                                        octtreeData->shift.z + node.extentMin.z));
      //world = glm::scale(world, glm::vec3(node.extentMax - node.extentMin));
 
      //world = glm::scale(world, glm::vec3(static_cast<float>(1 << node.ix4.w)));
      //world = glm::translate(world, glm::vec3(node.ix4.x,
      //                                        node.ix4.y,
      //                                        node.ix4.z));
 
      {
        MappedBuffer<DebugConstants> constants(context, constantBuffer, MapMode::WriteDiscard);
        if (constants) {
          constants->projectionMatrix = drawContext->cameraData->projectionMatrix;
          constants->viewMatrix = drawContext->cameraData->viewMatrix;
          constants->worldMatrix = world;
          constants->diffuseColor = boxColor[node.ix4.w & 3];
        }
      }
      context->setConstantBuffer("DebugBuffer", constantBuffer);
 
      context->drawIndexed(Cogs::PrimitiveType::LineList, 0, 0);
    };
 
#if 1
    for (const auto nodeIx : octtreeData->front) {
      renderNode(octtreeData->nodes[nodeIx]);
    }
#elif 1
    for (const auto & node : octtreeData->nodes) {
      //if (node.ix4.w < 1) continue;
      //if(2 <= node.ix4.w) continue;
      renderNode(node);
    }
#else
    for (const auto & it : octtreeData->baseBlocks) {
      const auto & baseBlock = it.second;
 
      glm::mat4 world = glm::translate(glm::vec3(baseBlock.i - 0x7fff,
                                                 baseBlock.j - 0x7fff,
                                                 baseBlock.k - 0x7fff));
      {
        MappedBuffer<DebugConstants> constants(context, constantBuffer, MapMode::WriteDiscard);
        if (constants) {
          constants->projectionMatrix = drawContext->cameraData->projectionMatrix;
          constants->viewMatrix = drawContext->cameraData->viewMatrix;
          constants->worldMatrix = world;
          constants->diffuseColor = boxColor[node.ix4.w & 3];
        }
      }
      context->setConstantBuffer("DebugBuffer", constantBuffer);
 
      context->drawIndexed(Cogs::PrimitiveType::LineList, 0, 0);
    }
#endif
 
    device->getBuffers()->releaseBuffer(constantBuffer);
    device->getBuffers()->releaseIndexBuffer(cubeIndices);
    device->getBuffers()->releaseVertexBuffer(cubeVertices);
  }
 
  static void renderCallback(RenderTaskContext * taskContext, DrawContext * drawContext, RenderListTask* task, const RenderItem * item)
  {
    const auto * octData = (Volumetric::OctData*)item->callbackData;
    const auto * octComp = octData->comp;
    const auto * camData = drawContext->cameraData;
    auto * renderer = taskContext->renderer;
    auto * device = renderer->getDevice();
    auto * effects = device->getEffects();
    auto * iContext = device->getImmediateContext();
    auto * octtreeRenderer = octComp->system->renderer;
 
    iContext->setViewport(camData->viewportOrigin.x,
                          camData->viewportOrigin.y,
                          camData->viewportSize.x != 0 ? camData->viewportSize.x : renderer->getSize().x,
                          camData->viewportSize.y != 0 ? camData->viewportSize.y : renderer->getSize().y);
 
    //iContext->setDepthStencilState(item->depthState);
    iContext->setDepthStencilState(taskContext->states->commonDepthStates[item->depthState]);
    //iContext->setBlendState(item->transparencyState.blendState);
    iContext->setBlendState(taskContext->states->blendStates[item->blendState].handle);
    //iContext->setRasterizerState(getRasterizerState(renderer, item, camData->flipWindingOrder));
 
    const RenderPassOptions passOptions = initRenderPassOptions(*camData, item->materialInstance);
    iContext->setRasterizerState(taskContext->states->rasterizerStateHandles[getRasterizerState(renderer, *item, passOptions, camData->flipWindingOrder)]);
 
    applyMaterialPermutation(taskContext, drawContext, drawContext->binding, item->renderMaterialInstance);
    task->applyMaterial(*drawContext, *item, drawContext->binding);
    //updateEnvironmentBindings(drawContext, drawContext->binding);
    applyMaterialInstance(drawContext, drawContext->binding, item->renderMaterialInstance);
 
    //auto renderMaterialInstance = renderer->resources.getRenderMaterialInstance(materialInstance);
    assert(item->renderMaterialInstance);
 
    Cogs::VertexBufferHandle vertexBuffers[2] = {
      octtreeRenderer->cubeVertices,
      octData->instanceBufferHandle
    };
 
    //FIXME: Set strides/offsets.
    iContext->setVertexBuffers(vertexBuffers, 2);
    iContext->setIndexBuffer(octtreeRenderer->cubeIndices);
 
    EngineBuffers & engineBuffers = renderer->getEngineBuffers();
    ObjectBuffer & objectParameters = engineBuffers.objectBuffer;
 
 
    const auto & worldMatrix = taskContext->context->transformSystem->getLocalToWorld(octComp->getComponent<TransformComponent>());
    auto worldFromIndex =
      worldMatrix *
      Volumetric::OctSystem::LocalFromIndexSpaceTransform(*octComp, *octData);
 
    objectParameters.encodeWorldMatrix(worldFromIndex);
 
    auto localToView = camData->viewMatrix * worldFromIndex;
 
    const auto bindings = drawContext->binding;
    if(!HandleIsValid(engineBuffers.objectBufferHandle)) return;
    {
      Cogs::MappedBuffer<ObjectBuffer> objectBuffer(iContext, engineBuffers.objectBufferHandle, Cogs::MapMode::WriteDiscard);
      if (objectBuffer) std::memcpy(objectBuffer.get(), &objectParameters, sizeof(ObjectBuffer));
    }
    iContext->setConstantBuffer(bindings->objectBufferBinding, engineBuffers.objectBufferHandle);
    auto octBinding = effects->getConstantBufferBinding(drawContext->binding->renderEffect->effectHandle, "OctParams");
    if (HandleIsValid(octBinding)) {
      {
        auto eye_local = glm::inverse(localToView)*glm::vec4(0, 0, 0, 1);
        Cogs::MappedBuffer<OctParams> op(iContext, octtreeRenderer->octParamsBuffer, Cogs::MapMode::WriteDiscard);
 
        if (op) {
          op->eye_local = (1.f / eye_local.w)*glm::vec3(eye_local);
          op->valueMin = octComp->valueMin;
          op->lightdir_local = -glm::normalize(glm::vec3(1, 1, 1));
          op->valueScale = 1.f / (octComp->valueMax - octComp->valueMin);
          op->turbidity = std::max(1.f, octComp->turbidity);
          op->ageScale = octComp->ageScale;
        }
      }
      iContext->setConstantBuffer(octBinding, octtreeRenderer->octParamsBuffer);
    }
 
    unsigned unit = (unsigned)item->materialInstance->textureVariables.size();
    iContext->setTexture("atlasTexture0", unit, octData->atlas.textureAtlas0);
    iContext->setSamplerState("atlasSampler0", unit, octtreeRenderer->atlasSampler);
    unit++;
 
    if (HandleIsValid(octData->atlas.textureAtlas1)) {
      iContext->setTexture("atlasTexture1", unit, octData->atlas.textureAtlas1);
      iContext->setSamplerState("atlasSampler1", unit, octtreeRenderer->atlasSampler);
      unit++;
    }
 
    RenderTexture * transferTex = drawContext->renderer->getRenderResources().getRenderTexture(octComp->transferTexture);
    if (transferTex == nullptr) return;
 
    iContext->setTexture("transferTexture", unit, transferTex->textureHandle);
    iContext->setSamplerState("transferSampler", unit, octtreeRenderer->atlasSampler);
    unit++;
 
    iContext->drawInstancedIndexed(Cogs::PrimitiveType::TriangleList, 0, octData->instanceCount, 0, 36);
  }
}
 
void Cogs::Core::Volumetric::OctRenderer::initialize(Context * context, IGraphicsDevice * device)
{
  octSystem = ExtensionRegistry::getExtensionSystem<OctSystem>(context);
  this->device = device;
  this->context = context;
  auto * buffers = device->getBuffers();
  auto * textures = device->getTextures();
 
  octParamsBuffer = buffers->loadBuffer(nullptr, sizeof(OctParams), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  cubeIndices = device->getBuffers()->loadIndexBuffer(indices, sizeof(indices) / sizeof(uint32_t), sizeof(uint32_t));
  cubeVertices = device->getBuffers()->loadVertexBuffer(positions, sizeof(positions) / sizeof(glm::vec3), Cogs::Core::VertexFormats::Pos3f);
 
  SamplerState sampler = SamplerState::DefaultState();
  sampler.addressModeS = SamplerState::Clamp;
  sampler.addressModeT = SamplerState::Clamp;
  sampler.addressModeW = SamplerState::Clamp;
  sampler.filter = SamplerState::MinMagMipLinear;
  atlasSampler = textures->loadSamplerState(sampler);
 
 
  depthStencilState = device->getRenderTargets()->loadDepthStencilState(DepthStencilState{ true, false, DepthStencilState::Less });
 
  Cogs::VertexElement elements[] = {
    { sizeof(float) * 0, Cogs::DataFormat::X32Y32Z32W32_FLOAT, Cogs::ElementSemantic::InstanceVector, 0, Cogs::InputType::InstanceData, 1 },
    { sizeof(float) * 4, Cogs::DataFormat::X32Y32Z32W32_FLOAT, Cogs::ElementSemantic::InstanceVector, 1, Cogs::InputType::InstanceData, 1 },
    { sizeof(float) * 8, Cogs::DataFormat::X32Y32Z32W32_FLOAT, Cogs::ElementSemantic::InstanceVector, 2, Cogs::InputType::InstanceData, 1 },
    { sizeof(float) * 12, Cogs::DataFormat::R32G32B32A32_UINT, Cogs::ElementSemantic::InstanceVector, 3, Cogs::InputType::InstanceData, 1 }
  };
 
  octStreamsLayout.vertexFormats[0] = VertexFormats::Pos3f;
  octStreamsLayout.vertexFormats[1] = Cogs::VertexFormats::createVertexFormat(elements, std::size(elements));
  octStreamsLayout.numStreams = 2;
  octStreamsLayout.updateHash();
 
  defaultMatInstance = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
}
 
void Cogs::Core::Volumetric::OctRenderer::handleEvent(uint32_t eventId, const DrawContext * renderingContext)
{
  auto * iContext = device->getImmediateContext();
  auto * buffers = device->getBuffers();
 
  switch (eventId) {
  case RenderingEvent::PreRender:
    for (auto & octComp : octSystem->pool) {
      auto & octData = octSystem->getData(&octComp);
 
      if (octData.gpuCacheWipe) handleAtlasWipe(renderingContext, octComp, octData);
 
      octData.atlas.handleStaging(renderingContext, octComp, octData, octData.currentTimestamp);
 
      octData.instanceCount = static_cast<unsigned>(octData.front.size());
      if (octData.instanceCount) {
        {
          static bool missingDataPrev = false;
 
          bool missingData = false;
 
          unsigned W = octComp.tileSize * octComp.gpuCacheSize;
 
          float texW = (octComp.tileSize - 2.f) / W;
          float texS = 1.f / W;
 
          octData.instanceBufferHandle = buffers->loadVertexBuffer(nullptr, octData.instanceCount, octStreamsLayout.vertexFormats[1]);
          Cogs::MappedBuffer<InstanceData> instanceData(iContext, octData.instanceBufferHandle, Cogs::MapMode::WriteDiscard, octData.front.size());
 
          if (instanceData) {
            for (size_t i = 0; i < octData.instanceCount; i++) {
              const auto & node = octData.nodes[octData.front[i]];
 
              auto slotPos = octData.atlas.slotPosition(octComp, createTileKey(node.ix4, octData.alignMinToZeroShift));
 
              bool missing = (slotPos.x == 0) && (slotPos.y == 0) && (slotPos.z == 0);
 
              if (missing) missingData = true;
 
 
              const float scale = static_cast<float>(1 << node.ix4.w);
              const glm::uvec3 lll = glm::uvec3(node.ix4.x << node.ix4.w,
                                                node.ix4.y << node.ix4.w,
                                                node.ix4.z << node.ix4.w);
 
              float ageShift = 0.f;
              if (octComp.alphaCallback.func) {
                ageShift = octComp.alphaCallback.func(octComp.alphaCallback.data,
                                                      octData.atlas.slots[slotPos.w].clientData);
              }
 
              instanceData[i].min = glm::vec4((1.f / scale)*glm::vec3(glm::uvec3(node.extentMin) - lll), ageShift);
              instanceData[i].max = glm::vec4((1.f / scale)*glm::vec3(glm::uvec3(node.extentMax) - lll), 0.f);
 
              instanceData[i].texpos = glm::vec4((float)slotPos.x / octComp.gpuCacheSize + texS,
                                                 (float)slotPos.y / octComp.gpuCacheSize + texS,
                                                 (float)slotPos.z / octComp.gpuCacheSize + texS,
                                                 missing ? -1.f : texW);
 
              assert(0 <= instanceData[i].min.x);
              assert(0 <= instanceData[i].min.y);
              assert(0 <= instanceData[i].min.z);
              assert(instanceData[i].max.x <= 1.f);
              assert(instanceData[i].max.y <= 1.f);
              assert(instanceData[i].max.z <= 1.f);
              instanceData[i].key = node.ix4;
            }
          }
          if (missingDataPrev != missingData) {
            //std::cerr << "Render tile is " << (missingData ? "" : "not ") << "missing\n";
            missingDataPrev = missingData;
          }
        }
      }
    }
    break;
 
  case RenderingEvent::PostRender:
    for (const auto & octRenderComp : octSystem->pool) {
      auto & octRenderData = octSystem->getData(&octRenderComp);
      if (octRenderData.instanceCount) {
        buffers->releaseVertexBuffer(octRenderData.instanceBufferHandle);
      }
    }
    break;
  default:
    break;
  }
}
 
void Cogs::Core::Volumetric::OctRenderer::handleAtlasWipe(const DrawContext * renderingContext, OctComponent& octComp, OctData& octData)
{
  octData.gpuCacheWipe = false;
  octComp.tileRequests.clear();
 
  while (!octData.tileResponses.empty()) {
    octData.tileResponsesStash.push_back(std::move(octData.tileResponses.back()));
    octData.tileResponses.pop_back();
  }
  octData.atlas.reset(renderingContext, octData, octComp.tileSize, octComp.gpuCacheSize, octData.currentTimestamp);
}
 
void Cogs::Core::Volumetric::OctRenderer::generateCommands(const RenderTaskContext * /*renderingContext*/, RenderList * renderList)
{
  for (auto & octComp : octSystem->pool) {
    auto * sceneComp = octComp.getComponent<SceneComponent>();
    if (sceneComp->visible == false) continue;
 
    const auto * transformComponent = octComp.getComponent<TransformComponent>();
    if (!transformComponent) continue;
 
    auto & octData = octSystem->getData(&octComp);
    if (octData.instanceCount == 0) continue;
 
    if (!HandleIsValid(octData.atlas.textureAtlas0)) continue;
 
    if (octComp.drawDebug) {
      auto & item = renderList->createCustom(&debugStreamsLayout);
      item.layer = RenderLayers::Default;
      //item.bbox = Geometry::BoundingBox{ glm::vec3(-100.f), glm::vec3(100.f) };  // FIXME: world-space bounds
 
      //item.material = defaultMatInstance->material;
      item.materialInstance = defaultMatInstance.resolve();
 
      item.blendState = (uint16_t)BlendMode::None; // TransparencyState{ renderer->renderStates.noBlendStateHandle, false }; // No transparency for now.
      item.depthState = (uint16_t)DepthMode::NoWrite;//  depthStencilState;
 
      item.flags = RenderItemFlags::Custom;
      item.setCallbackData(&octData);
      item.callback = octtreeDebugRenderCallback;
    }
 
    auto & item = renderList->createCustom(&octStreamsLayout);
    item.layer = RenderLayers::Default;
    //item.bbox = Geometry::BoundingBox{ glm::vec3(-100.f), glm::vec3(100.f) }; // FIXME
 
    item.materialInstance = octData.materialInstance.resolve();
    //item.material = item.materialInstance->material;
 
    //item.transparencyState = TransparencyState{ renderer->renderStates.noBlendStateHandle, true, 0 };
    item.blendState = (uint16_t)BlendMode::None; // TransparencyState{ renderer->renderStates.noBlendStateHandle, false }; // No transparency for now.
    item.depthState = (uint16_t)DepthMode::NoWrite;//  depthStencilState;
 
    item.flags = RenderItemFlags::Custom2 | RenderItemFlags::Transparent;
    item.setCallbackData(&octData);
    item.callback2 = renderCallback;
  }
}