ClipmapManager.h

#pragma once
 
#include "ClipmapUpdater.h"
#include "NormalUpdater.h"
 
#include "ClipmapGeometry.h"
#include "ClipmapState.h"
#include "ClipmapLevel.h"
 
#include "ClipmapRenderer.h"
#include "ClipmapDepthQuery.h"
 
#include "OceanRenderer.h"
 
#include "Raster/RasterSourceSubscription.h"
 
namespace Cogs
{
  class ClipmapManager
  {
  public:
    ClipmapManager();
    ~ClipmapManager();
 
    void setRasterSources(const RasterSourcePtr & terrainSource, const std::vector<RasterSourcePtr> & imagerySources);
    void setClipmapParameters(const ClipmapParameters * clipmapParameters);
    void setCustomParameters(const unsigned char * data, int count);
 
    void initialize(IGraphicsDevice * device);
    void updateSharedDevice(IGraphicsDevice * device);
    void initializeGeometry();
    void initializeLevels();
    void initializeBackgroundLevels();
    void cleanupLevels();
    void detachResponseHandlers();
 
    void update();
    size_t preRender(RenderContext & renderContext);
 
    void renderDepth(RenderContext & renderContext, size_t maxLevel);
    void render(RenderContext & renderContext, size_t maxLevel);
    void renderOcean(RenderContext & renderContext, size_t maxLevel);
 
    void postRender(RenderContext & renderContext);
    void renderDebugOverlays(RenderContext & renderContext);
 
    void getTerrainMetrics(TerrainMetrics * metrics) const;
    
    void invalidateRasterSource(RasterSource * rasterSource, bool clearContents);
    void invalidateTile(RasterSource * rasterSource, const RasterTileIdentifier & id);
 
    bool updateRequired() const { return needsUpdate; }
 
    bool isInitialized() const { return initialized; }
 
    float getNearestSample();
 
    WorldOptions worldOptions;
    UpdateOptions updateOptions;
    RenderOptions renderOptions;
    DebugOptions debugOptions;
 
    bool effectsNeedUpdate = false;
 
    RenderContext previousContext;
 
    ClipmapRenderer clipmapRenderer;
    ClipmapDepthQuery depthQuery;
 
    OceanRenderer oceanRenderer;
    bool oceanActive = false;
 
    std::vector<ClipmapLevel> terrainLevels;
    std::vector<std::vector<ClipmapLevel>> imagery;
    std::vector<ClipmapLevel> normalLevels;
 
    ClipmapLevel backgroundLevel;
    std::vector<ClipmapLevel> backgroundImagery;
    ClipmapLevel backgroundNormalLevel;
    bool backgroundNeedsUpdate = false;
 
    std::vector<bool> imageryEnabled;
 
    ClipmapGeometry clipmapGeometry;
    bool geometryNeedsUpdate = true;
 
    RasterSourceSubscription terrainSource;
    std::vector<RasterSourceSubscription> imagerySources;
    bool sourcesNeedUpdate = false;
 
    ClipmapParameters parameters;
 
  private:
    size_t calculateCenterAndMaxLevel(RenderContext & renderContext);
    void updateOriginInTextures(ClipmapLevel & level);
    void requestTileLoads(RenderContext & renderContext, const size_t maxLevel);
 
    void updateClipmapLevels(RenderContext & renderContext, const WorldOptions & worldOptions, const size_t maxLevel);
    void updateClipmapLevel(RenderContext & renderContext, const WorldOptions & worldOptions, ClipmapLevel & level, ClipmapLevel & coarserLevel, bool normal);
    
    void updateBackgroundLevel(RenderContext & renderContext, const WorldOptions & worldOptions);
 
    void preloadLevelZeroTiles();
 
    void updateMipmaps(size_t maxLevel, IGraphicsDevice * device);
 
    void touch() { needsUpdate = true; }
 
    void clearLevels(RasterSource * rasterSource, bool clearContents);
 
    RenderTexture createTexture(const size_t width, const size_t height, const TextureFormat textureFormat, const bool mipmapping = false, glm::vec4 clearColor = glm::vec4(0, 0, 0, 0));
    void destroyTexture(RenderTexture & texture);
 
    IGraphicsDevice * device = nullptr;
 
    ClipmapUpdater updater;
    NormalUpdater normalUpdater;
    
    ClipmapState clipmapState;
 
    TerrainMetrics metrics = {};
 
    int missingTileRegions = 1;
    std::vector<size_t> missingImageryTileRegions;
 
    size_t lastMaxLevel = 0;
    bool needsUpdate = false;
 
    bool initialized = false;
    float nearestSample = 0;
    bool first = true;
  };
}