ClipmapRenderer.h

#pragma once
 
#include "RenderContext.h"
#include "RenderTexture.h"
#include "RenderBlock.h"
 
#include "ClipmapEffectVariables.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
#include "Rendering/IBuffers.h"
 
namespace Cogs
{
  struct ClipmapState;
  struct ClipmapGeometry;
  struct ClipmapMesh;
 
  class ClipmapLevel;
 
  struct GlobalParameters;
  struct LevelParameters;
  struct ImageryParameters;
 
  struct IRenderTargets;
 
  RenderTexture createClipmapTexture(IGraphicsDevice * device, int width, int height, TextureFormat textureFormat, bool mipmap = false, glm::vec4 clearColor = glm::vec4(0));
  void releaseClipmapTexture(IGraphicsDevice * device, RenderTexture & texture);
  void clearClipmapTexture(IGraphicsDevice * device, RenderTexture & texture);
 
  struct DepthRenderData
  {
    TextureHandle depthTextureHandle;
    int width;
    int height;
    bool depthRenderInitialized = false;
    RenderTargetHandle depthRenderHandle;
    DepthStencilHandle depthTargetHandle;
    BufferHandle readbackBufferHandle = BufferHandle::NoHandle;
 
    void initialize(IGraphicsDevice * device, int width, int height);
    void cleanup(IGraphicsDevice * device);
  };
 
  struct PermutationDependentClipmapRendererData
  {
    bool initialized = false;
    ClipmapEffectVariables effectVariables;
    ClipmapEffectVariables depthEffectVariables;
 
    ClipmapTextureBindings effectBindings;
    ClipmapTextureBindings depthEffectBindings;
    EffectHandle clipmapEffect;
    EffectHandle clipmapDepthEffect;
  };
 
  struct ClipmapRenderer
  {
    void initializeTextures(ITextures * textures);
    void initializeEffects(IBuffers * buffers, IEffects * effects, const size_t numImagery, size_t permutation);
    void initializeConstantBuffers(IBuffers * buffers, ClipmapEffectVariables & variables);
    void initializeEffectVariables(IEffects * effects, EffectHandle effect, ClipmapEffectVariables & variables, const size_t numImagery, bool isDepth);
    void initializeEffectBindings(IEffects * effects, EffectHandle effect, ClipmapTextureBindings & bindings, const size_t numImagery, bool isDepth);
    void initializeRasterizerStates(IRenderTargets * renderTargets);
    void initializeRenderTargets(IRenderTargets * renderTargets);
 
    void cleanup(IGraphicsDevice * device);
 
    void updateGlobalParameters(const RenderContext & context, const RenderOptions & renderOptions, const ClipmapState & clipmapState, const GlobalParameters & globalParameters);
    void updateLevelParameters(IContext * context, const RenderOptions & options, const LevelParameters & parameters, const ImageryParameters & imageryParameters, size_t permutation);
    void updateLevelTextures(IContext * context, const RenderLevel * renderLevel, size_t permutation);
 
    void setCustomParameters(const unsigned char * data, int count);
 
    void initLevels();
 
    bool createRenderLevel(ClipmapGeometry & clipmapGeometry,
      ClipmapState & clipmapState,
      ClipmapLevel & terrainLevel,
      std::vector<std::vector<ClipmapLevel>> &,
      ClipmapLevel * normalLevel,
      const GlobalParameters & globalParameters,
      const LevelParameters & parameters,
      const ImageryParameters & imageryParameters,
      bool fillRing,
      bool select = false);
 
    bool createBackgroundRenderLevel(ClipmapGeometry & clipmapGeometry,
      ClipmapState & clipmapState,
      ClipmapLevel & terrainLevel,
      std::vector<std::vector<ClipmapLevel>> &,
      ClipmapLevel * normalLevel,
      const GlobalParameters & globalParameters,
      const LevelParameters & parameters,
      const ImageryParameters & imageryParameters,
      bool useSimplifiedMesh = false);
 
    void setupDepthPass(RenderContext & renderContext, size_t depthDataIndex);
    void setupDepthQueryPass(RenderContext & renderContext);
    void setupRegularPass(RenderContext & renderContext);
 
    void render(RenderContext & renderContext, const RenderOptions & renderOptions, const WorldOptions & worldOptions, bool usePreviousCullingResults = false);
 
    void createBlock(ClipmapMesh & mesh, int overallWest, int overallSouth, int blockWest, int blockSouth, RenderLevel & renderLevel, bool useSimplifiedMesh = false);
    void drawBlock(const RenderBlock & renderBlock, RenderContext & renderContext);
 
    PermutationDependentClipmapRendererData & getPermutationDependentClipmapRendererData(const size_t index)
    {
      if (permutationDependentClipmapRendererData.size() <= index) {
        permutationDependentClipmapRendererData.resize(index + 4);
      }
 
      return permutationDependentClipmapRendererData[index];
    }
 
    bool depthPass;
 
    SamplerStateHandle pointSamplerState;
    SamplerStateHandle linearSamplerState;
 
    RasterizerStateHandle solidRasterizerState;
    RasterizerStateHandle solidNoDepthClipRasterizerState;
    RasterizerStateHandle solidOffsetRasterizerState;
    RasterizerStateHandle wireframeRasterizerState;
 
    DepthStencilStateHandle solidDepthState;
    DepthStencilStateHandle wireframeDepthState;
    DepthStencilStateHandle transparentDepthState;
    DepthStencilStateHandle transparentWireframeDepthState;
 
    InputLayoutHandle inputLayout;
    BufferHandle customParametersBuffer;
 
    // One per "raypick camera":
    std::vector<DepthRenderData> raypickDepthData;
    const static int NoPickIndex = -1;
    const static int DefaultPickIndex = 0;
 
    TextureHandle depthQueryTextureHandle;
 
    int depthQuerySize;
    RenderTargetHandle depthQueryRenderHandle;
    DepthStencilHandle depthQueryTargetHandle;
    bool depthQueryRenderInitialized = false;
 
    bool reverseDepth = false;
 
    std::vector<unsigned char> customParameters;
 
    RenderLevel levels[kMaxNumLevels];
    size_t levelIndex;
    bool visibleBlocks[Cogs::kMaxNumBlocks * Cogs::kMaxNumLevels];
 
    struct ClipmapGeometry * geometry;
 
  private:
    std::vector<PermutationDependentClipmapRendererData> permutationDependentClipmapRendererData;
  };
}