Renderer.cpp

#include "Renderer.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "MemoryContext.h"
#include "Types.h"
 
#include "RenderPipelineManager.h"
#include "RenderStateUpdater.h"
#include "RenderTarget.h"
 
#include "CustomRenderer/BoundsRenderer.h"
#include "CustomRenderer/DebugGeometryRenderers.h"
 
#include "Rendering/Factory.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
#include "Rendering/IRenderTargets.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/Texture.h"
#include "Services/Variables.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
#include "Systems/Core/LightSystem.h"
#include "Utilities/Parsing.h"
 
#include "InspectorGui/InspectorGuiRenderer.h"
 
#include <glm/gtc/color_space.hpp>
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Renderer");
 
  void addLights(std::vector<const LightComponent*>& dst, size_t& freeSlots, uint32_t& srcCount, const std::vector<const LightComponent*>& src)
  {
    srcCount = static_cast<uint32_t>(std::min(freeSlots, src.size()));
    freeSlots -= srcCount;
 
    for (size_t i = 0; i < srcCount; i++) {
      dst.push_back(src[i]);
    }
  }
 
  void buildSortedListOfActiveLights(Context* context, ActiveLights& activeLights, const size_t maxLights)
  {
    LightSystem& lightSystem = *context->lightSystem;
 
    // Bucket sort active lights
    std::vector<const LightComponent*> directionalShadowLights;
    std::vector<const LightComponent*> pointShadowLights;
    std::vector<const LightComponent*> directionalLights;
    std::vector<const LightComponent*> pointLights;
    const bool shadowsEnabled = context->variables->get("renderer.shadowsEnabled", false);
    for (const LightComponent& light : lightSystem.pool) {
 
      if (!light.enabled) continue;
 
      if (shadowsEnabled && light.castShadows) {
        if (light.lightType == LightType::Directional) {
          directionalShadowLights.push_back(&light);
        }
        else if (light.lightType == LightType::Point) {
          pointShadowLights.push_back(&light);
        }
      }
      else {
        if (light.lightType == LightType::Directional) {
          directionalLights.push_back(&light);
        }
        else if (light.lightType == LightType::Point) {
          pointLights.push_back(&light);
        }
      }
    }
 
    size_t numLightsTotal = directionalShadowLights.size() + directionalLights.size() + pointShadowLights.size() + pointLights.size();
    if (maxLights < numLightsTotal) {
      LOG_WARNING_ONCE(logger, "More active lights (=%zu) than supported (=%zu)", numLightsTotal, maxLights);
    }
 
    activeLights.lights.clear();
    size_t freeLightSlots = maxLights;
    addLights(activeLights.lights, freeLightSlots, activeLights.numDirectionalShadowLights, directionalShadowLights);
    addLights(activeLights.lights, freeLightSlots, activeLights.numDirectionalLights, directionalLights);
    addLights(activeLights.lights, freeLightSlots, activeLights.numPointShadowLights, pointShadowLights);
    addLights(activeLights.lights, freeLightSlots, activeLights.numPointLights, pointLights);
 
    assert(activeLights.lights.size() <= maxLights);
  }
 
}
 
namespace Cogs
{
  namespace Core
  {
    struct Renderers
    {
      BoundsRenderer        boundsRenderer;
      DebugGeometryRenderer debugGeometryRenderer;
      ImguiRenderer         imguiRenderer;
      InspectorGuiRenderer  engineInspectorGuiRenderer;
    };
 
    // Setup default render context content.
    RenderTaskContext getRenderTaskContext(Renderer * renderer)
    {
      RenderTaskContext renderContext = {};
 
      renderContext.context = renderer->context;
      renderContext.renderer = renderer;
      renderContext.device = renderer->device;
      renderContext.resources = &renderer->resources;
      renderContext.states = &renderer->renderStates;
      renderContext.engineBuffers = &renderer->engineBuffers;
      renderContext.defaultRenderTarget = renderer->defaultTarget;
 
      return renderContext;
    }
 
    DrawContext getDrawContext(RenderTaskContext * renderContext)
    {
      DrawContext drawContext = {};
 
      drawContext.context = renderContext->context;
      drawContext.renderer = renderContext->renderer;
      drawContext.device = renderContext->device;
      drawContext.deviceContext = renderContext->device->getImmediateContext();
      drawContext.cameraData = renderContext->cameraData;
      drawContext.renderTarget = renderContext->defaultRenderTarget;
      drawContext.engineBuffers = renderContext->engineBuffers;
      drawContext.taskContext = renderContext;
      drawContext.permutationIndex = 0;
 
      return drawContext;
    }
  }
}
 
Cogs::Core::Renderer::Renderer(Context * context) :
  context(context),
  resources(context),
  enginePermutations(context),
  effectBindings(context->memory.get()),
  renderers(std::make_unique<Renderers>()),
  pipelineManager(std::make_unique<RenderPipelineManager>())
{
  updateEffectFlags();
}
 
Cogs::Core::Renderer::~Renderer()
{
}
 
void Cogs::Core::Renderer::initialize(IGraphicsDevice * device)
{
  if (!device) {
    LOG_FATAL(logger, "Cannot initialize renderer with nullptr device.");
    return;
  }
 
  Instrumentation::initializeGpu(context);
  Instrumentation::beginGpuThread(device->getImmediateContext());
 
  this->device = device;
 
  auto backColor = context->variables->get("renderer.backgroundColor", glm::vec4(0.5, 0.5, 0.5, 1));
  setBackgroundColor(backColor);
 
  {
    const GraphicsDeviceCapabilities& device_capabilities = device->getCapabilities()->getDeviceCapabilities();
 
    context->variables->set("renderer.DedicatedVideoMemoryMB", (int)(device_capabilities.DedicatedVideoMemory/(1024*1024)));
    context->variables->set("renderer.DedicatedSystemMemoryMB", (int)(device_capabilities.DedicatedSystemMemory/(1024*1024)));
    context->variables->set("renderer.SharedSystemMemoryMB", (int)(device_capabilities.SharedSystemMemory/(1024*1024)));
  }
 
  enginePermutations.initialize(context);
  renderStates.initialize(device);
 
  resources.initialize(context, this);
 
  defaultTarget = resources.createRenderTarget();
 
  initializeEngineBuffers(device->getBuffers(), device->getCapabilities(), engineBuffers);
  initializeEngineBindGroups(device->getBindGroups(), engineBindGroups);
 
  renderContext = getRenderTaskContext(this);
  pipelineManager->initialize(&renderContext);
 
  renderers->boundsRenderer.initialize(this, device);
  renderers->debugGeometryRenderer.initialize(this, device);
  renderers->imguiRenderer.initialize(context);
  renderers->engineInspectorGuiRenderer.initialize(context, this);
  context->variables->set("renderer.device", device->getIdentifier());
 
  settings.anisotropicFiltering = context->variables->get("renderer.anisotropicFiltering");
 
  for (auto & extension : extensions) {
    extension->initialize(context, device);
  }
}
 
void Cogs::Core::Renderer::cleanup()
{
  renderers->debugGeometryRenderer.cleanup();
 
  if (defaultTarget) {
    resources.releaseResource(defaultTarget);
  }
 
  pipelineManager->cleanup(&renderContext);
 
  renderers->engineInspectorGuiRenderer.cleanup(context, this);
  renderers->imguiRenderer.cleanup();
 
  if (context && context->variables->get("renderer.reportLeaks", false)) {
    resources.cleanup(context);
  }
 
  renderStates.cleanup();
}
 
void Cogs::Core::Renderer::render()
{
  // Since we do not control the main thread we need to set the GPU profiling context every time
  // we begin rendering.
  Instrumentation::beginGpuThread(device->getImmediateContext());
 
  auto textures = device->getTextures();
 
  bool reverseDepth = context->variables->get("renderer.reverseDepth", false);
  if(renderStates.reverseDepth != reverseDepth){
    renderStates.reverseDepth = reverseDepth;
    pipelineManager->dirty = true;
 
    renderStates.setupDepthStates(device);
 
    SamplerState comparisonSamplerState{};
    comparisonSamplerState.addressModeS = SamplerState::Border;
    comparisonSamplerState.addressModeT = SamplerState::Border;
    comparisonSamplerState.addressModeW = SamplerState::Border;
    if(reverseDepth) comparisonSamplerState.comparisonFunction = SamplerState::GreaterEqual;
    else comparisonSamplerState.comparisonFunction = SamplerState::LessEqual;
    comparisonSamplerState.filter = SamplerState::ComparisonMinMagMipLinear;
    for (unsigned i = 0; i < 4; i++) {
      if(reverseDepth) comparisonSamplerState.borderColor[i] = 0.f;
      else comparisonSamplerState.borderColor[i] = 1.f;
    }
 
    renderStates.shadowSampler = textures->loadSamplerState(comparisonSamplerState);
  }
 
  updateEffectFlags();
  updateSettings();
 
  renderContext.cameraData = &context->cameraSystem->getMainCameraData();
 
  defaultTarget->setName("Cogs.BackBuffer");
  defaultTarget->setOverride();
  defaultTarget->renderTargetHandle = RenderTargetHandle::NoHandle;
  defaultTarget->depthTargetHandle = DepthStencilHandle::NoHandle;
  defaultTarget->width = static_cast<int>(renderContext.cameraData->viewportSize.x);
  defaultTarget->height = static_cast<int>(renderContext.cameraData->viewportSize.y);
  defaultTarget->samples = device->getSettings().numSamples;
  defaultTarget->clearColors = { backgroundColor };
 
  const bool reloadEffects = context->variables->get("renderer.reloadEffects", false);
 
  if (reloadEffects) {
    effectCache.reload(&renderContext);
    context->variables->set("renderer.reloadEffects", false);
  }
 
  pipelineManager->setupPipeline(&renderContext);
 
  buildSortedListOfActiveLights(context, activeLights, maxLights);
 
  {
    const auto eventContext = getDrawContext(&renderContext);
 
    emitEvent(RenderingEvent::PreRender, &eventContext);
  }
 
  {
    int samples = context->variables->get("renderer.samples", 1);
    context->variables->set("impl.multiSample", samples > 1);
  }
 
  pipelineManager->initializeFrame(&renderContext);
  updateLightTexturesBindGroup(&renderContext);
  pipelineManager->applyPipeline(&renderContext);
 
  device->getImmediateContext()->setRenderTarget(defaultTarget->renderTargetHandle, defaultTarget->depthTargetHandle);
 
  if (mode == RenderMode::Box) {
    renderers->boundsRenderer.renderBounds(this, context, *pipelineManager->getRenderList());
  }
 
  {
    const auto eventContext = getDrawContext(&renderContext);
 
    emitEvent(RenderingEvent::RenderGui, &eventContext);
  }
 
  renderers->engineInspectorGuiRenderer.beginRender(context, this);
  renderers->engineInspectorGuiRenderer.render(context, this);
 
  if (context->callbacks.postRenderCallback) {
    context->callbacks.postRenderCallback(context);
  }
 
  renderers->engineInspectorGuiRenderer.endRender(context, this);
 
  {
    const DrawContext eventContext = getDrawContext(&renderContext);
 
    context->cameraSystem->postRender(context);
    emitEvent(RenderingEvent::PostRender, &eventContext);
  }
  pipelineManager->cleanupFrame(&renderContext);
}
 
void Cogs::Core::Renderer::setBackgroundColor(const glm::vec4 & backgroundColor)
{
  // Background color is expected to be in sRGB color space, renderer works in linear space.
  this->backgroundColor = glm::vec4(glm::convertSRGBToLinear(glm::vec3(backgroundColor)),
                                    backgroundColor.a);
}
 
void Cogs::Core::Renderer::updateEffectFlags()
{
  effectFlags = EffectFlags::None;
  if (context->variables->get("effects.logShaderInfo", false)) {
    effectFlags = static_cast<EffectFlags::EEffectFlags>(effectFlags | EffectFlags::LogShaderInfo);
  }
  if (context->variables->get("effects.logShaderSource", false)) {
    effectFlags = static_cast<EffectFlags::EEffectFlags>(effectFlags | EffectFlags::LogShaderSource);
  }
}
 
 
void Cogs::Core::Renderer::updateSettings()
{
 
  if(context->variables->exist("renderer.enableDeferred")){
    static uint32_t t = 0;
    if(t<6){
      t++;
      LOG_WARNING(logger, "Variable \"renderer.enableDeferred\" deprecated. Use \"renderer.pipeline\": \"Pipelines/Deferred.pipeline\".");
    }
    if(context->variables->get("renderer.enableDeferred", false))
      context->variables->set("renderer.pipeline", "Pipelines/Deferred.pipeline");
  }
 
  switch (StringView(context->variables->get("renderer.transparencyAlgorithm", "Regular")).hash())
  {
  case Cogs::hash("OIT"): settings.transparencyAlgorithm = RenderSettings::TransparencyAlgorithm::OIT; break;
  default:                settings.transparencyAlgorithm = RenderSettings::TransparencyAlgorithm::Regular; break;
  }
 
  switch (StringView(context->variables->get("renderer.blendKernel", "Alpha")).hash())
  {
  case Cogs::hash("DepthWeighted"): settings.blendKernel = RenderSettings::BlendKernel::DepthWeighted;  break;
  case Cogs::hash("Max"):           settings.blendKernel = RenderSettings::BlendKernel::Max;            break;
  case Cogs::hash("Max2"):          settings.blendKernel = RenderSettings::BlendKernel::Max2;           break;
  case Cogs::hash("Beers"):         settings.blendKernel = RenderSettings::BlendKernel::Beers;          break;
  default:                          settings.blendKernel = RenderSettings::BlendKernel::Alpha;          break;
  }
 
  settings.defaultRenderTargetClear = context->variables->get("renderer.backBuffer.clear.enable", true);
 
  if (Variable* var = context->variables->get("renderer.backBuffer.sRGB"); var->isEmpty()) {
    switch (context->device->getType()) {
    case Cogs::GraphicsDeviceType::OpenGLES30:
      settings.defaultRenderTargetExpectsSRGB = true;
      break;
    default:
      settings.defaultRenderTargetExpectsSRGB = false;
      break;
    }
    var->setBool(settings.defaultRenderTargetExpectsSRGB);
  }
  else {
    settings.defaultRenderTargetExpectsSRGB = var->getBool();
  }
 
  {
    Variable* var = context->variables->get("renderer.sRGBConversion");
    if (var->isEmpty()) {
      var->setValue("Exact");
    }
    switch (StringView(var->getCString()).hashLowercase()) {
    case Cogs::hash("fast"):
      settings.sRGBConversion = RenderSettings::SRGBConversion::Fast;
      break;
    case Cogs::hash("approx"):
      settings.sRGBConversion = RenderSettings::SRGBConversion::Approx;
      break;
    case Cogs::hash("exact"):
      settings.sRGBConversion = RenderSettings::SRGBConversion::Exact;
      break;
    default:
      settings.sRGBConversion = RenderSettings::SRGBConversion::Exact;
      break;
    }
  }
  {
    Variable* var = context->variables->get("renderer.tonemapper");
    if (var->isEmpty()) {
      var->setValue("Filmic");
    }
    switch (StringView(var->getCString()).hashLowercase()) {
    case Cogs::hash("reinhard"):
      settings.tonemapper = RenderSettings::Tonemapper::Reinhard;
      break;
    case Cogs::hash("filmic"):
      settings.tonemapper = RenderSettings::Tonemapper::Filmic;
      break;
    case Cogs::hash("acesluminance"):
      settings.tonemapper = RenderSettings::Tonemapper::ACESLuminance;
      break;
    case Cogs::hash("pbrneutral"):
      settings.tonemapper = RenderSettings::Tonemapper::PBRNeutral;
      break;
    default:
      settings.tonemapper = RenderSettings::Tonemapper::Filmic;
      break;
    }
  }
  settings.beersScaleFactor = context->variables->get("renderer.beers.scaleFactor", 1.f);
 
  settings.ambientIntensity = context->variables->get("renderer.ambientLightIntensity", 0.f);
  std::string acStr = context->variables->get("renderer.ambientLightColor", "1 1 1");
  static std::string prev;
 
  if (prev != acStr) {
    auto acTokens = tokenize(acStr);
    parseValues(glm::value_ptr(settings.ambientColor), acTokens, 3);
 
    // Ambient color is expected to be in sRGB color space, renderer works in linear space.
    settings.ambientColor = glm::convertSRGBToLinear(settings.ambientColor);
    prev = acStr;
  }
}
 
glm::mat4 Cogs::Core::Renderer::getProjectionMatrix(glm::mat4 projectionMatrix)
{
  if (!device) {
    return projectionMatrix;
  }
 
  if(context->variables->get("renderer.reverseDepth", false)){
     static glm::mat4 reverse(
      1, 0, 0, 0,
      0, 1, 0, 0,
      0, 0, -1, 0,
      0, 0, 0, 1
    );
    projectionMatrix = reverse * projectionMatrix;
  }
 
  switch (device->getType())
  {
  case GraphicsDeviceType::WebGPU :
  case GraphicsDeviceType::Direct3D11 :
  case GraphicsDeviceType::Direct3D12 :
  {
    static glm::mat4 depthScale = glm::scale(glm::mat4(1.0f), glm::vec3(1, 1, 0.5f));
    static glm::mat4 bias(
      1, 0, 0, 0,
      0, 1, 0, 0,
      0, 0, 1, 0,
      0, 0, 1, 1
    );
 
    glm::mat4 projection = depthScale * bias * projectionMatrix;
 
    return projection;
  }
  case GraphicsDeviceType::Vulkan :
  {
    static glm::mat4 depthScale = glm::scale(glm::mat4(1.0f), glm::vec3(1, -1, 0.5f));
    static glm::mat4 bias(
      1, 0, 0, 0,
      0, 1, 0, 0,
      0, 0, 1, 0,
      0, 0, 1, 1
    );
 
    glm::mat4 projection = depthScale * bias * projectionMatrix;
 
    return projection;
  }
  case GraphicsDeviceType::OpenGL20:
  case GraphicsDeviceType::OpenGLES30:
    if(device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne){
      return projectionMatrix;
    }
    else{
      static glm::mat4 depthScale = glm::scale(glm::mat4(1.0f), glm::vec3(1, 1, 0.5f));
      static glm::mat4 bias(
                            1, 0, 0, 0,
                            0, 1, 0, 0,
                            0, 0, 1, 0,
                            0, 0, 1, 1
                            );
 
      glm::mat4 projection = depthScale * bias * projectionMatrix;
 
      return projection;
    }
  case GraphicsDeviceType::Null:
    return projectionMatrix;
 
  default:
    LOG_WARNING(logger, "Unknown device type.");
    return projectionMatrix;
  }
}
glm::mat4 Cogs::Core::Renderer::getViewFromViewportMatrix(glm::mat4 inverseProjectionMatrix)
{
  if (!device) {
    return inverseProjectionMatrix;
  }
  switch (device->getType())
  {
  case GraphicsDeviceType::WebGPU:
  case GraphicsDeviceType::Direct3D11:
  case GraphicsDeviceType::Direct3D12:
  {
    glm::vec4 x = glm::vec4(0.1, 0.2, 0.3, 1.0);
    glm::mat4 clipFromViewport (
      2, 0, 0, 0,
      0, -2, 0, 0,
      0, 0, 1, 0,
      -1, 1, 0, 1
    );
    return inverseProjectionMatrix * clipFromViewport;
  }
  case GraphicsDeviceType::Vulkan:
  {
    // TODO: Verify this
    return inverseProjectionMatrix;
  }
  case GraphicsDeviceType::OpenGL20:
  case GraphicsDeviceType::OpenGLES30:
    if (device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne) {
      glm::mat4 scale = glm::scale(glm::mat4(1.0), glm::vec3(2.0, 2.0, 2.0));
      static glm::mat4 bias(
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        -1, -1, -1, 1
      );
      return inverseProjectionMatrix * bias * scale;
    }
    else {
      glm::mat4 scale = glm::scale(glm::mat4(1.0), glm::vec3(2.0, 2.0, 1.0));
      static glm::mat4 bias(
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        -1, -1, 0, 1
      );
      return inverseProjectionMatrix * bias * scale;
    }
  case GraphicsDeviceType::Null:
    return inverseProjectionMatrix;
 
  default:
    LOG_WARNING(logger, "Unknown device type.");
    return inverseProjectionMatrix;
  }
}
float Cogs::Core::Renderer::getClearDepth()
{
  if(context->variables->get("renderer.reverseDepth", false)) {
    return 0.0f;
  }
  return 1.0f;
}
float Cogs::Core::Renderer::getNearDepth()
{
  if(context->variables->get("renderer.reverseDepth", false)) {
    return 1.0f;
  }
  if(device && device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne){
    return -1.0f;
  }
  else{
    return 0.0f;
  }
}
 
void Cogs::Core::Renderer::beginFrame()
{
  if (!device) return;
 
  device->beginFrame();
}
 
void Cogs::Core::Renderer::endFrame(uint32_t syncInterval, Cogs::PresentFlags presentFlags)
{
  if (!device) return;
 
  device->endFrame(syncInterval, presentFlags);
}
 
Cogs::Core::IRenderResources * Cogs::Core::Renderer::getResources()
{
  return &resources;
}
 
void Cogs::Core::Renderer::registerExtension(IRendererExtension * extension)
{
  extensions.push_back(extension);
 
  if (context) {
    extension->initialize(context, device);
  }
}
 
void Cogs::Core::Renderer::unregisterExtension(IRendererExtension* extension)
{
  auto it = std::find(extensions.begin(), extensions.end(), extension);
  assert(it != extensions.end() && "Unregistering unknown IRendererExtension");
  if (it != extensions.end()) {
    extensions.erase(it);
  }
}
 
 
void Cogs::Core::Renderer::renderScreenshot(const ScreenshotSettings & settings, std::vector<uint8_t> & bytes, uint32_t * stride)
{
  auto deviceContext = device->getImmediateContext();
  auto renderTargets = device->getRenderTargets();
  auto textures = device->getTextures();
  auto buffers = device->getBuffers();
  auto format = TextureFormat::R8G8B8A8_UNORM_SRGB;
 
  const size_t size = (size_t)settings.width * (size_t)settings.height * Cogs::getBlockSize(format);
 
  auto readBuffer = buffers->loadBuffer(nullptr, size, Usage::Staging, AccessMode::Read, BindFlags::None);
 
  Cogs::TextureHandle texture;
  {
    TextureDescription desc;
    if(settings.numSamples > 1)
      desc.target = ResourceDimensions::Texture2DMS;
    else
      desc.target = ResourceDimensions::Texture2D;
    desc.width = settings.width;
    desc.height = settings.height;
    desc.format = format;
    desc.samples = settings.numSamples;
    desc.flags = TextureFlags::RenderTarget;
    texture = textures->loadTexture(desc, nullptr);
  }
 
  auto renderTarget = renderTargets->createRenderTarget(&texture, 1);
  auto depthStencilTarget = renderTargets->createDepthStencilTarget(renderTarget);
 
  auto camera = context->cameraSystem->getMainCamera();
  auto restoreViewport = camera->viewportSize;
  camera->viewportSize = glm::vec2(settings.width, settings.height);
  context->cameraSystem->update(context);
 
  renderContext.cameraData = &context->cameraSystem->getMainCameraData();
 
  pipelineManager->setupPipeline(&renderContext);
 
  auto restoreRenderTargetHandle = defaultTarget->renderTargetHandle;
  auto restoreDepthTargetHandle = defaultTarget->depthTargetHandle;
  auto restoreWidth = defaultTarget->width;
  auto restoreHeight = defaultTarget->height;
  auto restoreSamples = defaultTarget->samples;
  auto restoreColors = std::move(defaultTarget->clearColors);
 
  defaultTarget->renderTargetHandle = renderTarget;
  defaultTarget->depthTargetHandle = depthStencilTarget;
  defaultTarget->width = settings.width;
  defaultTarget->height = settings.height;
  defaultTarget->samples = settings.numSamples;
  defaultTarget->clearColors = { backgroundColor };
 
  pipelineManager->initializeFrame(&renderContext);
  pipelineManager->applyPipeline(&renderContext);
  pipelineManager->cleanupFrame(&renderContext);
 
  if (settings.numSamples > 1) {
    auto resolveTexture = textures->loadTexture(nullptr, settings.width, settings.height, format, Cogs::TextureFlags::RenderTarget);
    auto resolveRt = renderTargets->createRenderTarget(&resolveTexture, 1);
    auto resolveDt = renderTargets->createDepthStencilTarget(resolveRt);
 
    deviceContext->resolveResource(texture, resolveTexture);
 
    deviceContext->setRenderTarget(resolveRt, resolveDt);
 
    deviceContext->readColorBuffer(readBuffer, 0, 0, settings.width, settings.height, Framebuffer::Front);
 
    renderTargets->releaseDepthStencilTarget(resolveDt);
    renderTargets->releaseRenderTarget(resolveRt);
    textures->releaseTexture(resolveTexture);
  } else {
    deviceContext->setRenderTarget(renderTarget, depthStencilTarget);
 
    deviceContext->readColorBuffer(readBuffer, 0, 0, settings.width, settings.height, Framebuffer::Front);
  }
 
  {
    MappedBuffer<uint8_t> data(deviceContext, readBuffer, MapMode::Read, size);
 
    if (data) {
      const size_t bufferSize = data.getStride() ? data.getStride() * settings.height : size;
      bytes.assign(data.get(), data.get() + bufferSize);
 
      if (stride) {
        *stride = data.getStride();
      }
    }
  }
 
  defaultTarget->renderTargetHandle = restoreRenderTargetHandle;
  defaultTarget->depthTargetHandle = restoreDepthTargetHandle;
  defaultTarget->width = restoreWidth;
  defaultTarget->height = restoreHeight;
  defaultTarget->samples = restoreSamples;
  defaultTarget->clearColors = std::move(restoreColors);
 
  camera->viewportSize = restoreViewport;
 
  buffers->releaseBuffer(readBuffer);
  renderTargets->releaseDepthStencilTarget(depthStencilTarget);
  renderTargets->releaseRenderTarget(renderTarget);
  textures->releaseTexture(texture);
}
 
void Cogs::Core::Renderer::emitEvent(uint32_t eventId, const DrawContext * renderingContext)
{
  for (auto extension : extensions) {
    extension->handleEvent(eventId, renderingContext);
  }
}
 
void Cogs::Core::Renderer::updatePermutation(EnginePermutation * permutation)
{
  const bool ditherEnabled = context->variables->get("renderer.ditherEnabled", false);
  if(permutation->hasVariant("Dither"))
    permutation->setVariant("Dither", ditherEnabled);
 
  const bool reverseDepth = context->variables->get("renderer.reverseDepth", false);
  if(permutation->hasVariant("ReverseDepth"))
    permutation->setVariant("ReverseDepth", reverseDepth);
 
  if(permutation->hasVariant("DepthNegativeOneToOne"))
    permutation->setVariant("DepthNegativeOneToOne", device->getCapabilities()->getDeviceCapabilities().DepthNegativeOneToOne);
 
  if (!permutation->hasBuiltins()) return;
  if (!permutation->isShadingPass() || permutation->isDepthOnly()) return;
 
  if (auto ec = context->environmentSystem->getGlobalEnvironment(); ec != nullptr) {
    permutation->setVariant("SubseaSupport", ec->subseaSupport);
    if(ec->imageBasedLighting) {
      if(ec->PBR) {
        permutation->setVariant("ImageBasedLighting", "PBR");
      } else {
        permutation->setVariant("ImageBasedLighting", "Phong");
      }
    } else {
      permutation->setVariant("ImageBasedLighting", "Disabled");
    }
  }
 
 
  const bool shadowsEnabled = (activeLights.numDirectionalShadowLights != 0) || (activeLights.numPointShadowLights != 0);
  permutation->setVariant("NumDirectionalShadowLights", static_cast<int>(activeLights.numDirectionalShadowLights));
  permutation->setVariant("NumPointShadowLights", static_cast<int>(activeLights.numPointShadowLights));
  permutation->setVariant("NumDirectionalLights", static_cast<int>(activeLights.numDirectionalLights));
  permutation->setVariant("NumPointLights", static_cast<int>(activeLights.numPointLights));
  permutation->setVariant("ShadowsEnabled", shadowsEnabled);
  if (shadowsEnabled) {
    const Cogs::Core::SoftShadows softShadows = parseEnum<SoftShadows>(context->variables->get("shadows.softShadows", "Default"));
    permutation->setVariant("SoftShadows", (int)softShadows);
  }
 
  if(permutation->hasVariant("sRGBConversion"))  {
    switch (settings.sRGBConversion) {
    case RenderSettings::SRGBConversion::Fast:
      permutation->setVariant("sRGBConversion", "Fast");
      break;
    case RenderSettings::SRGBConversion::Approx:
      permutation->setVariant("sRGBConversion", "Approx");
      break;
    case RenderSettings::SRGBConversion::Exact:
      permutation->setVariant("sRGBConversion", "Exact");
      break;
    default:
      assert(false && "Invalid enum");
      break;
    }
  }
 
  if (permutation->hasVariant("Tonemapper")) {
    switch (settings.tonemapper) {
    case RenderSettings::Tonemapper::Reinhard:
      permutation->setVariant("Tonemapper", "Reinhard");
      break;
    case RenderSettings::Tonemapper::Filmic:
      permutation->setVariant("Tonemapper", "Filmic");
      break;
    case RenderSettings::Tonemapper::ACESLuminance:
      permutation->setVariant("Tonemapper", "ACESLuminance");
      break;
    case RenderSettings::Tonemapper::PBRNeutral:
      permutation->setVariant("Tonemapper", "PBRNeutral");
      break;
    default:
      assert(false && "Invalid enum");
      break;
    }
  }
 
}
 
Cogs::Core::ImguiRenderer* Cogs::Core::Renderer::getGuiRenderer() {
  return &renderers->imguiRenderer;
}
 
Cogs::Core::InspectorGuiRenderer * Cogs::Core::Renderer::getEngineInspectorGuiRenderer()
{
  return &renderers->engineInspectorGuiRenderer;
}