ClipmapParameterCalculation.h

#pragma once
 
#include "ClipmapTerrainTypes.h"
 
#include "ClipmapState.h"
#include "ClipmapLevel.h"
#include "ClipmapRenderer.h"
#include "Raster/RasterLevel.h"
 
namespace Cogs
{
  inline Vector2 calculateViewPosInClippedLevel(const ClipmapState & clipmapState, const ClipmapLevel & terrainLevel)
  {
    return Vector2(
      static_cast<float>(terrainLevel.rasterLevel->longitudeToIndex(clipmapState.clipmapCenter.x) - terrainLevel.currentExtent.west),
      static_cast<float>(terrainLevel.rasterLevel->latitudeToIndex(clipmapState.clipmapCenter.y) - terrainLevel.currentExtent.south));
  }
 
  static Vector2 calculateScaleFactor(const int levelIndex)
  {
    const float levelScaleFactor = std::exp2(static_cast<float>(-levelIndex));
 
    return Vector2(levelScaleFactor, levelScaleFactor);
  }
 
  static Vector2 calculateResolutionRatio(const ClipmapLevel & a, const ClipmapLevel & b)
  {
    return Vector2(
      static_cast<float>(a.rasterLevel->getPostDeltaLongitude() / b.rasterLevel->getPostDeltaLongitude()),
      static_cast<float>(a.rasterLevel->getPostDeltaLatitude() / b.rasterLevel->getPostDeltaLatitude())
      );
  }
 
  namespace
  {
    template<typename InputVector>
    Vector4 pad3to4(const InputVector in)
    {
      Vector4 out(in[0], in[1], in[2], 0);
 
      return out;
    }
 
    template<typename InputVector>
    vec2a pad2to4(const InputVector in)
    {
      vec2a out(in[0], in[1]);
 
      return out;
    }
  }
 
  inline void calculateLevelParameters(
    const ClipmapLevel & terrainLevel,
    const std::vector<const ClipmapLevel *> & imageryLevels,
    LevelParameters & parameters,
    ImageryParameters & imageryParameters,
    const Vector3d center,
    const bool /*enableNoData*/)
  {
    const ClipmapLevel & coarserLevel = *terrainLevel.coarserLevel;
 
    const int west = terrainLevel.currentExtent.west;
    const int south = terrainLevel.currentExtent.south;
 
    // Converts raster space coordinates [0, extent] to texture coordinates [0, 1].
    const float reciprocalX = 1.0f / static_cast<float>(terrainLevel.nextExtent.getWidth());
    const float reciprocalY = 1.0f / static_cast<float>(terrainLevel.nextExtent.getHeight());
 
    parameters.oneOverClipmapSize = Vector2(reciprocalX, reciprocalY);
 
    // Converts coarse raster space coordinates [0, extent] to coarse texture coordinates [0, 1].
    const float coarseReciprocalX = 1.0f / static_cast<float>(coarserLevel.nextExtent.getWidth());
    const float coarseReciprocalY = 1.0f / static_cast<float>(coarserLevel.nextExtent.getHeight());
 
    parameters.oneOverCoarseClipmapSize = Vector2(coarseReciprocalX, coarseReciprocalY);
 
    // Translates level raster coordinates to be relative to the clipmap center.
    parameters.levelOffsetFromClipmapCenter = Vector2(west - terrainLevel.rasterLevel->longitudeToIndex(center.x),
      south - terrainLevel.rasterLevel->latitudeToIndex(center.y));
    
    // Scales raster coordinates to the raster coordinates of the least detailed level.
    parameters.levelScaleFactor = calculateScaleFactor(static_cast<int>(terrainLevel.index));
 
    // See ClipmapSampling.hlsl
    Vector2 texelOffset = Vector2(0.5f, 0.5f);
 
    // Translates level raster coordinates to texture raster coordinates relative to the origin.
    parameters.fineTextureOrigin = Vector2(static_cast<float>(terrainLevel.origin.x), static_cast<float>(terrainLevel.origin.y)) + texelOffset;
 
    const auto fineToCoarseRatio = calculateResolutionRatio(terrainLevel, coarserLevel);
 
    parameters.fineToCoarseRatio = fineToCoarseRatio;
 
    // Represents the origin of the fine level in the raster coordinate system of the coarser level.
    const int coarserWest = coarserLevel.currentExtent.west;
    const int coarserSouth = coarserLevel.currentExtent.south;
    parameters.fineLevelOriginInCoarse = Vector2(
      static_cast<float>(coarserLevel.origin.x),
      static_cast<float>(coarserLevel.origin.y)) +
      Vector2(
      static_cast<float>(west) * fineToCoarseRatio.x - static_cast<float>(coarserWest),
      static_cast<float>(south) * fineToCoarseRatio.y - static_cast<float>(coarserSouth)) + texelOffset;
 
    for (size_t i = 0; i < imageryLevels.size(); ++i) {
      const ClipmapLevel & imageryLevel = *imageryLevels[i];
      const ClipmapLevel & coarserImageryLevel = *imageryLevel.coarserLevel;
 
      imageryParameters.terrainToImageryResolutionRatio[i] = pad2to4(calculateResolutionRatio(terrainLevel, imageryLevel));
 
      const double terrainWest = terrainLevel.rasterLevel->indexToLongitude(west);
      const double terrainSouth = terrainLevel.rasterLevel->indexToLatitude(south);
      const double imageryWestIndex = imageryLevel.rasterLevel->longitudeToIndex(terrainWest);
      const double imagerySouthIndex = imageryLevel.rasterLevel->latitudeToIndex(terrainSouth);
 
      imageryParameters.terrainOffsetInImagery[i] = pad2to4(Vector2(
        static_cast<float>(imageryLevel.origin.x),
        static_cast<float>(imageryLevel.origin.y)) +
        Vector2(
        static_cast<float>(imageryWestIndex - imageryLevel.currentExtent.west),
        static_cast<float>(imagerySouthIndex - imageryLevel.currentExtent.south)));
 
      const auto fineToCoarseImageryRatio = pad2to4(calculateResolutionRatio(imageryLevel, coarserImageryLevel));
 
      imageryParameters.fineToCoarseImageryResolutionRatio[i] = fineToCoarseImageryRatio;
 
      const int coarserImageryWest = coarserImageryLevel.currentExtent.west;
      const int coarserImagerySouth = coarserImageryLevel.currentExtent.south;
      imageryParameters.fineImageryOriginInCoarse[i] = pad2to4(Vector2(
        static_cast<float>(coarserImageryLevel.origin.x),
        static_cast<float>(coarserImageryLevel.origin.y)) +
        Vector2(
        imageryLevel.currentExtent.west * fineToCoarseImageryRatio.x - coarserImageryWest,
        imageryLevel.currentExtent.south * fineToCoarseImageryRatio.y - coarserImagerySouth));
 
      imageryParameters.oneOverImagerySize[i] = pad2to4(Vector2(
        1.0f / static_cast<float>(imageryLevel.currentExtent.getWidth()),
        1.0f / static_cast<float>(imageryLevel.currentExtent.getHeight())));
 
      imageryParameters.oneOverCoarseImagerySize[i] = pad2to4(Vector2(
        1.0f / static_cast<float>(coarserImageryLevel.currentExtent.getWidth()),
        1.0f / static_cast<float>(coarserImageryLevel.currentExtent.getHeight())));
 
      imageryParameters.noData[i] = imageryLevel.rasterLevel->getNoData();
    }
  }
 
  inline void calculateGlobalParameters(const ClipmapLevel & levelZero, const RenderContext & renderContext, const WorldOptions & worldOptions, const ClipmapState & clipmapState, GlobalParameters & globalParameters)
  {
    auto rasterLevel = levelZero.rasterLevel;
    auto & extent = levelZero.nextExtent;
 
    globalParameters.noClipmapData = rasterLevel->getNoData();
 
    // Scales raster coordinates from the least detailed level to geo-coordinates relative to the clipmap center.
    globalParameters.levelZeroWorldScaleFactor = Vector2(rasterLevel->getPostDeltaLongitude(), rasterLevel->getPostDeltaLatitude());
 
    auto & worldScale = worldOptions.worldScale;
 
    // Scales clipmap geo-coordinates to world coordinates. Serves as a simplified reprojection e.g from degrees to meters.
    globalParameters.worldScale = Vector4(worldScale);
 
    // Distance of scaled terrain coordinate system origin from global origin.
    auto offsetFromOrigin = Vector2d(renderContext.origin) - Vector2d(renderContext.offset);
 
    // Translates world coordinates from local to origin space.
    globalParameters.centerOffsetFromOrigin = Vector2(Vector2d(renderContext.center) - offsetFromOrigin);
 
    // Calculate the extent of the entire terrain relative to the current origin.
    auto & geodeticExtent = levelZero.rasterLevel->getGeoExtent();
    globalParameters.worldExtents = Vector4(
      Vector2d(geodeticExtent.getWest(), geodeticExtent.getSouth()) * Vector2d(worldScale) - offsetFromOrigin,
      Vector2d(geodeticExtent.getEast(), geodeticExtent.getNorth()) * Vector2d(worldScale) - offsetFromOrigin
    );
 
    // Calculate the extent of the clipmap level pyramid relative to the current origin.
    globalParameters.clipmapExtents = Vector4(
      Vector2d(rasterLevel->indexToLongitude(extent.west), rasterLevel->indexToLatitude(extent.south)) * Vector2d(worldScale) - offsetFromOrigin,
      Vector2d(rasterLevel->indexToLongitude(extent.east), rasterLevel->indexToLatitude(extent.north)) * Vector2d(worldScale) - offsetFromOrigin
    );
 
    globalParameters.unblendedRegionSize = Vector2(clipmapState.unblendedRegionSize, clipmapState.unblendedRegionSize);
    globalParameters.oneOverBlendedRegionSize = Vector2(clipmapState.oneOverBlendedRegionSize, clipmapState.oneOverBlendedRegionSize);
 
    globalParameters.heightExaggeration = worldOptions.heightExaggeration;
 
    // The xy offset is included in the centerOffsetFromOrigin value.
    globalParameters.worldOffset = Vector4(0, 0, renderContext.offset.z, 1);
 
    globalParameters.enableNoData = worldOptions.enableNoData;
  }
}