EditorRenderTask.cpp

#include "EditorRenderTask.h"
 
#include "Context.h"
#include "Engine.h"
#include "Editor/Editor.h"
#include "Editor.h"
 
#include "Renderer/Renderer.h"
 
#include "Resources/VertexFormats.h"
#include "Resources/DefaultMaterial.h"
 
#include "Scene/GetBounds.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Components/Core/CameraComponent.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IEffects.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/glm.hpp>
#include <array>
#include <cassert>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("EditorRenderTask");
 
  struct DebugConstants
  {
    glm::mat4 projectionMatrix;
    glm::mat4 viewMatrix;
    glm::mat4 worldMatrix;
    glm::vec4 diffuseColor;
  };
 
  static constexpr uint16_t indexesEntity[] = {
    0, 1, 0, 2, 0, 4,
    1, 3, 1, 5,
    2, 3, 2, 6,
    3, 7,
    4, 5, 4, 6,
    5, 7,
    6, 7
  };
}
 
void Cogs::Core::EditorRenderTask::init(const ViewContext* viewContext, IGraphicsDevice * device)
{
  this->viewContext = viewContext;
  Cogs::IBuffers* buffers = device->getBuffers();
 
  Cogs::EffectDescription desc{
  .name = "EditorEffect",
  .flags = viewContext->getContext()->renderer->getEffectFlags(),
  .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);
 
  static constexpr VertexElement elements[] = {
    { 0, DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 }
  };
  vertexFormat = buffers->createVertexFormat(elements, 1);
 
  constantBuffer = device->getBuffers()->loadBuffer(nullptr, sizeof(DebugConstants), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  device->getBuffers()->annotate(constantBuffer, "SelectedBounds");
}
 
Cogs::ResourceStatus Cogs::Core::EditorRenderTask::checkReady(RenderTaskContext * context)
{
  Cogs::IEffects* effects = context->device->getEffects();
  Cogs::ResourceStatus status = effects->checkEffect(effectHandle);
 
  if (status == Cogs::ResourceStatus::Ready && effectStatus != Cogs::ResourceStatus::Ready) {
    Cogs::IBuffers* buffers = context->device->getBuffers();
    inputLayoutHandle = buffers->loadInputLayout(&vertexFormat, 1, effectHandle);
  }
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "EditorRenderTask: Failed to build editor debug effect.");
  }
 
  effectStatus = status;
  return status;
}
 
void Cogs::Core::EditorRenderTask::apply(RenderTaskContext * renderContext)
{
  IEditor* editor = renderContext->context->engine->getEditor();
 
  if (!editor->isActive()) return;
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  EditorState* state = editor->getState();
  std::string erasedSelections = state->eraseInvalidSelected();
  if (!erasedSelections.empty()) {
    LOG_WARNING(logger, "Removed selection of invalid entities (Asset temp Entities?): %s", erasedSelections.data());
  }
 
  Renderer* renderer = renderContext->renderer;
  Cogs::IGraphicsDevice* device = renderer->getDevice();
  Cogs::IContext* context = device->getImmediateContext();
  const RenderStates& renderStates = renderer->getRenderStates();
 
  context->setEffect(effectHandle);
 
  context->setRasterizerState(renderStates.defaultRasterizerStateHandle);
  context->setDepthStencilState(renderStates.commonDepthStates[RenderStates::noWriteDepthStencilState]);
  context->setBlendState(renderStates.blendStates[size_t(BlendMode::None)].handle);
 
  const CameraData& cameraData = renderContext->context->cameraSystem->getMainCameraData();
 
  Cogs::IBuffers* buffers = device->getBuffers();
  context->setInputLayout(inputLayoutHandle);
 
  context->setViewport(cameraData.viewportOrigin.x, cameraData.viewportOrigin.y, cameraData.viewportSize.x, cameraData.viewportSize.y);
 
 
  // Render selected Cameras. No use rendering View Camera as bounds not visible.
  if (renderContext->context->cameraSystem->pool.size() > 1) {
    for (const CameraComponent& cameraComponent : renderContext->context->cameraSystem->pool) {
      const Entity* entity = cameraComponent.getContainer();
 
      if (cameraComponent.projectionMode != ProjectionMode::Perspective) continue;
      if (!state->isSelected(entity->getId())) continue;
      if (entity == viewContext->getCamera().get()) continue;
 
      glm::vec4 diffuseColor(0.0f, 0.8f, 0.1f, 1.0f);
      renderCamera(renderContext, cameraComponent, diffuseColor);
    }
  }
 
 
  // Draw Bounds for selected entities:
  if (!state->selected.empty()) {
 
    const std::array 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),
    };
 
    auto ib = buffers->loadIndexBuffer(indexesEntity, std::size(indexesEntity), sizeof(indexesEntity[0]));
    auto vb = buffers->loadVertexBuffer(positions.data(), positions.size(), VertexFormats::Pos3f);
 
    context->setIndexBuffer(ib, sizeof(indexesEntity[0]));
    static constexpr uint32_t strides[] = { sizeof(glm::vec3) };
    context->setVertexBuffers(&vb, 1, strides, nullptr);
 
    glm::vec4 boxColor(0.8f, 0.7f, 0.2f, 1.0f);
 
    for (EntityId id : state->selected) {
      renderEntity(renderContext, id, boxColor);
    }
 
    buffers->releaseIndexBuffer(ib);
    buffers->releaseVertexBuffer(vb);
  }
}
 
void Cogs::Core::EditorRenderTask::renderEntity(RenderTaskContext* renderContext, const EntityId id, glm::vec4 diffuseColor)
{
  Renderer* renderer = renderContext->renderer;
  Cogs::IGraphicsDevice* device = renderer->getDevice();
  Cogs::IContext* context = device->getImmediateContext();
  const CameraData& cameraData = renderContext->context->cameraSystem->getMainCameraData();
 
  Geometry::BoundingBox bounds = Bounds::getBounds(renderContext->context, id, true);
  if (bounds.empty()) {
    return;
  }
 
  glm::vec3 center = bounds.getCenter();
  glm::vec3 scale = 0.5f * bounds.getExtent();
 
  glm::mat4 world = glm::translate(glm::mat4(1.0f), center) * glm::scale(glm::mat4(1.0f), scale);
 
  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, std::size(indexesEntity));
}
 
void Cogs::Core::EditorRenderTask::renderCamera(RenderTaskContext* renderContext, const CameraComponent& cameraComponent, glm::vec4 diffuseColor)
{
  Renderer* renderer = renderContext->renderer;
  Cogs::IGraphicsDevice* device = renderer->getDevice();
  Cogs::IContext* context = device->getImmediateContext();
  Cogs::IBuffers* buffers = device->getBuffers();
  const CameraData& cameraData = renderContext->context->cameraSystem->getMainCameraData();
 
  const std::array<glm::vec4, 8U> positionsClip = {
    glm::vec4(-1, -1, 0, 1),
    glm::vec4(1, -1, 0, 1),
    glm::vec4(1, 1, 0, 1),
    glm::vec4(-1, 1, 0, 1),
 
    glm::vec4(-1, -1, 1, 1),
    glm::vec4(1, -1, 1, 1),
    glm::vec4(1, 1, 1, 1),
    glm::vec4(-1, 1, 1, 1),
  };
 
  std::array<glm::vec3, positionsClip.size()> positionsWS;
  const CameraData& cData = renderContext->context->cameraSystem->getData(&cameraComponent);
 
  for (size_t i = 0; i < positionsWS.size(); ++i) {
    glm::vec4 posWS = cData.inverseViewProjectionMatrix * positionsClip[i];
    posWS /= posWS.w;
 
    positionsWS[i] = glm::vec3(posWS);
  }
 
  static constexpr uint16_t indexesCamera[] = {
    0, 1, 1, 2, 2, 3, 3, 0,
    4, 5, 5, 6, 6, 7, 7, 4,
    0, 4, 1, 5, 2, 6, 3, 7
  };
 
  auto ib = buffers->loadIndexBuffer(indexesCamera, std::size(indexesCamera), sizeof(indexesCamera[0]));
  auto vb = buffers->loadVertexBuffer(positionsWS.data(), positionsWS.size(), VertexFormats::Pos3f);
 
  context->setIndexBuffer(ib, sizeof(indexesCamera[0]));
  static constexpr uint32_t strides[] = { sizeof(glm::vec3) };
  context->setVertexBuffers(&vb, 1, strides, nullptr);
 
  const glm::mat4 world = glm::mat4(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;
      }
      else {
        LOG_ERROR_ONCE(logger, "MappedBuffer<DebugConstants> for Camera fail");
      }
    }
    context->setConstantBuffer("DebugBuffer", constantBuffer);
  }
  else {
    assert(false);
  }
 
  context->drawIndexed(PrimitiveType::LineList, 0, std::size(indexesCamera));
 
  buffers->releaseIndexBuffer(ib);
  buffers->releaseVertexBuffer(vb);
}