BoundsRenderer.cpp

#include "BoundsRenderer.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
 
#include "Context.h"
 
#include "Renderer/IRenderer.h"
 
#include "Resources/VertexFormats.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/Mesh.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Scene/GetBounds.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/matrix_transform.hpp>
 
using namespace Cogs::Geometry;
 
namespace{
  struct DebugConstants
  {
    glm::mat4 projectionMatrix;
    glm::mat4 viewMatrix;
    glm::mat4 worldMatrix;
    glm::vec4 diffuseColor;
  };
 
  const uint16_t indexes[] = {
    0, 1, 0, 2, 0, 4,
    1, 3, 1, 5,
    2, 3, 2, 6,
    3, 7,
    4, 5, 4, 6,
    5, 7,
    6, 7
  };
 
  const glm::vec3 positions[] = {
    glm::vec3(-1, -1, -1),
    glm::vec3(1, -1, -1),
    glm::vec3(-1, 1, -1),
    glm::vec3(1, 1, -1),
 
    glm::vec3(-1, -1, 1),
    glm::vec3(1, -1, 1),
    glm::vec3(-1, 1, 1),
    glm::vec3(1, 1, 1),
  };
}
 
void Cogs::Core::BoundsRenderer::initialize(class IRenderer* renderer, IGraphicsDevice * device)
{
  auto buffers = device->getBuffers();
 
  Cogs::EffectDescription desc = {};
  desc.name = "DebugEffect";
  desc.flags = renderer->getEffectFlags();
  desc.type = EffectDescriptionType::File;
  switch (device->getType()) {
  case Cogs::GraphicsDeviceType::WebGPU:
    desc.vertexShader = "Engine/DebugVS.wgsl";
    desc.pixelShader = "Engine/DebugPS.wgsl";
    desc.vsEntryPoint = "vs_main";
    desc.psEntryPoint = "fs_main";
    desc.flags = static_cast<EffectFlags::EEffectFlags>(desc.flags | EffectFlags::WGSL);
    break;
  case Cogs::GraphicsDeviceType::OpenGLES30:
    desc.vertexShader = "Engine/DebugVS.es30.glsl";
    desc.pixelShader = "Engine/DebugPS.es30.glsl";
    desc.flags = static_cast<EffectFlags::EEffectFlags>(desc.flags | EffectFlags::GLSL);
    break;
  default:
    desc.vertexShader = "Engine/DebugVS.hlsl";
    desc.pixelShader = "Engine/DebugPS.hlsl";
    break;
  }
  effectHandle = device->getEffects()->loadEffect(desc);
 
  VertexElement elements[] = {
    { 0, DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 }
  };
  auto vertexFormat = buffers->createVertexFormat(elements, 1);
  inputLayoutHandle = buffers->loadInputLayout(&vertexFormat, 1, effectHandle);
 
  constantBuffer = device->getBuffers()->loadBuffer(nullptr, sizeof(DebugConstants), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  device->getBuffers()->annotate(constantBuffer, "BoundsConstants");
}
void Cogs::Core::BoundsRenderer::renderBounds(class IRenderer * renderer, class Context* mainContext, const RenderList & renderList)
{
  auto device = renderer->getDevice();
  auto context = device->getImmediateContext();
  auto & renderStates = renderer->getRenderStates();
 
  context->setEffect(effectHandle);
 
  context->setRasterizerState(renderStates.defaultRasterizerStateHandle);
  context->setDepthStencilState(renderStates.noWriteDepthStencilStateHandle);
  context->setBlendState(renderStates.blendStates[size_t(BlendMode::None)].handle);
 
  auto ib = device->getBuffers()->loadIndexBuffer(indexes, sizeof(indexes) / sizeof(uint16_t), sizeof(uint16_t));
  auto vb = device->getBuffers()->loadVertexBuffer(positions, sizeof(positions) / sizeof(glm::vec3), VertexFormats::Pos3f);
 
  context->setInputLayout(inputLayoutHandle);
  context->setIndexBuffer(ib, 2);
  uint32_t strides[] = { sizeof(glm::vec3) };
  context->setVertexBuffers(&vb, 1, strides, nullptr);
 
  auto & cameraData = mainContext->cameraSystem->getMainCameraData();
 
  for (auto & renderItem : renderList) {
    if (renderItem.layer == RenderLayers::Sky) continue;
    if (renderItem.isSprite()) continue;
 
    Geometry::BoundingBox bbox;
 
    if (renderItem.hasBoundingBox()) {
      bbox = *renderItem.boundingBox;
    } else {
      if (renderItem.cullingIndex == static_cast<uint32_t>(-1)) continue;
 
      assert(renderItem.cullingIndex < cameraData.cullingData->source->bbMinWorld.size() && "Bounds index out of range.");
      bbox = {
        cameraData.cullingData->source->bbMinWorld[renderItem.cullingIndex],
        cameraData.cullingData->source->bbMaxWorld[renderItem.cullingIndex]
      };
    }
 
    auto center = (bbox.max + bbox.min) * 0.5f;
    auto scale = 0.5f * glm::vec3(
      bbox.max.x - bbox.min.x,
      bbox.max.y - bbox.min.y,
      bbox.max.z - bbox.min.z);
 
    glm::mat4 world = glm::translate(glm::mat4(1.0f), center) * glm::scale(glm::mat4(1.0f), scale);
    glm::vec4 diffuseColor = glm::vec4(0.4f, 1.0f, 0.2f, 1.0f);
    if (renderItem.materialInstance->isDefaultMaterial()) {
      diffuseColor = renderItem.materialInstance->getVec4Property(DefaultMaterial::DiffuseColor);
      diffuseColor.a = 1.0f;
    }
 
    if (HandleIsValid(constantBuffer)) {
      {
        MappedBuffer<DebugConstants> constants(context, constantBuffer, MapMode::WriteDiscard);
 
        if (constants) {
          constants->projectionMatrix = cameraData.projectionMatrix;
          constants->viewMatrix = cameraData.viewMatrix;
          constants->worldMatrix = world;
          constants->diffuseColor = diffuseColor;
        }
      }
      context->setConstantBuffer("DebugBuffer", constantBuffer);
    }
    else{
      assert(false);
    }
 
    context->drawIndexed(PrimitiveType::LineList, 0, glm::countof(indexes));
 
    if (renderItem.isInstanced() && renderItem.numInstances < 10000) {
      auto instanceMesh = renderItem.instanceData;
      const auto & instanceBounds = renderItem.meshData->getMesh()->boundingBox;
 
      //TODO/FIXME: Use stream slots to help figure out which data may be position/color data.
      auto[pPos, pCount, pStride] = instanceMesh->getMesh()->getSemanticStream(ElementSemantic::InstanceVector, DataFormat::X32Y32Z32_FLOAT);
      auto[cColor, cCount, cStride] = instanceMesh->getMesh()->getSemanticStream(ElementSemantic::InstanceVector, DataFormat::X32Y32Z32W32_FLOAT);
 
      if (!isEmpty(instanceBounds) && pPos && pCount >= renderItem.numInstances) {
        auto instanceCenter = (instanceBounds.min + instanceBounds.max) * 0.5f;
        auto instanceScale = 0.5f * glm::vec3(
          instanceBounds.max.x - instanceBounds.min.x,
          instanceBounds.max.y - instanceBounds.min.y,
          instanceBounds.max.z - instanceBounds.min.z);
 
        const auto worldMatrix = renderItem.worldMatrix ? *renderItem.worldMatrix : glm::mat4(1.0f);
 
        for (size_t i = 0; i < renderItem.numInstances; ++i) {
          const glm::vec3 & instancePosition = *reinterpret_cast<const glm::vec3 *>(pPos + pStride * (renderItem.startInstance + i));
          const glm::mat4 instanceTransform = worldMatrix * glm::translate(glm::mat4(1.0f), instanceCenter + instancePosition) * glm::scale(glm::mat4(1.0f), instanceScale);
 
          glm::vec4 col;
          if (cColor && cCount >= renderItem.numInstances) {
            const float *color = reinterpret_cast<const float *>(cColor + cStride * i);
            col = glm::vec4(color[0], color[1], color[2], color[3]);
          } else {
            col = diffuseColor;
          }
 
          if (HandleIsValid(constantBuffer)) {
            {
              MappedBuffer<DebugConstants> constants(context, constantBuffer, MapMode::WriteDiscard);
 
              if (constants) {
                constants->projectionMatrix = cameraData.projectionMatrix;
                constants->viewMatrix = cameraData.viewMatrix;
                constants->worldMatrix = instanceTransform;
                constants->diffuseColor = col;
              }
            }
            context->setConstantBuffer("DebugBuffer", constantBuffer);
          }
          else{
            assert(false);
          }
 
          context->drawIndexed(PrimitiveType::LineList, 0, glm::countof(indexes));
        }
      }
    }
  }
 
  device->getBuffers()->releaseIndexBuffer(ib);
  device->getBuffers()->releaseVertexBuffer(vb);
}