ClipmapDepthQuery.cpp

#include "ClipmapDepthQuery.h"
#include "ClipmapRenderer.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/IContext.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ClipmapDepthQuery");
}
 
Cogs::ClipmapDepthQuery::ClipmapDepthQuery()
  : device(nullptr),
  clipmapRenderer(nullptr)
{
 
}
 
void Cogs::ClipmapDepthQuery::initialize(IGraphicsDevice * device, ClipmapRenderer * clipmapRenderer)
{
  this->device = device;
  this->clipmapRenderer = clipmapRenderer;
 
  const size_t queryBufferSize = clipmapRenderer->depthQuerySize * clipmapRenderer->depthQuerySize * sizeof(float) * 4;
 
  this->queryReadBackBuffer = device->getBuffers()->loadBuffer(nullptr, queryBufferSize * 4, Usage::Staging, AccessMode::Read, 0);
}
 
Cogs::ClipmapDepthQuery::~ClipmapDepthQuery()
{
  if (!device) return;
 
  auto buffers = device->getBuffers();
 
  if (HandleIsValid(queryReadBackBuffer)) {
    buffers->releaseBuffer(queryReadBackBuffer);
  }
}
 
void Cogs::ClipmapDepthQuery::readBack()
{
  IContext * context = this->device->getImmediateContext();
  for (auto & data : clipmapRenderer->raypickDepthData) {
    context->setRenderTarget(data.depthRenderHandle, data.depthTargetHandle);
    context->readColorBuffer(data.readbackBufferHandle, 0, 0, data.width, data.height, Framebuffer::Front);
  }
 
  context->setRenderTarget(clipmapRenderer->depthQueryRenderHandle, clipmapRenderer->depthQueryTargetHandle);
  context->readColorBuffer(queryReadBackBuffer, 0, 0, clipmapRenderer->depthQuerySize, clipmapRenderer->depthQuerySize, Framebuffer::Front);
  context->setRenderTarget(RenderTargetHandle::NoHandle, DepthStencilHandle::NoHandle);
  hasReadBack = clipmapRenderer->raypickDepthData[0].depthRenderInitialized && clipmapRenderer->depthQueryRenderInitialized;
}
 
bool Cogs::ClipmapDepthQuery::getPositions(const Vector2 * mousePositions, const Matrix & inverseViewProjection, const size_t numPositions, Vector4 * worldPos, bool * positionValid, int rayPickId)
{
  if (rayPickId < 0 || rayPickId >= static_cast<int>(clipmapRenderer->raypickDepthData.size())) {
    LOG_ERROR(logger, "Invalid ray pick id: %d", rayPickId);
    return false;
  }
 
  auto & depthData = clipmapRenderer->raypickDepthData[rayPickId];
  if (!device || !HandleIsValid(depthData.readbackBufferHandle) || !hasReadBack) return false;
 
  IContext * context = this->device->getImmediateContext();
 
  MappedBuffer<float> data(context, depthData.readbackBufferHandle, MapMode::Read);
 
  if (!data) return false;
 
  bool anyValid = false;
  const int width = depthData.width;
  const int height = depthData.height;
 
  bool flip = device->getType() == GraphicsDeviceType::Direct3D11 ? true : false;
 
  const int rowPitch = data.getStride() ? data.getStride() / sizeof(float) : width;
 
  for (size_t i = 0; i < numPositions; ++i) {
    const float screenX = mousePositions[i][0] * width;
    const float screenY = (flip ? (1.0f - mousePositions[i][1]) : mousePositions[i][1]) * height;
 
    const int screenIndexX = static_cast<int>(screenX);
    const int screenIndexY = static_cast<int>(screenY);
 
    if ((screenIndexX < 0 || screenIndexX >= width) || (screenIndexY < 0 || screenIndexY >= height)) {
      LOG_WARNING(logger, "Readback positions outside of buffer dimensions.");
 
      return false;
    }
 
    const float depth = data[screenIndexY * rowPitch + screenIndexX];
    float clearDepth = 1.0;
    if(clipmapRenderer->reverseDepth)
      clearDepth = 0.0f;
 
    if (depth != clearDepth) {
      // Reconstruct the projected, normalized screen position from the positions
      // and the queried depth.
      const float x = (mousePositions[i][0] - 0.5f) * 2.0f;
      const float y = (mousePositions[i][1] - 0.5f) * 2.0f;
 
      const Vector4 screenPos(x, y, depth, 1);
 
      worldPos[i] = inverseViewProjection * screenPos;
 
      if (worldPos[i][3] != 0) {
        // Renormalize to get world position.
        worldPos[i] /= worldPos[i][3];
        positionValid[i] = true;
        anyValid = true;
      } else {
        positionValid[i] = false;
      }
    } else {
      positionValid[i] = false;
    }
  }
 
  return anyValid;
}
 
float Cogs::ClipmapDepthQuery::getNearestTerrainSample(const Matrix & inverseProjection)
{
  if (!device || !HandleIsValid(queryReadBackBuffer)) return 0.0f;
 
  IContext * context = this->device->getImmediateContext();
 
  const MappedBuffer<float> data(context, queryReadBackBuffer, MapMode::Read);
 
  if (!data) return 0.0f;
 
  float min = std::numeric_limits<float>::max();
  float minX = 0.0f;
  float minY = 0.0f;
 
  auto size = clipmapRenderer->depthQuerySize;
  const int sampleSize = 4; //RGBA
  const int rowPitch = data.getStride() ? data.getStride() / (sizeof(float) * sampleSize) : size;
 
  for (int y = 0; y < size; ++y) {
    for (int x = 0; x < size; ++x) {
      int sampleIndex = (y * rowPitch + x) * sampleSize;
 
      const float depth = data[sampleIndex];
      float clearDepth = 1.0;
      if(clipmapRenderer->reverseDepth)
        clearDepth = 0.0f;
 
      if (depth != clearDepth) {
        const float xPos = data[sampleIndex + 1];
        const float yPos = data[sampleIndex + 2];
 
        if(clipmapRenderer->reverseDepth){
          if (depth > min) {
            min = depth;
            minX = xPos;
            minY = yPos;
          }
        }
        else{
          if (depth < min) {
            min = depth;
            minX = xPos;
            minY = yPos;
          }
        }
      }
    }
  }
 
  const Vector4 screenPos(minX, minY, min, 1);
  Vector4 viewPos;
 
  viewPos = inverseProjection * screenPos;
 
  if (viewPos[3] != 0) {
    viewPos /= viewPos[3];
 
    return -viewPos[2];
  }
 
  return 0;
}
 
float Cogs::ClipmapDepthQuery::getNearestTerrainSample2(const Matrix & inverseProjection, const Matrix & viewMatrix)
{
  if (!device || !HandleIsValid(queryReadBackBuffer)) return 0.0f;
 
  IContext * context = this->device->getImmediateContext();
 
  const MappedBuffer<float> data(context, queryReadBackBuffer, MapMode::Read);
 
  if (!data) return 0.0f;
 
  float min = std::numeric_limits<float>::max();
  float minX = 0.0f;
  float minY = 0.0f;
 
  auto size = clipmapRenderer->depthQuerySize;
  const int sampleSize = 4; //RGBA
  const int rowPitch = data.getStride() ? data.getStride() / (sizeof(float) * sampleSize) : size;
 
  for (int y = 0; y < size; ++y) {
    for (int x = 0; x < size; ++x) {
      int sampleIndex = (y * rowPitch + x) * sampleSize;
 
      float depth = data[sampleIndex];
      float clearDepth = 1.0;
      if(clipmapRenderer->reverseDepth)
        clearDepth = 0.0f;
 
      if (depth != clearDepth) {
        const float xPos = data[sampleIndex + 1];
        const float yPos = data[sampleIndex + 2];
 
        if(clipmapRenderer->reverseDepth){
          if (depth > min) {
            min = depth;
            minX = xPos;
            minY = yPos;
          }
        }
        else{
          if (depth < min) {
            min = depth;
            minX = xPos;
            minY = yPos;
          }
        }
      }
    }
  }
 
  const Vector4 screenPos(minX, minY, min, 1);
  Vector4 viewPos;
 
  viewPos = inverseProjection * screenPos;
 
  float ret = 0.0f;
 
  if (viewPos[3]) {
    viewPos /= viewPos[3];
    ret = -viewPos[2];
  }
 
  if (prevViewPos[3]) {
    prevViewPos = viewMatrix * glm::inverse(prevViewMatrix) * prevViewPos;
    ret = std::min(ret, -prevViewPos[2]);
  }
 
  prevViewPos = viewPos;
  prevViewMatrix = viewMatrix;
 
  return ret;
}