mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-03 18:19:38 -06:00
Code Issues Packages Projects Releases Wiki Activity

TileProviderManager -> LayerManager. Fix shader recompilation bug

Browse Source
This commit is contained in:
Erik Broberg
2016-10-19 16:08:26 +02:00
parent 0d02844982
commit ee9bb36a06
14 changed files with 67 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
modules/globebrowsing/CMakeLists.txt
View File

@@ -63,7 +63,7 @@ set(HEADER_FILES
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledepthtransform.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileioresult.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/layermanager.h
${CMAKE_CURRENT_SOURCE_DIR}/tile/pixelregion.h
${CMAKE_CURRENT_SOURCE_DIR}/layered_rendering/layeredtextureshaderprovider.h
@@ -118,7 +118,7 @@ set(SOURCE_FILES
${CMAKE_CURRENT_SOURCE_DIR}/tile/tiledatatype.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileioresult.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/layermanager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tile/pixelregion.cpp
${CMAKE_CURRENT_SOURCE_DIR}/layer/layer.cpp

6
modules/globebrowsing/chunk/chunk.cpp
View File

@@ -101,14 +101,14 @@ namespace globebrowsing {
// In the future, this should be abstracted away and more easily queryable.
// One must also handle how to sample pick one out of multiplte heightmaps
auto tileProviderManager = owner().chunkedLodGlobe()->getTileProviderManager();
auto layerManager = owner().chunkedLodGlobe()->layerManager();
auto heightMapProviders = tileProviderManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
auto heightMapProviders = layerManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
size_t HEIGHT_CHANNEL = 0;
const LayerGroup& heightmaps = tileProviderManager->layerGroup(LayeredTextures::HeightMaps);
const LayerGroup& heightmaps = layerManager->layerGroup(LayeredTextures::HeightMaps);
std::vector<ChunkTile> tiles = TileSelector::getTilesSortedByHighestResolution(heightmaps, _tileIndex);
bool lastHadMissingData = true;
for (auto tile : tiles) {

2
modules/globebrowsing/chunk/chunklevelevaluator.cpp
View File

@@ -162,7 +162,7 @@ namespace globebrowsing {
}
int EvaluateChunkLevelByAvailableTileData::getDesiredLevel(const Chunk& chunk, const RenderData& data) const {
auto tileProvidermanager = chunk.owner().chunkedLodGlobe()->getTileProviderManager();
auto tileProvidermanager = chunk.owner().chunkedLodGlobe()->layerManager();
auto heightLayers = tileProvidermanager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
int currLevel = chunk.tileIndex().level;

29
modules/globebrowsing/chunk/chunkrenderer.cpp
View File

@@ -27,7 +27,7 @@
#include <modules/globebrowsing/globes/chunkedlodglobe.h>
#include <modules/globebrowsing/globes/renderableglobe.h>
#include <modules/globebrowsing/layered_rendering/layeredtextures.h>
#include <modules/globebrowsing/tile/tileprovidermanager.h>
#include <modules/globebrowsing/tile/layermanager.h>
// open space includes
#include <openspace/engine/wrapper/windowwrapper.h>
@@ -60,8 +60,8 @@ namespace globebrowsing {
ChunkRenderer::ChunkRenderer(
std::shared_ptr<Grid> grid,
std::shared_ptr<TileProviderManager> tileProviderManager)
: _tileProviderManager(tileProviderManager)
std::shared_ptr<LayerManager> layerManager)
: _layerManager(layerManager)
, _grid(grid)
{
_globalRenderingShaderProvider = std::make_shared<LayeredTextureShaderProvider>(
@@ -186,7 +186,7 @@ namespace globebrowsing {
category++) {
LayeredTextureInfo layeredTextureInfo;
auto layerGroup = _tileProviderManager->layerGroup(category);
auto layerGroup = _layerManager->layerGroup(category);
layeredTextureInfo.lastLayerIdx = layerGroup.activeLayers().size() - 1;
layeredTextureInfo.layerBlendingEnabled = layerGroup.levelBlendingEnabled;
@@ -241,16 +241,15 @@ namespace globebrowsing {
};
std::array<std::vector<BlendTexUnits>, LayeredTextures::NUM_TEXTURE_CATEGORIES> texUnits;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
auto layerGroup = _tileProviderManager->layerGroup(category);
texUnits[category].resize(layerGroup.activeLayers().size());
size_t activeLayers = _layerManager->layerGroup(category).activeLayers().size();
texUnits[category].resize(activeLayers);
}
// Go through all the categories
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
// Go through all the providers in this category
const auto& layers = _tileProviderManager->layerGroup(category).activeLayers();
int i = 0;
for (const Layer& layer : layers) {
for (const Layer& layer : _layerManager->layerGroup(category).activeLayers()) {
TileProvider* tileProvider = layer.tileProvider.get();
// Get the texture that should be used for rendering
ChunkTile chunkTile = TileSelector::getHighestResolutionTile(tileProvider, tileIndex);
@@ -316,7 +315,7 @@ namespace globebrowsing {
// Go through all the height maps and set depth tranforms
int i = 0;
const auto& heightLayers = _tileProviderManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
const auto& heightLayers = _layerManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
for (const Layer& heightLayer : heightLayers) {
TileDepthTransform depthTransform = heightLayer.tileProvider->depthTransform();
@@ -356,7 +355,7 @@ namespace globebrowsing {
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
const LayerGroup& layerGroup = _tileProviderManager->layerGroup(i);
const LayerGroup& layerGroup = _layerManager->layerGroup(i);
if(layerGroup.levelBlendingEnabled && layerGroup.activeLayers().size() > 0){
performAnyBlending = true;
break;
@@ -389,9 +388,9 @@ namespace globebrowsing {
programObject->setUniform("lonLatScalingFactor", vec2(patchSize.toLonLatVec2()));
programObject->setUniform("radiiSquared", vec3(ellipsoid.radiiSquared()));
if (_tileProviderManager->layerGroup(
if (_layerManager->layerGroup(
LayeredTextures::NightTextures).activeLayers().size() > 0 ||
_tileProviderManager->layerGroup(
_layerManager->layerGroup(
LayeredTextures::WaterMasks).activeLayers().size() > 0 ||
chunk.owner().generalProperties().atmosphereEnabled ||
chunk.owner().generalProperties().performShading) {
@@ -436,7 +435,7 @@ namespace globebrowsing {
bool performAnyBlending = false;
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
LayeredTextures::TextureCategory category = (LayeredTextures::TextureCategory)i;
if (_tileProviderManager->layerGroup(i).levelBlendingEnabled && _tileProviderManager->layerGroup(category).activeLayers().size() > 0) {
if (_layerManager->layerGroup(i).levelBlendingEnabled && _layerManager->layerGroup(category).activeLayers().size() > 0) {
performAnyBlending = true;
break;
}
@@ -470,9 +469,9 @@ namespace globebrowsing {
programObject->setUniform("patchNormalCameraSpace", patchNormalCameraSpace);
programObject->setUniform("projectionTransform", data.camera.projectionMatrix());
if (_tileProviderManager->layerGroup(
if (_layerManager->layerGroup(
LayeredTextures::NightTextures).activeLayers().size() > 0 ||
_tileProviderManager->layerGroup(
_layerManager->layerGroup(
LayeredTextures::WaterMasks).activeLayers().size() > 0 ||
chunk.owner().generalProperties().atmosphereEnabled ||
chunk.owner().generalProperties().performShading) {

4
modules/globebrowsing/chunk/chunkrenderer.h
View File

@@ -56,7 +56,7 @@ namespace globebrowsing {
class ChunkRenderer {
public:
ChunkRenderer(std::shared_ptr<Grid> grid,
std::shared_ptr<TileProviderManager> tileProviderManager);
std::shared_ptr<LayerManager> layerManager);
/**
Chooses to render a chunk either locally or globally depending on the chunklevel
@@ -117,7 +117,7 @@ namespace globebrowsing {
// shared pointer to a grid which can be the same for all rendered chunks.
std::shared_ptr<Grid> _grid;
std::shared_ptr<TileProviderManager> _tileProviderManager;
std::shared_ptr<LayerManager> _layerManager;
// Two different shader programs. One for global and one for local rendering.
std::shared_ptr<LayeredTextureShaderProvider> _globalRenderingShaderProvider;

12
modules/globebrowsing/globes/chunkedlodglobe.cpp
View File

@@ -65,7 +65,7 @@ namespace globebrowsing {
ChunkedLodGlobe::ChunkedLodGlobe(
const RenderableGlobe& owner,
size_t segmentsPerPatch,
std::shared_ptr<TileProviderManager> tileProviderManager)
std::shared_ptr<LayerManager> layerManager)
: _owner(owner)
, _leftRoot(std::make_unique<ChunkNode>(
Chunk(owner, LEFT_HEMISPHERE_INDEX)))
@@ -73,7 +73,7 @@ namespace globebrowsing {
Chunk(owner, RIGHT_HEMISPHERE_INDEX)))
, minSplitDepth(2)
, maxSplitDepth(22)
, _tileProviderManager(tileProviderManager)
, _layerManager(layerManager)
, stats(StatsCollector(absPath("test_stats"), 1,
StatsCollector::Enabled::No)) {
auto geometry = std::make_shared<SkirtedGrid>(
@@ -95,7 +95,7 @@ namespace globebrowsing {
std::make_unique<EvaluateChunkLevelByDistance>();
_renderer =
std::make_unique<ChunkRenderer>(geometry, tileProviderManager);
std::make_unique<ChunkRenderer>(geometry, layerManager);
}
ChunkedLodGlobe::~ChunkedLodGlobe() {
@@ -115,9 +115,9 @@ namespace globebrowsing {
return ready;
}
std::shared_ptr<TileProviderManager>
ChunkedLodGlobe::getTileProviderManager() const {
return _tileProviderManager;
std::shared_ptr<LayerManager>
ChunkedLodGlobe::layerManager() const {
return _layerManager;
}
bool ChunkedLodGlobe::testIfCullable(

6
modules/globebrowsing/globes/chunkedlodglobe.h
View File

@@ -52,7 +52,7 @@ namespace globebrowsing {
ChunkedLodGlobe(
const RenderableGlobe& owner,
size_t segmentsPerPatch,
std::shared_ptr<TileProviderManager> tileProviderManager);
std::shared_ptr<LayerManager> layerManager);
virtual ~ChunkedLodGlobe();
bool initialize() override;
@@ -71,7 +71,7 @@ namespace globebrowsing {
const int minSplitDepth;
const int maxSplitDepth;
std::shared_ptr<TileProviderManager> getTileProviderManager() const;
std::shared_ptr<LayerManager> layerManager() const;
StatsCollector stats;
@@ -97,7 +97,7 @@ namespace globebrowsing {
std::unique_ptr<ChunkLevelEvaluator> _chunkEvaluatorByProjectedArea;
std::unique_ptr<ChunkLevelEvaluator> _chunkEvaluatorByDistance;
std::shared_ptr<TileProviderManager> _tileProviderManager;
std::shared_ptr<LayerManager> _layerManager;
const RenderableGlobe& _owner;
};

20
modules/globebrowsing/globes/renderableglobe.cpp
View File

@@ -27,7 +27,7 @@
#include <ghoul/misc/threadpool.h>
#include <modules/globebrowsing/tile/tileselector.h>
#include <modules/globebrowsing/tile/tileprovidermanager.h>
#include <modules/globebrowsing/tile/layermanager.h>
// open space includes
#include <openspace/engine/openspaceengine.h>
@@ -71,13 +71,13 @@ namespace globebrowsing {
LayeredCategoryPropertyOwner::LayeredCategoryPropertyOwner(
LayeredTextures::TextureCategory category,
TileProviderManager& tileProviderManager)
: _tileProviderManager(tileProviderManager)
LayerManager& layerManager)
: _layerManager(layerManager)
, _levelBlendingEnabled("blendTileLevels", "blend tile levels", true){
setName(LayeredTextures::TEXTURE_CATEGORY_NAMES[category]);
// Create the property owners
auto& layerGroup = _tileProviderManager.layerGroup(category);
auto& layerGroup = _layerManager.layerGroup(category);
for (Layer& layer : layerGroup.layers) {
_texturePropertyOwners.push_back(
std::make_unique<SingleTexturePropertyOwner>(layer.name));
@@ -165,11 +165,11 @@ namespace globebrowsing {
dictionary.getValue(keyTextureInitData, textureInitDataDictionary);
dictionary.getValue(keyTextures, texturesDictionary);
_tileProviderManager = std::make_shared<TileProviderManager>(
_layerManager = std::make_shared<LayerManager>(
texturesDictionary, textureInitDataDictionary);
_chunkedLodGlobe = std::make_shared<ChunkedLodGlobe>(
*this, patchSegments, _tileProviderManager);
*this, patchSegments, _layerManager);
_pointGlobe = std::make_shared<PointGlobe>(*this);
_distanceSwitch.addSwitchValue(_chunkedLodGlobe, 1e9);
@@ -199,7 +199,7 @@ namespace globebrowsing {
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++) {
_textureProperties.push_back(std::make_unique<LayeredCategoryPropertyOwner>
(LayeredTextures::TextureCategory(i), *_tileProviderManager));
(LayeredTextures::TextureCategory(i), *_layerManager));
_texturePropertyOwner.addPropertySubOwner(*_textureProperties[i]);
}
@@ -263,10 +263,10 @@ namespace globebrowsing {
_cachedInverseModelTransform = glm::inverse(_cachedModelTransform);
if (_debugProperties.resetTileProviders) {
_tileProviderManager->reset();
_layerManager->reset();
_debugProperties.resetTileProviders = false;
}
_tileProviderManager->update();
_layerManager->update();
_chunkedLodGlobe->update(data);
}
@@ -276,7 +276,7 @@ namespace globebrowsing {
float RenderableGlobe::getHeight(glm::dvec3 position) {
// Get the tile provider for the height map
const auto& heightLayers = _tileProviderManager->layerGroup(
const auto& heightLayers = _layerManager->layerGroup(
LayeredTextures::HeightMaps).activeLayers();
if (heightLayers.size() == 0)
return 0;

8
modules/globebrowsing/globes/renderableglobe.h
View File

@@ -48,7 +48,7 @@ namespace openspace {
namespace globebrowsing {
class ChunkedLodGlobe;
class TileProviderManager;
class LayerManager;
/**
Property owner that owns all property of a single texture layer.
@@ -75,10 +75,10 @@ class LayeredCategoryPropertyOwner : public properties::PropertyOwner
public:
LayeredCategoryPropertyOwner(
LayeredTextures::TextureCategory category,
TileProviderManager& tileProviderManager);
LayerManager& layerManager);
~LayeredCategoryPropertyOwner();
private:
TileProviderManager& _tileProviderManager;
LayerManager& _layerManager;
std::vector<std::unique_ptr<SingleTexturePropertyOwner> >
_texturePropertyOwners;
properties::BoolProperty _levelBlendingEnabled;
@@ -151,7 +151,7 @@ private:
std::shared_ptr<PointGlobe> _pointGlobe;
Ellipsoid _ellipsoid;
std::shared_ptr<TileProviderManager> _tileProviderManager;
std::shared_ptr<LayerManager> _layerManager;
DistanceSwitch _distanceSwitch;
std::shared_ptr<Camera> _savedCamera;

19
modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.cpp
View File

@@ -23,7 +23,7 @@
****************************************************************************************/
#include <modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h>
#include <modules/globebrowsing/tile/tileprovidermanager.h>
#include <modules/globebrowsing/tile/layermanager.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/engine/openspaceengine.h>
@@ -39,7 +39,7 @@ namespace {
namespace openspace {
namespace globebrowsing {
LayeredTexturePreprocessingData::LayeredTexturePreprocessingData(TileProviderManager* tpm){
LayeredTexturePreprocessingData::LayeredTexturePreprocessingData(LayerManager* tpm){
}
@@ -58,19 +58,14 @@ namespace globebrowsing {
keyValuePairs.size() != other.keyValuePairs.size()) {
return false;
}
else
{
else {
bool equal = true;
for (size_t i = 0; i < layeredTextureInfo.size(); i++) {
equal = equal && (layeredTextureInfo[i] == other.layeredTextureInfo[i]);
equal &= (layeredTextureInfo[i] == other.layeredTextureInfo[i]);
}
for (size_t i = 0; i < keyValuePairs.size(); i++) {
equal &= (keyValuePairs[i] == other.keyValuePairs[i]);
}
// Commented this for-loop. Not necessary since the keyValuePairs
// are always supposed to be equal. Comparing strings takes time.
//for (size_t i = 0; i < keyValuePairs.size(); i++) {
// equal = equal && (keyValuePairs[i] == other.keyValuePairs[i]);
//}
return equal;
}
}

4
modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h
View File

@@ -38,7 +38,7 @@ namespace globebrowsing {
using namespace ghoul::opengl;
class TileProviderManager;
class LayerManager;
class LayeredTextureShaderUniformIdHandler;
@@ -64,7 +64,7 @@ namespace globebrowsing {
* levels.
*/
struct LayeredTexturePreprocessingData {
LayeredTexturePreprocessingData(TileProviderManager* tpm = nullptr);
LayeredTexturePreprocessingData(LayerManager* tpm = nullptr);
std::array<LayeredTextureInfo, LayeredTextures::NUM_TEXTURE_CATEGORIES>
layeredTextureInfo;

18
modules/globebrowsing/tile/tileprovidermanager.cpp → modules/globebrowsing/tile/layermanager.cpp
View File

@@ -24,14 +24,14 @@
#include <openspace/util/factorymanager.h>
#include <modules/globebrowsing/tile/tileprovidermanager.h>
#include <modules/globebrowsing/tile/layermanager.h>
#include <ghoul/logging/logmanager.h>
#include "cpl_minixml.h"
namespace {
const std::string _loggerCat = "TileProviderManager";
const std::string _loggerCat = "LayerManager";
}
namespace openspace {
@@ -58,7 +58,7 @@ namespace globebrowsing {
//////////////////////////////////////////////////////////////////////////////////////
// Tile Provider Manager //
//////////////////////////////////////////////////////////////////////////////////////
TileProviderManager::TileProviderManager(
LayerManager::LayerManager(
const ghoul::Dictionary& textureCategoriesDictionary,
const ghoul::Dictionary& textureInitDictionary){
// Create all the categories of tile providers
@@ -105,11 +105,11 @@ namespace globebrowsing {
}
}
TileProviderManager::~TileProviderManager()
LayerManager::~LayerManager()
{
}
void TileProviderManager::initTexures(std::vector<Layer>& dest,
void LayerManager::initTexures(std::vector<Layer>& dest,
const ghoul::Dictionary& texturesDict, const TileProviderInitData& initData)
{
// Create TileProviders for all textures within this category
@@ -148,21 +148,21 @@ namespace globebrowsing {
}
}
LayerGroup& TileProviderManager::layerGroup(size_t groupId) {
LayerGroup& LayerManager::layerGroup(size_t groupId) {
return layerGroups[groupId];
}
LayerGroup& TileProviderManager::layerGroup(LayeredTextures::TextureCategory category) {
LayerGroup& LayerManager::layerGroup(LayeredTextures::TextureCategory category) {
return layerGroups[category];
}
void TileProviderManager::update() {
void LayerManager::update() {
for (LayerGroup& layerGroup : layerGroups) {
layerGroup.update();
}
}
void TileProviderManager::reset(bool includingInactive) {
void LayerManager::reset(bool includingInactive) {
for (LayerGroup& layerGroup : layerGroups) {
for (Layer& layer : layerGroup.layers) {
if (layer.isActive) {

6
modules/globebrowsing/tile/tileprovidermanager.h → modules/globebrowsing/tile/layermanager.h
View File

@@ -59,13 +59,13 @@ namespace globebrowsing {
std::vector<Layer> _activeLayers;
};
class TileProviderManager {
class LayerManager {
public:
TileProviderManager(
LayerManager(
const ghoul::Dictionary& textureCategoriesDictionary,
const ghoul::Dictionary& textureInitDictionary);
~TileProviderManager();
~LayerManager();
LayerGroup& layerGroup(size_t groupId);
LayerGroup& layerGroup(LayeredTextures::TextureCategory);

2
modules/globebrowsing/tile/tileselector.h
View File

@@ -28,7 +28,7 @@
#include <modules/globebrowsing/tile/tileindex.h>
#include <modules/globebrowsing/tile/tile.h>
#include <modules/globebrowsing/tile/tileprovidermanager.h>
#include <modules/globebrowsing/tile/layermanager.h>
#include <modules/globebrowsing/tile/chunktile.h>
#include <vector>