MipLevelsTask.cpp

#include "MipLevelsTask.h"
 
#include "Platform/Instrumentation.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
#include "Rendering/SamplerState.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderTexture.h"
 
#include "Resources/VertexFormats.h"
 
#include "Utilities/Parsing.h"
 
using namespace Cogs;
 
namespace
{
  struct MipLevelsParameter
  {
    glm::vec2 srcTexelSize;
    glm::vec2 dstTexelSize;
    int srcLevel;
    int dstLevel;
  };
}
void Cogs::Core::MipLevelsTask::initialize(RenderTaskContext* context)
{
  PostProcessTask::initialize(context);
}
 
void Cogs::Core::MipLevelsTask::initialize(RenderTaskContext * context, const RenderTaskDefinition& taskDefinition)
{
  PostProcessTask::initialize(context, taskDefinition);
  if (effect == nullptr || !HandleIsValid(effect->handle)) return;
 
  auto device = context->renderer->getDevice();
  auto effects = device->getEffects();
  auto buffers = device->getBuffers();
 
  parameterHandle = buffers->loadBuffer(nullptr, sizeof(MipLevelsParameter), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  parameterBufferBinding = effects->getConstantBufferBinding(effect->handle, "MipLevelsParameter");
}
 
void Cogs::Core::MipLevelsTask::cleanup(RenderTaskContext * context)
{
  auto device = context->renderer->getDevice();
  auto buffers = device->getBuffers();
  buffers->releaseBuffer(parameterHandle);
  PostProcessTask::cleanup(context);
}
 
void Cogs::Core::MipLevelsTask::apply(RenderTaskContext * context)
{
  DynamicRenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "MipLevelsTask", (std::string("MipLevelsTask<") + name + ">::apply").c_str());
 
  if (effect == nullptr || !HandleIsValid(effect->handle)) return;
 
  auto device = context->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
  auto effects = device->getEffects();
 
  auto renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
  auto targetSource = renderTarget->textures[0];
 
  std::string targetSourceKey;
  for (auto & p : properties) {
    if (p.definition->type == ParsedDataType::Texture2D) {
      auto inputSource = input.get(p.definition->value);
      RenderTexture* tex = nullptr;
      if (inputSource->type == RenderResourceType::RenderTexture) {
        tex = inputSource->renderTexure;
      }
      else if (inputSource->type == RenderResourceType::RenderTarget) {
        tex = inputSource->renderTarget->textures[0];
      }
      if (tex) {
        targetSourceKey = p.definition->key;
      }
    }
  }
 
  size_t maxLevel = std::max(size_t(1u), renderTarget->mipLevelViews.size());
  if (sizes.size() != maxLevel || sizes[0].x != renderTarget->width || sizes[0].y != renderTarget->height) {
    sizes.resize(maxLevel);
    sizes[0] = glm::ivec2(renderTarget->width, renderTarget->height);
    for (uint32_t i = 1; i < maxLevel; i++) {
      sizes[i] = glm::ivec2(std::max(1, sizes[i - 1].x / 2), std::max(1, sizes[i - 1].y / 2));
    }
  }
 
  TextureBindingHandle targetSourceHandle = TextureBindingHandle::NoHandle;
  if (!targetSourceKey.empty()) {
    SamplerState ss;
    std::memset(&ss, 0, sizeof(SamplerState));
    ss.addressModeS = SamplerState::Clamp;
    ss.addressModeT = SamplerState::Clamp;
    ss.addressModeW = SamplerState::Clamp;
    ss.filter = SamplerState::MinMagMipLinear;
 
    targetSourceHandle = effects->getTextureBinding(effect->handle, targetSourceKey, texUnit);
    deviceContext->setSamplerState(targetSourceKey + "Sampler", texUnit, context->states->getSamplerState(ss));
 
    texUnit++;
  }
 
  if (!HandleIsValid(targetSourceHandle)) {
    //TODO: Log warning
    return;
  }
 
  size_t currentFirstLevel = std::min(maxLevel - 1u, static_cast<size_t>(firstLevel));
  size_t currentLastLevel = std::min(maxLevel - 1u, static_cast<size_t>(lastLevel));
  if (currentFirstLevel < currentLastLevel) {
    for (size_t level = currentFirstLevel; level < currentLastLevel; level++) {
      draw(context, renderTarget, targetSource, targetSourceHandle, level, level + 1);
    }
  } else if (currentLastLevel < currentFirstLevel) {
    for (size_t level = currentFirstLevel; currentLastLevel < level; level--) {
      draw(context, renderTarget, targetSource, targetSourceHandle, level, level - 1);
    }
  }
}
 
void Cogs::Core::MipLevelsTask::draw(RenderTaskContext * context,
                                     RenderTarget * renderTarget,
                                     RenderTexture * targetSource,
                                     TextureBindingHandle &targetSourceHandle,
                                     const size_t srcLevel, const size_t dstLevel)
{
  auto device = context->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  if(device->getCapabilities()->getDeviceCapabilities().RenderPass){
    RenderPassInfo info;
    info.renderTargetHandle = renderTarget->mipLevelViews[dstLevel];
    info.depthStencilHandle = DepthStencilHandle::NoHandle;
    {
      uint32_t i = 0;
      info.loadOp[i] = clearColor ? LoadOp::Clear : LoadOp::Load;
      info.storeOp[i] = StoreOp::Store;
      glm::vec4 color;
      if (clearToDefault) {
        color = context->renderer->getBackgroundColor();
      }
      else{
        color = renderTarget->getClearColor();
      }
      info.clearValue[i][0] = color[0];
      info.clearValue[i][1] = color[1];
      info.clearValue[i][2] = color[2];
      info.clearValue[i][3] = color[3];
    }
    info.depthLoadOp = LoadOp::Undefined;
    info.depthStoreOp = StoreOp::Undefined;
    info.depthClearValue = context->renderer->getClearDepth();
    deviceContext->beginRenderPass(info);
  }
  else{
    deviceContext->setRenderTarget(renderTarget->mipLevelViews[dstLevel], DepthStencilHandle::NoHandle);
  }
 
  deviceContext->setEffect(effect->handle);
  deviceContext->setDepthStencilState(context->states->noDepthStencilStateHandle);
  deviceContext->setRasterizerState(context->states->defaultRasterizerStateHandle);
 
  for (size_t i = 0; i < 4; ++i) {
    if (HandleIsValid(samplerStateBindings[i])) {
      deviceContext->setSamplerState(samplerStateBindings[i], samplerStates[i]);
    }
  }
 
  setProperties(context, targetSource);
 
  {
    MappedBuffer<MipLevelsParameter> parameters(deviceContext, parameterHandle, MapMode::WriteDiscard);
 
    if (parameters) {
      parameters->srcTexelSize = glm::vec2(1.f) / glm::vec2(sizes[srcLevel]);
      parameters->dstTexelSize = glm::vec2(1.f) / glm::vec2(sizes[dstLevel]);
      parameters->srcLevel = static_cast<int>(srcLevel);
      parameters->dstLevel = static_cast<int>(dstLevel);
    }
  }
 
  deviceContext->setConstantBuffer(parameterBufferBinding, parameterHandle);
 
  TextureViewDescription textureViewDesc = {};
  textureViewDesc.texture = targetSource->textureHandle;
  textureViewDesc.layerIndex = 0;
  textureViewDesc.numLayers = 1;
  textureViewDesc.levelIndex = static_cast<uint32_t>(srcLevel);
  textureViewDesc.numLevels = 1;
 
  size_t code = textureViewDesc.hash();
 
  auto found = targetSource->views.find(code);
 
  Cogs::TextureViewHandle textureView;
  if (found == targetSource->views.end()) {
    textureView = device->getTextures()->createTextureView(textureViewDesc);
    targetSource->views.insert({ code, textureView });
  } else {
    textureView = found->second;
  }
 
  deviceContext->setTexture(targetSourceHandle, textureView);
  deviceContext->setViewport(0, 0, (float)sizes[dstLevel].x, (float)sizes[dstLevel].y);
 
  deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(inputLayout);
 
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
 
  if(device->getCapabilities()->getDeviceCapabilities().RenderPass){
    deviceContext->endRenderPass();
  }
}