RenderContext.h

#pragma once
 
#include "ClipmapTerrainTypes.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include <functional>
#include <vector>
 
namespace
{
  glm::vec2 quadVertices[] = {
    { 0.0f, 0.0f },
    { 1.0f, 0.0f },
    { 1.0f, 1.0f },
 
    { 0.0f, 0.0f },
    { 1.0f, 1.0f },
    { 0.0f, 1.0f }
  };
}
 
namespace Cogs
{
  struct UpdateOptions
  {
    bool enableUpdate = true;
    bool enableCulling = true;
 
    bool invalidateNormals = false;
  };
 
  struct CenterCalculationPolicy
  {
    enum ECenterCalculationPolicy
    {
      TerrainProjected,
      Projected,
      Vertical
    };
  };
  struct WorldOptions
  {
    float heightExaggeration = 1.0f;
 
    Vector4d worldScale = Vector4d(1, 1, 1, 1);
 
    bool enableNoData = false;
 
    CenterCalculationPolicy::ECenterCalculationPolicy centerPolicy = CenterCalculationPolicy::Vertical;
  };
 
  struct OceanOptions
  {
    Vector4 shallowColor = Vector4(0.15f, 0.28f, 0.35f, 0.9f);
    Vector4 deepColor = Vector4(0.1f, 0.2f, 0.3f, 0.95f);
    Vector4 roughColor = Vector4(0.15f, 0.35f, 0.28f, 0.95f);
 
    float worldSpaceMeter = 1.f;          //< Size of one meter in world space.
    float baseTileLength = 500;           //< Side-length of base tile in meters.
    int   baseTileSizeLog2 = 8;           //< Number of samples along side of tile.
    float significantWaveHeight = 2.f;    //< Significant wave height of spectrum, in meters. 
    float significantWavePeriod = 6.f;    //< Significant wave period of spectrum, in seconds.
    float swellDirection = 0.f;           //< Direction of waves, zero implies waves that arrive from positive X.
    float shoale = 0.f;                   //< Depth at which shoaling of waves start, in world space units.
    float roughness = 0.f;                //< How rough the sea should appear to be, value between 0.0 and 1.0.
    float detailFactor = 9.13f;
 
    float foamDetectionScale = 0.1f;
    float foamErosionValue = 2.f;
    float shoalingEffectFactor = 0.f;
 
    float lodDisplaceStart = 2.f;
    float lodDisplaceTransition = 1.f;
    float lodNormalStart = 0.01f;
    float lodNormalTransition = 2.5f;
 
    float lodDetailStart = 25.f;
    float lodDetailTransition = 150.f;
    float lodFoamStart = 0.75f;
    float lodFoamTransition = 0.3f;
 
    bool enableImagery = true;
  };
 
  struct RenderOptions
  {
    bool showImagery = true;
    bool showBlendRegions = false;
 
    bool enableBlending = true;
 
    bool showLevelColors = false;
 
    Vector4 blendRegionColor = Vector4(0, 0, 1, 1);
    Vector4 diffuseColor = Vector4(0.4f, 0.5f, 0.4f, 1);
 
    float lodBias = 0.0f;
 
    bool enableMipMapping = false;
 
    bool enableCulling = true;
  };
 
  struct DebugOptions
  {
    bool showDepthBuffer = false;
    bool showHeightMaps = false;
    bool showTextures = false;
 
    Vector2 textureOverlaySize = Vector2(256, 256);
  };
 
  struct TerrainRenderPass
  {
    enum ETerrainRenderPass
    {
      Main = 0,
      Reflection,
      Refraction,
      Other
    };
  };
 
  struct PermutationDependentRenderContextData
  {
    EffectHandle clipmapEffect;
    EffectHandle clipmapDepthEffect;
 
    EffectHandle oceanEffect;
  };
 
  struct RenderContext
  {
    PermutationDependentRenderContextData & getPermutationDependentRenderContextData(const size_t index)
    {
      if (permutationDependentRenderContextData.size() <= index)
        permutationDependentRenderContextData.resize(index + 4);
 
      return permutationDependentRenderContextData[index];
    }
 
    IGraphicsDevice * device;
    IContext * context;
 
    RenderTargetHandle renderTarget;
    DepthStencilHandle depthStencilTarget;
 
    TerrainRenderPass::ETerrainRenderPass renderPass = TerrainRenderPass::Main;
 
    uint16_t viewportX;
    uint16_t viewportY;
 
    uint16_t width;
    uint16_t height;
 
    bool wireframe = false;
 
    size_t maxAppliedTilesPerFrame = 2;
 
    Vector3d origin;
    Vector3d center;
    Vector3 sampleCenter;
    Vector3d sampleOrigin;
    Vector3d sampleCameraCenter;
    float distance;
    bool initialized = false;
 
    // Offset to apply to terrain extents, in world coordinates.
    Vector3d offset;
 
    struct Scene
    {
      Matrix viewMatrix;
      Matrix projectionMatrix;
      Matrix viewMatrixInverse;
    } scene;
 
    Vector3d cullOrigin;
    ViewVolume cullVolume;
 
    size_t permutation = 0;
    bool isOIT = false;
 
    std::function<void(EffectHandle)> callback;
 
    bool offsetEnabled;
 
    bool oceanEnabled;
 
    bool reverseDepth = false;
 
    std::function<void(EffectHandle)> oceanCallback;
 
    int rayPickIndex = -1;
 
  private:
    std::vector<PermutationDependentRenderContextData> permutationDependentRenderContextData;
  };
 
  struct EffectParameters
  {
    bool changed = false;
    int numTextures;
    int numActiveImagery;
    bool precomputeNormals = false;
  };
}