MipLevelsTask.cpp

#include "MipLevelsTask.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IContext.h"
#include "Rendering/SamplerState.h"
#include "Rendering/ITextures.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));
    }
  }
 
  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);
 
  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 l = currentFirstLevel; l < currentLastLevel; l++) {
      const size_t srcLevel = l;
      const size_t dstLevel = l + 1;
 
 
      {
        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);
 
      deviceContext->setRenderTarget(renderTarget->mipLevelViews[dstLevel], DepthStencilHandle::NoHandle);
 
       // Why must it be done after setRenderTarget (WebGPU)
      deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
      deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
      deviceContext->setInputLayout(inputLayout);
 
 
      TextureViewDescription textureViewDesc = {};
      textureViewDesc.texture = targetSource->textureHandle;
      textureViewDesc.levelIndex = static_cast<uint32_t>(srcLevel);
      textureViewDesc.numLevels = 1;
      textureViewDesc.numLayers = 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->draw(PrimitiveType::TriangleList, 0, 3);
    }
  } else if (currentLastLevel < currentFirstLevel) {
    for (size_t l = currentFirstLevel; currentLastLevel < l; l--) {
      const size_t srcLevel = l;
      const size_t dstLevel = l - 1;
 
      {
        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);
      deviceContext->setRenderTarget(renderTarget->mipLevelViews[dstLevel], DepthStencilHandle::NoHandle);
 
      TextureViewDescription textureViewDesc = {};
      textureViewDesc.texture = targetSource->textureHandle;
      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->draw(PrimitiveType::TriangleList, 0, 3);
    }
  }
}