HighlightRegionRenderer.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IRenderTargets.h"
 
#include "Components/Core/ClipShapeComponent.h"
 
#include "Resources/MaterialInstance.h"
 
#include "Systems/Core/CameraSystem.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/Tasks/RenderTask.h"
#include "Renderer/Tasks/FilterListTask.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderStateUpdater.h"
 
#include "HighlightRegionSystem.h"
#include "HighlightRegionRenderer.h"
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("HighlightRegion");
 
  struct Matrices {
    glm::mat4 clipFromLocal;
    glm::mat4 localFromClip;
    glm::vec4 eye;
    glm::vec4 nearPlaneLocal;
    glm::vec4 viewPlaneLocal;
  };
 
  void setTexture(Cogs::IContext* deviceContext, RenderMaterialInstance* renderMaterialInstance, const EffectBinding* binding, RenderTexture* texture, VariableKey key)
  {
    if (key == NoProperty) return;
 
    const Cogs::TextureBindingHandle& texBinding = binding->textureBindings[key];
    if (texture && HandleIsValid(texture->textureHandle)) {
      deviceContext->setTexture(texBinding, texture->textureHandle);
    }
    else {
      deviceContext->setTexture(texBinding, Cogs::TextureHandle::NoHandle);
    }
 
    const Cogs::SamplerStateBindingHandle& samplerBinding = binding->samplerBindings[key];
    if (HandleIsValid(renderMaterialInstance->samplerStates[key])) {
      deviceContext->setSamplerState(samplerBinding, renderMaterialInstance->samplerStates[key]);
    }
    else {
      deviceContext->setSamplerState(samplerBinding, Cogs::SamplerStateHandle::NoHandle);
    }
  }
 
}
 
namespace {
 
  uint32_t packSplitVertex4(size_t a, size_t b, size_t c, size_t d)
  {
    return static_cast<uint32_t>(((d) << 9) | ((c ) << 6) | ((b ) << 3) | ((a ) << 0));
  }
 
  uint32_t packSplitVertex2(size_t a, size_t b)
  {
    return packSplitVertex4(a, a, b, b);
  }
 
  uint32_t packSplitVertex1(size_t a)
  {
    return packSplitVertex4(a, a, a, a);
  }
 
}
 
void Cogs::Core::HighlightRegionRenderer::initialize(Context* /*context*/, IGraphicsDevice* device)
{
  if (device->getType() != Cogs::GraphicsDeviceType::OpenGLES30) {
    LOG_WARNING_ONCE(logger, "HighlightRegionRenderer only supports OpenGLES30 currently");
    return;
  }
 
  Cogs::VertexElement vertexElements[1] =  {
    Cogs::VertexElement{0, Cogs::DataFormat::R32G32B32_FLOAT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
  };
  VertexFormatHandle vertexFormatHandle = VertexFormats::createVertexFormat(vertexElements, std::size(vertexElements));
 
  Cogs::VertexElement splitCubeVertexElements[1] =  {
    Cogs::VertexElement{0, Cogs::DataFormat::R32_UINT, Cogs::ElementSemantic::Position, 0, Cogs::InputType::VertexData, 0}
  };
  VertexFormatHandle splitCubeVertexFormatHandle = VertexFormats::createVertexFormat(splitCubeVertexElements, std::size(splitCubeVertexElements));
 
  Cogs::VertexElement instanceElements[2] = {
    Cogs::VertexElement { 0 * sizeof(glm::mat4), Cogs::DataFormat::MAT4X4_FLOAT, Cogs::ElementSemantic::InstanceMatrix, 0, Cogs::InputType::InstanceData, 1 },
    Cogs::VertexElement { 1 * sizeof(glm::mat4), Cogs::DataFormat::MAT4X4_FLOAT, Cogs::ElementSemantic::InstanceMatrix, 1, Cogs::InputType::InstanceData, 1 }
  };
 
  VertexFormatHandle instanceFormatHandle = VertexFormats::createVertexFormat(instanceElements, std::size(instanceElements));
  assert(Cogs::getSize(instanceFormatHandle) == sizeof(HighlightRegionInstanceData));
 
  solidStreamsLayout.vertexFormats[0] = vertexFormatHandle;
  solidStreamsLayout.vertexFormats[1] = instanceFormatHandle;
  solidStreamsLayout.numStreams = 2;
  solidStreamsLayout.updateHash();
 
  splitCubeStreamsLayout.vertexFormats[0] = splitCubeVertexFormatHandle;
  splitCubeStreamsLayout.vertexFormats[1] = instanceFormatHandle;
  splitCubeStreamsLayout.numStreams = 2;
  splitCubeStreamsLayout.updateHash();
 
  Cogs::IBuffers* buffers = device->getBuffers();
 
  {
    static const float cubeVertexData[8][3] = {
      { -1, -1, -1 },
      {  1, -1, -1 },
      { -1,  1, -1 },
      {  1,  1, -1 },
      { -1, -1,  1 },
      {  1, -1,  1 },
      { -1,  1,  1 },
      {  1,  1,  1 },
    };
    static_assert(std::size(cubeVertexData) == 8);
    cubeVertices = buffers->loadVertexBuffer(cubeVertexData, std::size(cubeVertexData), solidStreamsLayout.vertexFormats[0]);
 
    static const uint16_t cubeTriIndicesData[] = {
      0, 3, 1, 0, 2, 3,
      0, 1, 5, 0, 5, 4,
      1, 3, 7, 7, 5, 1,
      4, 6, 2, 4, 2, 0,
      2, 7, 3, 7, 2, 6,
      4, 7, 6, 4, 5, 7
    };
    cubeTriIndicesCount = static_cast<uint32_t>(std::size(cubeTriIndicesData));
    cubeTriIndices = buffers->loadIndexBuffer(cubeTriIndicesData, cubeTriIndicesCount, sizeof(cubeTriIndicesData[0]));
  }
 
  {
    static const uint32_t splitCubeVertexData[26] = {
      packSplitVertex1(0),           // glm::vec3( -1, -1, -1 ),
      packSplitVertex2(0, 1),        // glm::vec3(  0, -1, -1 ),
      packSplitVertex1(1),           // glm::vec3(  1, -1, -1 ),
      packSplitVertex2(0, 2),        // glm::vec3( -1,  0, -1 ),
      packSplitVertex4(0, 2, 3, 1),  // glm::vec3(  0,  0, -1 ),
      packSplitVertex2(1, 3),        // glm::vec3(  1,  0, -1 ),
      packSplitVertex1(2),           // glm::vec3( -1,  1, -1 ),
      packSplitVertex2(2, 3),        // glm::vec3(  0,  1, -1 ),
      packSplitVertex1(3),           // glm::vec3(  1,  1, -1 ),
 
      packSplitVertex2(0, 4),        // glm::vec3( -1, -1,  0 ),
      packSplitVertex4(0, 1, 5, 4),  // glm::vec3(  0, -1,  0 ),
      packSplitVertex2(1, 5),        // glm::vec3(  1, -1,  0 ),
      packSplitVertex4(0, 4, 6, 2),  // glm::vec3( -1,  0,  0 ),
      packSplitVertex4(1, 3, 7, 5),  // glm::vec3(  1,  0,  0 ),
      packSplitVertex2(2, 6),        // glm::vec3( -1,  1,  0 ),
      packSplitVertex4(2, 6, 7, 3),  // glm::vec3(  0,  1,  0 ),
      packSplitVertex2(3, 7),        // glm::vec3(  1,  1,  0 ),
 
      packSplitVertex1(4),           // glm::vec3( -1, -1,  1 ),
      packSplitVertex2(4, 5),        // glm::vec3(  0, -1,  1 ),
      packSplitVertex1(5),           // glm::vec3(  1, -1,  1 ),
      packSplitVertex2(4, 6),        // glm::vec3( -1,  0,  1 ),
      packSplitVertex4(4, 5, 7, 6),  // glm::vec3(  0,  0,  1 ),
      packSplitVertex2(5, 7),        // glm::vec3(  1,  0,  1 ),
      packSplitVertex1(6),           // glm::vec3( -1,  1,  1 ),
      packSplitVertex2(6, 7),        // glm::vec3(  0,  1,  1 ),
      packSplitVertex1(7)            // glm::vec3(  1,  1,  1 ),
    };
    splitCubeVertices = buffers->loadVertexBuffer(splitCubeVertexData, std::size(splitCubeVertexData), splitCubeStreamsLayout.vertexFormats[0]);
 
    static const uint16_t splitCubeTriIndicesData[] = {
       3,  1,  0,  4,  1,  3,
       7,  3,  6,  4,  3,  7,
       5,  7,  8,  4,  7,  5,
       1,  5,  2,  4,  5,  1,
 
      18, 20, 17, 21, 20, 18,
      20, 24, 23, 21, 24, 20,
      24, 22, 25, 21, 22, 24,
      22, 18, 19, 21, 18, 22,
 
       9,  3,  0, 12,  3,  9,
       3, 14,  6, 12, 14,  3,
      14, 20, 23, 12, 20, 14,
      20,  9, 17, 12,  9, 20,
 
       5, 11,  2, 13, 11,  5,
      16,  5,  8, 13,  5, 16,
      22, 16, 25, 13, 16, 22,
      11, 22, 19, 13, 22, 11,
 
      14,  7,  6, 15,  7, 14,
       7, 16,  8, 15, 16,  7,
      16, 24, 25, 15, 24, 16,
      24, 14, 23, 15, 14, 24,
 
       1,  9,  0, 10,  9,  1,
      11,  1,  2, 10,  1, 11,
      18, 11, 19, 10, 11, 18,
       9, 18, 17, 10, 18,  9
    };
    splitCubeTriIndicesCount = static_cast<uint32_t>(std::size(splitCubeTriIndicesData));
    splitCubeTriIndices = buffers->loadIndexBuffer(splitCubeTriIndicesData, splitCubeTriIndicesCount, sizeof(splitCubeTriIndicesData[0]));
  }
 
  // We have our own version of this depthStencilHandle since we need the
  // OrEqual-test in additon to Less/Greater: When depth is clamped behind the
  // near-plane, both the "normal" geometry and the highlight-region-pass gets
  // the same value and without OrEqual, highlight-region would loose the tie.
  // We would like it to win.
  Cogs::IRenderTargets* renderTargets = device->getRenderTargets();
  DepthStencilState depthState = { true, false, DepthStencilState::LessOrEqual };
  noWriteDepthStencilState = renderTargets->loadDepthStencilState(depthState);
 
  // Whether or not reverse depth should be used is not known this early, so we
  // cover both cases and choose at render time,
  depthState.depthFunction = DepthStencilState::GreaterOrEqual;
  noWriteDepthStencilStateReverse = renderTargets->loadDepthStencilState(depthState);
}
 
void Cogs::Core::HighlightRegionRenderer::handleEvent(uint32_t eventId, const DrawContext* renderingContext)
{
  Cogs::IGraphicsDevice* device = renderingContext->device;
  if (device->getType() != Cogs::GraphicsDeviceType::OpenGLES30) return;
 
  if (matrices.index == NoProperty && hrSystem->material && hrSystem->material->isActive()) {
    for (const MaterialPropertyBuffer& buffer: hrSystem->material->constantBuffers.buffers) {
      if (buffer.name == "Matrices" && sizeof(Matrices) <= buffer.size) {
        LOG_DEBUG(logger, "Found Matrices buffer: %u (size=%zu)", buffer.index, buffer.size);
        matrices.index = buffer.index;
        matrices.buffer = device->getBuffers()->loadBuffer(nullptr, buffer.size, Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer);
      }
    }
  }
 
 
  Cogs::IBuffers* buffers = device->getBuffers();
  RenderResources& renderResources = renderingContext->renderer->getRenderResources();
  switch (eventId) {
  case RenderingEvent::PreRender:
    // Do non-view/pass specific init at pre-render time
    for (const HighlightRegionComponent& regionComp : hrSystem->pool) {
      HighlightRegionData& data = hrSystem->getData(&regionComp);
      if (data.materialInstance && data.materialInstance->isActive()) {
        data.renderMaterialInstance = renderResources.getRenderMaterialInstance(data.materialInstance);
      }
 
      if (!regionComp.isVisible()) {
        if (HandleIsValid(data.instanceDataHandle)) {
          buffers->releaseVertexBuffer(data.instanceDataHandle);
          data.instanceDataHandle = Cogs::BufferHandle::NoHandle;
          data.instanceDataUpdated = true;
        }
      }
      else {
        if (data.instanceDataUpdated) {
          data.instanceDataUpdated = false;
          if (HandleIsValid(data.instanceDataHandle)) {
            buffers->releaseVertexBuffer(data.instanceDataHandle);
            data.instanceDataHandle = Cogs::BufferHandle::NoHandle;
          }
          if (!data.instanceData.empty()) {
            data.instanceDataHandle = buffers->loadVertexBuffer(data.instanceData.data(), data.instanceData.size(), solidStreamsLayout.vertexFormats[1]);
          }
        }
      }
    }
    break;
  default:
    break;
  }
}
 
void Cogs::Core::HighlightRegionRenderer::generateCommands(const RenderTaskContext* /*renderingContext*/, RenderList* /*renderList*/)
{
}
 
 
void Cogs::Core::HighlightRegionRenderer::render(RenderTaskContext* renderTaskContext, RenderTarget* renderTarget, RenderList* renderList, RenderTexture* color, RenderTexture* depth)
{
  if (renderTaskContext->device->getType() != Cogs::GraphicsDeviceType::OpenGLES30) return;
 
  const CameraData* camData = renderList->viewportData;
  if (!camData) return;
 
  size_t permutationIndex = 0;
  EnginePermutation* permutation = renderTaskContext->renderer->getEnginePermutations().get(permutationIndex);
  if (!permutation) return;
 
  DrawContext drawContext;
  drawContext.context = renderTaskContext->context;
  drawContext.renderer = renderTaskContext->renderer;
  drawContext.device = drawContext.renderer->getDevice();
  drawContext.deviceContext = drawContext.device->getImmediateContext();
  drawContext.cameraData = renderList->viewportData;
  drawContext.permutation = permutation;
  drawContext.engineBuffers = &drawContext.renderer->getEngineBuffers();
  drawContext.taskContext = renderTaskContext;
  drawContext.renderTarget = renderTarget;
 
  if (drawContext.permutation == nullptr) return;
 
  IContext* deviceContext = drawContext.deviceContext;
  bool reverseDepth = drawContext.taskContext->states->reverseDepth;
 
  drawContext.renderer->updatePermutation(drawContext.permutation);
 
  deviceContext->setBlendState(renderTaskContext->states->blendStates[size_t(BlendMode::None)].handle);
 
 
  deviceContext->setRenderTarget(renderTarget->renderTargetHandle, renderTarget->depthTargetHandle);
 
//  if (drawContext.task->viewportFromTarget && drawContext.renderTarget) {
  if (true) {
    deviceContext->setViewport(0.f, 0.f, float(drawContext.renderTarget->width), float(drawContext.renderTarget->height));
  }
  else {
    deviceContext->setViewport(camData->viewportOrigin.x, camData->viewportOrigin.y, camData->viewportSize.x, camData->viewportSize.y);
  }
 
//  deviceContext->setViewport(camData->viewportOrigin.x, camData->viewportOrigin.y, camData->viewportSize.x, camData->viewportSize.y);
  updateViewportBuffer(renderTaskContext, renderTaskContext->engineBuffers->sceneBufferHandle, renderTaskContext->engineBuffers->viewBufferHandle, renderTarget, camData, nullptr);
 
  deviceContext->setDepthStencilState(renderTaskContext->context->renderer->getRenderStates().reverseDepth
                                      ? noWriteDepthStencilStateReverse
                                      : noWriteDepthStencilState); 
  for (const HighlightRegionComponent& regionComp : hrSystem->pool) {
    HighlightRegionData& data = hrSystem->getData(&regionComp);
    if (!HandleIsValid(data.instanceDataHandle) || !data.renderMaterialInstance) continue;
 
    MaterialInstance* materialInstance = data.renderMaterialInstance->getResource();
    assert(materialInstance);
 
    VariableKey colorKey = NoProperty;
    VariableKey depthKey = NoProperty;
    for (const TextureValue& texProp : materialInstance->textureVariables) {
      switch (Cogs::hash(texProp.property->name)) {
      case Cogs::hash("offscreenColor"):
        colorKey = texProp.key;
        break;
      case Cogs::hash("offscreenDepth"):
        depthKey = texProp.key;
        break;
      default:
        break;
      }
    }
 
    RenderPassOptions passOptions = initRenderPassOptions(*camData, materialInstance);
    passOptions.depthBias = reverseDepth ? regionComp.depthConstantBias : -regionComp.depthConstantBias;
    passOptions.depthSlopedBias = reverseDepth ? regionComp.depthSlopedFactor : -regionComp.depthSlopedFactor;
    passOptions.setFlag(RenderPassOptions::Flags::NoDepthClip);
    passOptions.updateHash();
 
    uint16_t rasterizerState = drawContext.renderer->getRenderStates().getRasterizerState(passOptions, Cogs::RasterizerState::Back, false, true);
    deviceContext->setRasterizerState(drawContext.taskContext->states->rasterizerStateHandles[rasterizerState]);
 
    const ClipShapeType clipShape = ClipShapeType::None;
 
    const EffectBinding* effectBinding = nullptr;
    if (data.debugForceNoSplit) {
      effectBinding = data.renderMaterialInstance->checkReady(solidStreamsLayout, drawContext.permutation, passOptions, clipShape);
    }
    else {
      effectBinding = data.renderMaterialInstance->checkReady(splitCubeStreamsLayout, drawContext.permutation, passOptions, clipShape);
    }
    if (!effectBinding) continue;
 
    drawContext.renderer->updatePermutation(permutation);
    for (const MaterialPropertyBuffer& buffer : permutation->constantBuffers.buffers) {
      permutation->bufferHandles.resize(permutation->constantBuffers.buffers.size());
      if (!HandleIsValid(permutation->bufferHandles[buffer.index])) {
        Cogs::IBuffers* buffers = drawContext.device->getBuffers();
        permutation->bufferHandles[buffer.index] = buffers->loadBuffer(nullptr, buffer.size, Cogs::Usage::Dynamic, Cogs::AccessMode::Write, Cogs::BindFlags::ConstantBuffer);
      }
      deviceContext->updateBuffer(permutation->bufferHandles[buffer.index], buffer.content.data(), buffer.size);
      deviceContext->setConstantBuffer(buffer.name, permutation->bufferHandles[buffer.index]);
 
    }
    applyMaterialPermutation(drawContext.taskContext, &drawContext, effectBinding, data.renderMaterialInstance);
    applyMaterialInstance(&drawContext, effectBinding, data.renderMaterialInstance);
    updateEnvironmentBindings(&drawContext, effectBinding);
    updateSceneBindings(drawContext.taskContext, effectBinding);
    updateMaterialBindings(&drawContext, data.renderMaterialInstance, effectBinding, true);
 
    setTexture(deviceContext, data.renderMaterialInstance, effectBinding, color, colorKey);
    setTexture(deviceContext, data.renderMaterialInstance, effectBinding, depth, depthKey);
 
    if (HandleIsValid(matrices.buffer) && matrices.index < effectBinding->buffers.size()) {
      if (const Cogs::ConstantBufferBindingHandle& bufferBinding = effectBinding->bufferBindings[matrices.index]; HandleIsValid(bufferBinding)) {
 
        glm::dmat4 inverseView = camData->inverseViewMatrix;
        glm::dmat4 viewMatrix = glm::inverse(inverseView);
        glm::dmat4 viewFromLocal = viewMatrix * glm::dmat4(data.worldMatrix);
        glm::dmat4 clipFromLocal = glm::dmat4(camData->projectionMatrix) * viewFromLocal;
        glm::dmat4 localFromClip = glm::inverse(clipFromLocal);
        
        if (Cogs::MappedBuffer<Matrices> matricesBuffer(deviceContext, matrices.buffer, Cogs::MapMode::WriteDiscard); matricesBuffer) {
          matricesBuffer->clipFromLocal = clipFromLocal;
          matricesBuffer->localFromClip = localFromClip;
          matricesBuffer->eye = glm::inverse(viewFromLocal) * glm::vec4(0,0,0,1);
          matricesBuffer->nearPlaneLocal = glm::vec4(0, 0, -1, -camData->nearDistance) * viewFromLocal;
          matricesBuffer->viewPlaneLocal = glm::vec4(0, 0, -1, 0) * viewFromLocal;
        }
        deviceContext->setConstantBuffer(bufferBinding, matrices.buffer);
      }
    }
 
    if  (data.debugForceNoSplit) {
      Cogs::VertexBufferHandle vertexBuffers[2] = {
        cubeVertices,
        data.instanceDataHandle
      };
      deviceContext->setVertexBuffers(vertexBuffers, std::size(vertexBuffers));
      deviceContext->setIndexBuffer(cubeTriIndices, 2, 0);
      deviceContext->drawInstancedIndexed(Cogs::PrimitiveType::TriangleList, 0, data.instanceData.size(), 0, cubeTriIndicesCount);
    }
    else {
      Cogs::VertexBufferHandle vertexBuffers[2] = {
        splitCubeVertices,
        data.instanceDataHandle
      };
      deviceContext->setVertexBuffers(vertexBuffers, std::size(vertexBuffers));
      deviceContext->setIndexBuffer(splitCubeTriIndices, 2, 0);
      deviceContext->drawInstancedIndexed(Cogs::PrimitiveType::TriangleList, 0, data.instanceData.size(), 0, splitCubeTriIndicesCount);
    }
  }
}