RenderTarget.cpp

#include "RenderTarget.h"
 
#include "Rendering/ITextures.h"
#include "Rendering/IRenderTargets.h"
#include "Rendering/ISwapChain.h"
 
#include "Tasks/RenderTask.h"
 
#include "Renderer.h"
#include "RenderTexture.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTarget");
}
 
void Cogs::Core::RenderTarget::update(Renderer * renderer)
{
  auto device = renderer->getDevice();
  auto targets = device->getRenderTargets();
 
  if (!checkUpdate()) return;
 
  release(renderer);
 
  size_t textureCount = textures.size();
 
  // Hooks for external textures/targets
  // -----------------------------------
 
  if (textureCount == 1) {
 
    // Override implies that the texture is managed externally. We make a render and depth targets using those textures and exit.
    if(textures[0]->isOverride()) {
 
      RenderTexture* texture = textures[0];
      for (size_t i = 0; i < static_cast<size_t>(texture->count); ++i) {
 
        renderTargetHandles[i] = targets->createRenderTarget(&texture->textureHandles[i], 1);
        targets->annotate(renderTargetHandles[i], getName().to_string() + " color target " + std::to_string(i));
 
        depthTargetHandles[i] = depth ? targets->createDepthStencilTarget(renderTargetHandles[i], depth->textureHandle) : targets->createDepthStencilTarget(renderTargetHandles[i]);
        targets->annotate(depthTargetHandles[i], getName().to_string() + " depth target " + std::to_string(i));
      }
 
      renderTargetHandle = renderTargetHandles[0];
      depthTargetHandle = depthTargetHandles[0];
      width = texture->description.width;
      height = texture->description.height;
      samples = texture->description.samples;
      return;
    }
 
    // Texture is just a proxy for a swap chain
    if (textures[0]->swapChain) {
      Cogs::ISwapChain* swapChain = textures[0]->swapChain;
      renderTargetHandle = swapChain->getRenderTarget();
      depthTargetHandle = swapChain->getDepthStencil();
      width = swapChain->getWidth();
      height = swapChain->getHeight();
      samples = swapChain->getSamples();
      return;
    }
  }
 
  // Normal rendertarget with cogs textures
  // --------------------------------------
 
  // Populated if enabled on color, used by color and depth.
  Cogs::MultiViewDescription multiViewDesc{};
 
  // No textures
  if (textureCount == 0) {
    renderTargetHandle = RenderTargetHandle::NoHandle;
  }
 
  // Single color texture, support for mipmaps
  else if (textureCount == 1) {
 
    size_t levelViews = std::max(1u, std::min(textures[0]->description.levels, static_cast<uint32_t>(levels)));
 
    RenderTargetViewDescription view = {
      .texture = textures[0]->textureHandle,
      .layerIndex = layerIndex,
      .numLayers = numLayers,
      .levelIndex = 0
    };
    mipLevelViews.resize(levelViews);
    for (size_t l = 0; l < levelViews; l++) {
      view.levelIndex = uint8_t(l);
 
      if (1 < multiViewCount) {
        multiViewDesc.baseIndex = multiViewBaseIndex;
        multiViewDesc.count = multiViewCount;
        multiViewDesc.samples = multiViewSamples;
        mipLevelViews[l] = targets->createRenderTarget(&view, 1, multiViewDesc);
      }
      else {
        mipLevelViews[l] = targets->createRenderTarget(&view, 1);
      }
      targets->annotate(mipLevelViews[l], getName().to_string() + " view " + std::to_string(l));
    }
    renderTargetHandle = mipLevelViews[0];
 
  }
 
  // Multiple textures, no mipmap support for now.
  else {
 
    std::vector<Cogs::TextureHandle> handles;
    for (auto& texture : textures) {
      if (HandleIsValid(texture->textureHandle)) {
        handles.push_back(texture->textureHandle);
      }
    }
 
    if (!handles.empty()) {
      mipLevelViews.resize(1);
      mipLevelViews[0] = targets->createRenderTarget(handles.data(), handles.size());
      targets->annotate(mipLevelViews[0], getName().to_string());
      renderTargetHandle = mipLevelViews[0];
    }
    else if (textures.size() == 1) {
      if (textures[0]->swapChain) {
        renderTargetHandle = textures[0]->swapChain->getRenderTarget();
      }
    }
  }
 
 
  if (depth && HandleIsValid(depth->textureHandle)) {
    DepthStencilViewDescription depthTextureView = {};
    depthTextureView.texture = depth->textureHandle;
    depthTextureView.layerIndex = uint16_t(depthLayerIndex);
    depthTextureView.numLayers = 1;
    if (multiViewDesc.count) {
      depthTargetHandle = targets->createDepthStencilTarget(renderTargetHandle, depthTextureView, multiViewDesc);
    }
    else {
      depthTargetHandle = targets->createDepthStencilTarget(renderTargetHandle, depthTextureView);
    }
    targets->annotate(depthTargetHandle, getName().to_string());
  }
  else {
    depthTargetHandle = DepthStencilHandle::NoHandle;
  }
 
  if (textures.size()) {
    width = textures[0]->description.width;
    height = textures[0]->description.height;
    samples = textures[0]->description.samples;
  }
  else if (depth) {
    width = depth->description.width;
    height = depth->description.height;
    samples = depth->description.samples;
  }
 
}
 
void Cogs::Core::RenderTarget::release(Renderer * renderer)
{
  if ((textures.size() == 1) && textures[0]->swapChain) {
    renderTargetHandle = RenderTargetHandle::NoHandle;
    depthTargetHandle = DepthStencilHandle::NoHandle;
  }
  else {
    auto device = renderer->getDevice();
    auto renderTargets = device->getRenderTargets();
 
    if (HandleIsValid(depthTargetHandle)) {
      renderTargets->releaseDepthStencilTarget(depthTargetHandle);
      depthTargetHandle = DepthStencilHandle::NoHandle;
    }
 
    if (!mipLevelViews.empty()) {
      for (auto & h : mipLevelViews) {
        if (HandleIsValid(h)) {
          renderTargets->releaseRenderTarget(h);
        }
      }
      mipLevelViews.clear();
    }
    else if (HandleIsValid(renderTargetHandle)) {
      renderTargets->releaseRenderTarget(renderTargetHandle);
      renderTargetHandle = RenderTargetHandle::NoHandle;
    }
  }
}
 
Cogs::TextureHandle Cogs::Core::RenderTarget::get(const std::string & name)
{
  for (auto & t : textures) {
    if (t->getName() == name) return t->textureHandle;
  }
 
  return Cogs::TextureHandle::NoHandle;
}
 
bool Cogs::Core::RenderTarget::checkUpdate()
{
  if (isOverride()) return false;
 
  size_t generationHash = hash();
  for (auto & t : textures) {
    generationHash = hash(t->getGeneration(), generationHash);
  }
  if (depth) {
    generationHash = hash(depth->getGeneration(), generationHash);
  }
  generationHash = hash(static_cast<uint32_t>(this->levels), generationHash);
 
  if (generationHash != this->generationHash) {
    this->generationHash = generationHash;
    return true;
  }
  return false;
}