301 lines
13 KiB
C++
301 lines
13 KiB
C++
/* -*-c++-*- */
|
|
/* osgEarth - Geospatial SDK for OpenSceneGraph
|
|
* Copyright 2020 Pelican Mapping
|
|
* http://osgearth.org
|
|
*
|
|
* osgEarth is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
#pragma once
|
|
|
|
#include <osgEarth/Common>
|
|
#include <osgEarth/Config>
|
|
#include <osgEarth/Color>
|
|
#include <osgEarth/CullingUtils>
|
|
#include <osg/LOD>
|
|
|
|
namespace osgEarth
|
|
{
|
|
// Options structure for a terrain engine (internal)
|
|
class OSGEARTH_EXPORT TerrainOptions : public DriverConfigOptions
|
|
{
|
|
public:
|
|
META_ConfigOptions(osgEarth, TerrainOptions, DriverConfigOptions);
|
|
OE_OPTION(int, tileSize, 17);
|
|
OE_OPTION(float, minTileRangeFactor, 7.0f);
|
|
OE_OPTION(bool, clusterCulling, true);
|
|
OE_OPTION(unsigned, maxLOD, 19u);
|
|
OE_OPTION(unsigned, minLOD, 0u);
|
|
OE_OPTION(unsigned, firstLOD, 0u);
|
|
OE_OPTION(bool, enableLighting, true);
|
|
OE_OPTION(bool, enableBlending, true);
|
|
OE_OPTION(bool, compressNormalMaps, false);
|
|
OE_OPTION(unsigned, minNormalMapLOD, 0u);
|
|
OE_OPTION(bool, gpuTessellation, false);
|
|
OE_OPTION(float, tessellationLevel, 2.5f);
|
|
OE_OPTION(float, tessellationRange, 75.0f);
|
|
OE_OPTION(bool, debug, false);
|
|
OE_OPTION(int, renderBinNumber, 0);
|
|
OE_OPTION(unsigned, minExpiryFrames, 0u);
|
|
OE_OPTION(double, minExpiryTime, 0.0);
|
|
OE_OPTION(float, minExpiryRange, 0.0f);
|
|
OE_OPTION(unsigned, maxTilesToUnloadPerFrame, ~0u);
|
|
OE_OPTION(unsigned, minResidentTiles, 0u);
|
|
OE_OPTION(bool, castShadows, false);
|
|
OE_OPTION(LODMethod, lodMethod, LODMethod::CAMERA_DISTANCE);
|
|
OE_OPTION(float, tilePixelSize, 256.0f);
|
|
OE_OPTION(float, heightFieldSkirtRatio, 0.0f);
|
|
OE_OPTION(Color, color, Color::White);
|
|
OE_OPTION(bool, progressive, true);
|
|
OE_OPTION(bool, useNormalMaps, true);
|
|
OE_OPTION(bool, normalizeEdges, false);
|
|
OE_OPTION(bool, morphTerrain, true);
|
|
OE_OPTION(bool, morphImagery, true);
|
|
OE_OPTION(unsigned, mergesPerFrame, ~0u);
|
|
OE_OPTION(float, priorityScale, 1.0f);
|
|
OE_OPTION(std::string, textureCompression, {});
|
|
OE_OPTION(unsigned, concurrency, 4u);
|
|
OE_OPTION(bool, useLandCover, true);
|
|
OE_OPTION(float, screenSpaceError, 0.0f);
|
|
OE_OPTION(unsigned, maxTextureSize, 65536u);
|
|
OE_OPTION(bool, visible, true);
|
|
OE_OPTION(bool, createTilesAsync, true);
|
|
OE_OPTION(bool, createTilesGrouped, true);
|
|
|
|
virtual Config getConfig() const;
|
|
private:
|
|
void fromConfig(const Config&);
|
|
};
|
|
|
|
class OSGEARTH_EXPORT TerrainOptionsAPI
|
|
{
|
|
public:
|
|
//! Size of each dimension of each terrain tile, in verts.
|
|
//! Ideally this will be a power of 2 plus 1, i.e.: a number X
|
|
//! such that X = (2^Y)+1 where Y is an integer >= 1. Default=17.
|
|
void setTileSize(const int& value);
|
|
const int& getTileSize() const;
|
|
|
|
//! The minimum tile LOD range as a factor of a tile's radius. Default = 7.0
|
|
void setMinTileRangeFactor(const float& value);
|
|
const float& getMinTileRangeFactor() const;
|
|
|
|
//! Whether cluster culling is enabled on terrain tiles. Deafult=true
|
|
void setClusterCulling(const bool& value);
|
|
const bool& getClusterCulling() const;
|
|
|
|
//! (Legacy property)
|
|
//! The maximum level of detail to which the terrain should subdivide.
|
|
//! If you leave this unset the terrain will subdivide until the map layers
|
|
//! stop providing data (default behavior). If you set a value, the terrain
|
|
//! will stop subdividing at the specified LOD even if higher-resolution
|
|
//! data is available. (It still might stop subdividing before it reaches
|
|
//! this level if data runs out
|
|
void setMaxLOD(const unsigned& value);
|
|
const unsigned& getMaxLOD() const;
|
|
|
|
//! (Legacy property)
|
|
//! The lowest LOD to display. By default, the terrain begins at LOD 0.
|
|
//! Set this to start the terrain tile mesh at a higher LOD.
|
|
//! Don't set this TOO high though or you will run into memory problems.
|
|
void setFirstLOD(const unsigned& value);
|
|
const unsigned& getFirstLOD() const;
|
|
|
|
//! Whether to explicity enable or disable GL lighting on the map node.
|
|
//! Default = true
|
|
void setEnableLighting(const bool& value);
|
|
const bool& getEnableLighting() const;
|
|
|
|
//! (Legacy property)
|
|
//! Whether to enable blending on the terrain. Default is true.
|
|
void setEnableBlending(const bool& value);
|
|
const bool& getEnableBlending() const;
|
|
|
|
//! (Currently not used)
|
|
//! Minimum level of detail at which to generate elevation-based normal maps,
|
|
//! assuming normal maps have been activated. This mitigates the overhead of
|
|
//! calculating normal maps for very high altitude scenes where they are no
|
|
//! of much use. Default is 0 (zero).
|
|
void setMinNormalMapLOD(const unsigned& value);
|
|
const unsigned& getMinNormalMapLOD() const;
|
|
|
|
//! Whether the terrain engine will be using GPU tessellation shaders.
|
|
//! Even if the terrain option is set to true, the getting will return
|
|
//! false if tessellation shader support is not available.
|
|
void setGPUTessellation(bool value);
|
|
bool getGPUTessellation() const;
|
|
|
|
//! GPU tessellation level
|
|
void setTessellationLevel(const float& value);
|
|
const float& getTessellationLevel() const;
|
|
|
|
//! Maximum range in meters to apply GPU tessellation
|
|
void setTessellationRange(const float& value);
|
|
const float& getTessellationRange() const;
|
|
|
|
//! Render bin number for the terrain
|
|
void setRenderBinNumber(const int& value);
|
|
const int& getRenderBinNumber() const;
|
|
|
|
//! Minimum number of frames before unused terrain data is eligible to expire
|
|
void setMinExpiryFrames(const unsigned& value);
|
|
const unsigned& getMinExpiryFrames() const;
|
|
|
|
//! Minimum time (seconds) before unused terrain data is eligible to expire
|
|
void setMinExpiryTime(const double& value);
|
|
const double& getMinExpiryTime() const;
|
|
|
|
//! Minimun range (distance from camera) beyond which unused terrain data
|
|
//! is eligible to expire
|
|
void setMinExpiryRange(const float& value);
|
|
const float& getMinExpiryRange() const;
|
|
|
|
//! Maximum number of terrain tiles to unload/expire each frame.
|
|
void setMaxTilesToUnloadPerFrame(const unsigned& value);
|
|
const unsigned& getMaxTilesToUnloadPerFrame() const;
|
|
|
|
//! Minimum number of terrain tiles to keep in memory before expiring usused data
|
|
void setMinResidentTiles(const unsigned& value);
|
|
const unsigned& getMinResidentTiles() const;
|
|
|
|
//! Whether the terrain should cast shadows - default is false
|
|
void setCastShadows(const bool& value);
|
|
const bool& getCastShadows() const;
|
|
|
|
//! Mode to use when calculating LOD switching distances.
|
|
//! Choices are TerrainLODMode::CAMERA_DISTANCE (default) or TerrainLODMode::SCREEN_SPACE
|
|
void setLODMethod(const LODMethod& value);
|
|
const LODMethod& getLODMethod() const;
|
|
|
|
//! Size of the tile, in pixels, when using rangeMode = PIXEL_SIZE_ON_SCREEN
|
|
void setTilePixelSize(const float& value);
|
|
const float& getTilePixelSize() const;
|
|
|
|
//! Ratio of skirt height to tile width. The "skirt" is geometry extending
|
|
//! down from the edge of terrain tiles meant to hide cracks between adjacent
|
|
//! levels of detail. Default is 0 (no skirt).
|
|
void setHeightFieldSkirtRatio(const float& value);
|
|
const float& getHeightFieldSkirtRatio() const;
|
|
|
|
//! Color of the untextured globe (where no imagery is displayed) (default is white)
|
|
void setColor(const Color& value);
|
|
const Color& getColor() const;
|
|
|
|
//! Whether to load levels of details one after the other, instead of
|
|
//! prioritizing them based on the camera position. (default = false)
|
|
void setProgressive(const bool& value);
|
|
const bool& getProgressive() const;
|
|
|
|
//! Whether to generate normal map textures. Default is true
|
|
void setUseNormalMaps(const bool& value);
|
|
const bool& getUseNormalMaps() const;
|
|
|
|
//! Whether to include landcover textures. Default is true.
|
|
void setUseLandCover(const bool& value);
|
|
const bool& getUseLandCover() const;
|
|
|
|
//! Whether to average normal vectors on tile boundaries. Doing so reduces the
|
|
//! the appearance of seams when using lighting, but requires extra CPU work.
|
|
void setNormalizeEdges(const bool& value);
|
|
const bool& getNormalizeEdges() const;
|
|
|
|
//! Whether to morph terrain data between terrain tile LODs.
|
|
//! This feature is not available when rangeMode is PIXEL_SIZE_ON_SCREEN
|
|
void setMorphTerrain(const bool& value);
|
|
const bool& getMorphTerrain() const;
|
|
|
|
//! Whether to morph imagery between terrain tile LODs.
|
|
//! This feature is not available when rangeMode is PIXEL_SIZE_ON_SCREEN
|
|
void setMorphImagery(const bool& value);
|
|
const bool& getMorphImagery() const;
|
|
|
|
//! Maximum number of tile data merges permitted per frame. 0 = infinity.
|
|
void setMergesPerFrame(const unsigned& value);
|
|
const unsigned& getMergesPerFrame() const;
|
|
|
|
//! Texture compression to use by default on terrain image textures
|
|
void setTextureCompressionMethod(const std::string& method);
|
|
const std::string& getTextureCompressionMethod() const;
|
|
|
|
//! Target concurrency of terrain data loading operations. Default = 4.
|
|
void setConcurrency(const unsigned& value);
|
|
const unsigned& getConcurrency() const;
|
|
|
|
//! Screen space error for PIXEL SIZE ON SCREEN LOD mode
|
|
void setScreenSpaceError(const float& value);
|
|
const float& getScreenSpaceError() const;
|
|
|
|
//! Sets a maximum size for textures used by the terrain
|
|
void setMaxTextureSize(const unsigned& value);
|
|
const unsigned& getMaxTextureSize() const;
|
|
|
|
//! Whether to render the terrain
|
|
void setVisible(const bool& value);
|
|
const bool& getVisible() const;
|
|
|
|
//! Whether the engine should create child tiles asynchronously
|
|
void setCreateTilesAsync(const bool& value);
|
|
const bool& getCreateTilesAsync() const;
|
|
|
|
//! Whether the engine should create all child tiles in a group
|
|
void setCreateTilesGrouped(const bool& value);
|
|
const bool& getCreateTilesGrouped() const;
|
|
|
|
//! @deprecated
|
|
//! Scale factor for background loading priority of terrain tiles.
|
|
//! Default = 1.0. Make it higher to prioritize terrain loading over
|
|
//! other modules.
|
|
void setPriorityScale(const float& value);
|
|
const float& getPriorityScale() const;
|
|
|
|
//! @deprecated
|
|
//! Whether to activate debugging mode
|
|
void setDebug(const bool& value);
|
|
const bool& getDebug() const;
|
|
|
|
//! @deprecated
|
|
//! Whether to compress the normal maps before sending to the GPU
|
|
void setCompressNormalMaps(const bool& value);
|
|
const bool& getCompressNormalMaps() const;
|
|
|
|
//! @deprecated
|
|
//! The minimum level of detail to which the terrain should subdivide (no matter what).
|
|
//! If you leave this unset, the terrain will subdivide until the map layers
|
|
//! stop providing data (default behavior). If you set a value, the terrain will subdivide
|
|
//! to the specified LOD no matter what (and may continue farther if higher-resolution
|
|
//! data is available).
|
|
void setMinLOD(const unsigned& value);
|
|
const unsigned& getMinLOD() const;
|
|
|
|
TerrainOptionsAPI();
|
|
TerrainOptionsAPI(TerrainOptions*);
|
|
TerrainOptionsAPI(const TerrainOptionsAPI&);
|
|
|
|
public: // Legacy support
|
|
|
|
//! Sets the name of the terrain engine driver to use
|
|
void setDriver(const std::string& name);
|
|
|
|
private:
|
|
friend class MapNode;
|
|
friend class TerrainEngineNode;
|
|
TerrainOptions* _ptr;
|
|
TerrainOptions& options() { return *_ptr; }
|
|
const TerrainOptions& options() const { return *_ptr; }
|
|
};
|
|
|
|
} // namespace osgEarth
|