ClipmapDebug.cpp

#include "ClipmapDebug.h"
 
#include "ClipmapTerrainTypes.h"
#include "Effects.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IBuffers.h"
#include "Rendering/ITextures.h"
#include "Rendering/IContext.h"
#include "Rendering/IRenderTargets.h"
 
#include <cassert>
 
struct DebugGlobals{
  glm::mat4 projectionMatrix;
  glm::vec4 diffuseColor;
};
 
void Cogs::ClipmapDebug::displayClipmapTexture(IGraphicsDevice * device, TextureHandle texture, int x, int y, int width, int height, float multiplier)
{
  static Cogs::EffectHandle effectHandle = Cogs::EffectHandle::InvalidHandle;
  static Cogs::InputLayoutHandle inputLayoutHandle = Cogs::InputLayoutHandle::InvalidHandle;
  static BufferHandle constantBuffer = BufferHandle::NoHandle;
  static VertexBufferHandle quadBuffer = VertexBufferHandle::NoHandle;
  static SamplerStateHandle samplerStateHandle = SamplerStateHandle::NoHandle;
  static DepthStencilStateHandle depthStateHandle = DepthStencilStateHandle::NoHandle;
 
  if(!HandleIsValid(constantBuffer)){
    constantBuffer = device->getBuffers()->loadBuffer(nullptr, sizeof(DebugGlobals), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  }
 
  if (!HandleIsValid(quadBuffer)) {
    auto effects = device->getEffects();
    auto buffers = device->getBuffers();
    effectHandle = Terrain::EffectLoader::loadEffect(effects, "ClipmapDebugVS", "ClipmapDebugPS");
    assert(effects->checkEffect(effectHandle) == Cogs::ResourceStatus::Ready && "Expects synchronous effect loading");
 
    VertexElement elements[] = {
      { 0, DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 },
      { 3 * sizeof(float), DataFormat::X32Y32_FLOAT, ElementSemantic::TextureCoordinate, 0, InputType::VertexData, 0 }
    };
    VertexFormatHandle vertexFormat = buffers->createVertexFormat(elements, 2);
    inputLayoutHandle = buffers->loadInputLayout(&vertexFormat, 1, effectHandle);
 
    const float z = 0.0f;
 
    const float positions[] = {
      -1, -1, z, 0, 1,
      1, -1, z, 1, 1,
      1, 1, z, 1, 0,
 
      -1, -1, z, 0, 1,
      1, 1, z, 1, 0,
      -1, 1, z, 0, 0,
    };
    quadBuffer = device->getBuffers()->loadVertexBuffer(positions, 6, vertexFormat);
 
    SamplerState sampler = {
      SamplerState::AddressMode::Wrap,
      SamplerState::AddressMode::Wrap,
      SamplerState::AddressMode::Wrap,
      SamplerState::FilterMode::MinMagMipPoint,
      SamplerState::ComparisonFunction::Never,
      0,
      { 0.0f, 0.0f, 0.0f, 0.0f },
    };
    samplerStateHandle = device->getTextures()->loadSamplerState(sampler);
 
    DepthStencilState depthState = { true, true, DepthStencilState::Always };
    depthStateHandle = device->getRenderTargets()->loadDepthStencilState(depthState);
  }
 
  if (HandleIsValid(texture)) {
    auto context = device->getImmediateContext();
 
    context->setRasterizerState(RasterizerStateHandle::NoHandle);
    context->setBlendState(BlendStateHandle::NoHandle);
    context->setDepthStencilState(depthStateHandle);
 
    context->setViewport(static_cast<float>(x), static_cast<float>(y), static_cast<float>(width), static_cast<float>(height));
 
    const uint32_t strides[] = { 5 * sizeof(float) };
    context->setVertexBuffers(&quadBuffer, 1, strides, nullptr);
 
    context->setEffect(effectHandle);
    context->setInputLayout(inputLayoutHandle);
 
    const auto ortho = glm::ortho<float>(-1, 1, -1, 1, -1, 1);
    const Vector4 diffuse{ multiplier, multiplier, multiplier, 1 };
 
    {
      MappedBuffer<DebugGlobals> constants(context, constantBuffer, MapMode::WriteDiscard);
      if (constants) {
        constants->projectionMatrix = ortho;
        constants->diffuseColor = diffuse;
      }
    }
    context->setConstantBuffer("Globals", constantBuffer);
 
    context->setTexture("diffuseTexture", 0, texture);
    context->setSamplerState("diffuseSampler", 0, samplerStateHandle);
 
    context->draw(PrimitiveType::TriangleList, 0, 6);
 
    context->setDepthStencilState(DepthStencilStateHandle::NoHandle);
  }
}