mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-04-22 02:48:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

Renaming Layer, LayerGroup. Cache activeLayers

Browse Source
This commit is contained in:
Erik Broberg
2016-10-19 14:44:09 +02:00
parent 69a0c58c32
commit 331191bf03
10 changed files with 90 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/chunk/chunk.cpp
+2 -2
View File
@@ -104,11 +104,11 @@ namespace globebrowsing {
auto tileProviderManager = owner().chunkedLodGlobe()->getTileProviderManager();
auto heightMapProviders = tileProviderManager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
auto heightMapProviders = tileProviderManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
size_t HEIGHT_CHANNEL = 0;
const TileProviderGroup& heightmaps = tileProviderManager->getTileProviderGroup(LayeredTextures::HeightMaps);
const LayerGroup& heightmaps = tileProviderManager->layerGroup(LayeredTextures::HeightMaps);
std::vector<ChunkTile> tiles = TileSelector::getTilesSortedByHighestResolution(heightmaps, _tileIndex);
bool lastHadMissingData = true;
for (auto tile : tiles) {
modules/globebrowsing/chunk/chunklevelevaluator.cpp
+3 -5
View File
@@ -163,14 +163,12 @@ namespace globebrowsing {
int EvaluateChunkLevelByAvailableTileData::getDesiredLevel(const Chunk& chunk, const RenderData& data) const {
auto tileProvidermanager = chunk.owner().chunkedLodGlobe()->getTileProviderManager();
auto heightMapProviders = tileProvidermanager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
auto heightLayers = tileProvidermanager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
int currLevel = chunk.tileIndex().level;
for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++) {
auto tileProviderGroup = tileProvidermanager->getTileProviderGroup(i);
for (auto tileProvider : tileProviderGroup.getActiveTileProviders()) {
Tile::Status tileStatus = tileProvider->getTileStatus(chunk.tileIndex());
for (auto layer : tileProvidermanager->layerGroup(i).activeLayers()) {
Tile::Status tileStatus = layer.tileProvider->getTileStatus(chunk.tileIndex());
if (tileStatus == Tile::Status::OK) {
return UNKNOWN_DESIRED_LEVEL;
}
modules/globebrowsing/chunk/chunkrenderer.cpp
+22 -22
View File
@@ -186,8 +186,8 @@ namespace globebrowsing {
category++) {
LayeredTextureInfo layeredTextureInfo;
auto layerGroup = _tileProviderManager->getTileProviderGroup(category);
layeredTextureInfo.lastLayerIdx = layerGroup.getActiveTileProviders().size() - 1;
auto layerGroup = _tileProviderManager->layerGroup(category);
layeredTextureInfo.lastLayerIdx = layerGroup.activeLayers().size() - 1;
layeredTextureInfo.layerBlendingEnabled = layerGroup.levelBlendingEnabled;
layeredTexturePreprocessingData.layeredTextureInfo[category] = layeredTextureInfo;
@@ -241,18 +241,18 @@ 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->getTileProviderGroup(category);
texUnits[category].resize(layerGroup.getActiveTileProviders().size());
auto layerGroup = _tileProviderManager->layerGroup(category);
texUnits[category].resize(layerGroup.activeLayers().size());
}
// Go through all the categories
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
// Go through all the providers in this category
auto layerGroup = _tileProviderManager->getTileProviderGroup(category);
auto activeProviders = layerGroup.getActiveTileProviders();
auto layerGroup = _tileProviderManager->layerGroup(category);
const auto& layers = layerGroup.activeLayers();
int i = 0;
for (auto it = activeProviders.begin(); it != activeProviders.end(); it++) {
auto tileProvider = it->get();
for (auto it = layers.begin(); it != layers.end(); it++) {
auto tileProvider = it->tileProvider.get();
// Get the texture that should be used for rendering
ChunkTile chunkTile = TileSelector::getHighestResolutionTile(tileProvider, tileIndex);
@@ -301,7 +301,7 @@ namespace globebrowsing {
programUniformHandler,
LayeredTextures::TextureCategory(category),
i,
_tileProviderManager->getTileProviderGroup(category).getActiveNamedTileProviders()[i].settings);
_tileProviderManager->layerGroup(category).activeLayers()[i].settings);
/*
if (category == LayeredTextures::HeightMaps && chunkTile.tile.preprocessData) {
@@ -318,9 +318,9 @@ namespace globebrowsing {
// Go through all the height maps and set depth tranforms
int i = 0;
auto activeHeightProviders = _tileProviderManager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
for (auto it = activeHeightProviders.begin(); it != activeHeightProviders.end(); it++) {
auto tileProvider = *it;
auto heightLayers = _tileProviderManager->layerGroup(LayeredTextures::HeightMaps).activeLayers();
for (auto it = heightLayers.begin(); it != heightLayers.end(); it++) {
auto tileProvider = it->tileProvider;
TileDepthTransform depthTransform = tileProvider->depthTransform();
setDepthTransformUniforms(
@@ -359,7 +359,7 @@ namespace globebrowsing {
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
LayeredTextures::TextureCategory category = (LayeredTextures::TextureCategory)i;
if(_tileProviderManager->getTileProviderGroup(i).levelBlendingEnabled && _tileProviderManager->getTileProviderGroup(category).getActiveTileProviders().size() > 0){
if(_tileProviderManager->layerGroup(i).levelBlendingEnabled && _tileProviderManager->layerGroup(category).activeLayers().size() > 0){
performAnyBlending = true;
break;
}
@@ -391,10 +391,10 @@ namespace globebrowsing {
programObject->setUniform("lonLatScalingFactor", vec2(patchSize.toLonLatVec2()));
programObject->setUniform("radiiSquared", vec3(ellipsoid.radiiSquared()));
if (_tileProviderManager->getTileProviderGroup(
LayeredTextures::NightTextures).getActiveTileProviders().size() > 0 ||
_tileProviderManager->getTileProviderGroup(
LayeredTextures::WaterMasks).getActiveTileProviders().size() > 0 ||
if (_tileProviderManager->layerGroup(
LayeredTextures::NightTextures).activeLayers().size() > 0 ||
_tileProviderManager->layerGroup(
LayeredTextures::WaterMasks).activeLayers().size() > 0 ||
chunk.owner().generalProperties().atmosphereEnabled ||
chunk.owner().generalProperties().performShading) {
glm::vec3 directionToSunWorldSpace =
@@ -438,7 +438,7 @@ namespace globebrowsing {
bool performAnyBlending = false;
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
LayeredTextures::TextureCategory category = (LayeredTextures::TextureCategory)i;
if (_tileProviderManager->getTileProviderGroup(i).levelBlendingEnabled && _tileProviderManager->getTileProviderGroup(category).getActiveTileProviders().size() > 0) {
if (_tileProviderManager->layerGroup(i).levelBlendingEnabled && _tileProviderManager->layerGroup(category).activeLayers().size() > 0) {
performAnyBlending = true;
break;
}
@@ -472,10 +472,10 @@ namespace globebrowsing {
programObject->setUniform("patchNormalCameraSpace", patchNormalCameraSpace);
programObject->setUniform("projectionTransform", data.camera.projectionMatrix());
if (_tileProviderManager->getTileProviderGroup(
LayeredTextures::NightTextures).getActiveTileProviders().size() > 0 ||
_tileProviderManager->getTileProviderGroup(
LayeredTextures::WaterMasks).getActiveTileProviders().size() > 0 ||
if (_tileProviderManager->layerGroup(
LayeredTextures::NightTextures).activeLayers().size() > 0 ||
_tileProviderManager->layerGroup(
LayeredTextures::WaterMasks).activeLayers().size() > 0 ||
chunk.owner().generalProperties().atmosphereEnabled ||
chunk.owner().generalProperties().performShading) {
glm::vec3 directionToSunWorldSpace =
modules/globebrowsing/globes/renderableglobe.cpp
+12 -12
View File
@@ -77,22 +77,22 @@ namespace globebrowsing {
setName(LayeredTextures::TEXTURE_CATEGORY_NAMES[category]);
// Create the property owners
auto& layerGroup = _tileProviderManager.getTileProviderGroup(category);
for (NamedTileProvider& tileProvider : layerGroup.tileProviders) {
auto& layerGroup = _tileProviderManager.layerGroup(category);
for (Layer& layer : layerGroup.layers) {
_texturePropertyOwners.push_back(
std::make_unique<SingleTexturePropertyOwner>(tileProvider.name));
std::make_unique<SingleTexturePropertyOwner>(layer.name));
}
// Specify and add the property owners
for (int i = 0; i < layerGroup.tileProviders.size(); i++) {
NamedTileProvider &tileProvider = layerGroup.tileProviders[i];
for (int i = 0; i < layerGroup.layers.size(); i++) {
Layer &layer = layerGroup.layers[i];
SingleTexturePropertyOwner &prop = *_texturePropertyOwners[i].get();
prop.isEnabled.set(tileProvider.isActive);
prop.isEnabled.set(layer.isActive);
prop.isEnabled.onChange([&]{
tileProvider.isActive = prop.isEnabled;
layer.isActive = prop.isEnabled;
});
for (auto setting : tileProvider.settings.array()) {
for (auto setting : layer.settings.array()) {
prop.addProperty(setting->property());
}
@@ -276,11 +276,11 @@ namespace globebrowsing {
float RenderableGlobe::getHeight(glm::dvec3 position) {
// Get the tile provider for the height map
const auto& heightMapProviders = _tileProviderManager->getTileProviderGroup(
LayeredTextures::HeightMaps).getActiveTileProviders();
if (heightMapProviders.size() == 0)
const auto& heightLayers = _tileProviderManager->layerGroup(
LayeredTextures::HeightMaps).activeLayers();
if (heightLayers.size() == 0)
return 0;
const auto& tileProvider = heightMapProviders[0];
const auto& tileProvider = heightLayers[0].tileProvider;
// Get the uv coordinates to sample from
Geodetic2 geodeticPosition = _ellipsoid.cartesianToGeodetic2(position);
modules/globebrowsing/layer/layer.cpp
+6 -4
View File
@@ -46,17 +46,18 @@ namespace {
namespace openspace {
namespace globebrowsing {
/*
Layer::Layer(const ghoul::Dictionary& dict){
dict.getValue(KEY_NAME, _name);
dict.getValue(KEY_ENABLED, _enabled);
_tileProvider = std::unique_ptr<TileProvider>(TileProvider::createFromDictionary(dict));
}
}*/
/*
void Layer::bind(ProgramObject* programObject, const TileIndex& tileIndex){
/*
ChunkTile tat = TileSelector::getHighestResolutionTile(_tileProvider.get(), tileIndex);
if (tat.tile.status == Tile::Status::Unavailable) {
tat.tile = _tileProvider->getDefaultTile();
@@ -98,9 +99,10 @@ namespace globebrowsing {
texUnits[category][i].blendTexture2,
tatParent2);
}
*/
}
*/
/*
void Layer::ensureIdsAreUpdated(LayeredTextureShaderProvider* shaderProvider){
if (shaderProvider->updatedOnLastCall())
modules/globebrowsing/layer/layer.h
+2 -1
View File
@@ -39,6 +39,7 @@
namespace openspace {
namespace globebrowsing {
/*
class TileProvider;
class Layer : public properties::PropertyOwner {
@@ -66,7 +67,7 @@ private:
bool _enabled;
};
*/
} // namespace globebrowsing
} // namespace openspace
#endif // LAYER_H
modules/globebrowsing/tile/tileprovidermanager.cpp
+23 -33
View File
@@ -40,28 +40,19 @@ namespace globebrowsing {
// Tile Provider Group //
//////////////////////////////////////////////////////////////////////////////////////
void TileProviderGroup::update() {
activeTileProviders.clear();
for (auto tileProviderWithName : tileProviders) {
if (tileProviderWithName.isActive) {
tileProviderWithName.tileProvider->update();
activeTileProviders.push_back(tileProviderWithName.tileProvider);
void LayerGroup::update() {
_activeLayers.clear();
for (auto layer : layers) {
if (layer.isActive) {
layer.tileProvider->update();
_activeLayers.push_back(layer);
}
}
}
const std::vector<std::shared_ptr<TileProvider>>& TileProviderGroup::getActiveTileProviders() const {
return activeTileProviders;
}
const std::vector<NamedTileProvider> TileProviderGroup::getActiveNamedTileProviders() const {
std::vector<NamedTileProvider> activeNamedTileProviders;
for (auto tileProviderWithName : tileProviders) {
if (tileProviderWithName.isActive) {
activeNamedTileProviders.push_back(tileProviderWithName);
}
}
return activeNamedTileProviders;
const std::vector<Layer>& LayerGroup::activeLayers() const {
return _activeLayers;
}
//////////////////////////////////////////////////////////////////////////////////////
@@ -105,12 +96,12 @@ namespace globebrowsing {
initData.preprocessTiles = i == LayeredTextures::HeightMaps;
initTexures(
_layerCategories[i].tileProviders,
layerGroups[i].layers,
texturesDict,
initData);
// init level blending to be true
_layerCategories[i].levelBlendingEnabled = true;
layerGroups[i].levelBlendingEnabled = true;
}
}
@@ -118,7 +109,7 @@ namespace globebrowsing {
{
}
void TileProviderManager::initTexures(std::vector<NamedTileProvider>& dest,
void TileProviderManager::initTexures(std::vector<Layer>& dest,
const ghoul::Dictionary& texturesDict, const TileProviderInitData& initData)
{
// Create TileProviders for all textures within this category
@@ -157,29 +148,28 @@ namespace globebrowsing {
}
}
TileProviderGroup& TileProviderManager::getTileProviderGroup(size_t groupId) {
return _layerCategories[groupId];
LayerGroup& TileProviderManager::layerGroup(size_t groupId) {
return layerGroups[groupId];
}
TileProviderGroup& TileProviderManager::getTileProviderGroup(LayeredTextures::TextureCategory category) {
return _layerCategories[category];
LayerGroup& TileProviderManager::layerGroup(LayeredTextures::TextureCategory category) {
return layerGroups[category];
}
void TileProviderManager::update() {
for (auto& tileProviderGroup : _layerCategories) {
//tileProviderGroup.activeTileProviders.resize(5);
tileProviderGroup.update();
for (auto& layerGroup : layerGroups) {
layerGroup.update();
}
}
void TileProviderManager::reset(bool includingInactive) {
for (auto layerCategory : _layerCategories) {
for (auto tileProviderWithName : layerCategory.tileProviders) {
if (tileProviderWithName.isActive) {
tileProviderWithName.tileProvider->reset();
for (auto layerGroup : layerGroups) {
for (auto layer : layerGroup.layers) {
if (layer.isActive) {
layer.tileProvider->reset();
}
else if (includingInactive) {
tileProviderWithName.tileProvider->reset();
layer.tileProvider->reset();
}
}
}
modules/globebrowsing/tile/tileprovidermanager.h
+10 -11
View File
@@ -39,7 +39,7 @@
namespace openspace {
namespace globebrowsing {
struct NamedTileProvider {
struct Layer {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
bool isActive;
@@ -47,17 +47,16 @@ namespace globebrowsing {
PerLayerSettings settings;
};
struct TileProviderGroup {
struct LayerGroup {
void update();
const std::vector<std::shared_ptr<TileProvider>>& getActiveTileProviders() const;
const std::vector<NamedTileProvider> getActiveNamedTileProviders() const;
const std::vector<Layer>& activeLayers() const;
std::vector<NamedTileProvider> tileProviders;
std::vector<Layer> layers;
bool levelBlendingEnabled;
std::vector<std::shared_ptr<TileProvider>> activeTileProviders;
private:
std::vector<Layer> _activeLayers;
};
class TileProviderManager {
@@ -68,18 +67,18 @@ namespace globebrowsing {
const ghoul::Dictionary& textureInitDictionary);
~TileProviderManager();
TileProviderGroup& getTileProviderGroup(size_t groupId);
TileProviderGroup& getTileProviderGroup(LayeredTextures::TextureCategory);
LayerGroup& layerGroup(size_t groupId);
LayerGroup& layerGroup(LayeredTextures::TextureCategory);
void update();
void reset(bool includingInactive = false);
private:
static void initTexures(
std::vector<NamedTileProvider>& destination,
std::vector<Layer>& destination,
const ghoul::Dictionary& dict,
const TileProviderInitData& initData);
std::array<TileProviderGroup, LayeredTextures::NUM_TEXTURE_CATEGORIES> _layerCategories;
std::array<LayerGroup, LayeredTextures::NUM_TEXTURE_CATEGORIES> layerGroups;
};
modules/globebrowsing/tile/tileselector.cpp
+8 -8
View File
@@ -72,14 +72,14 @@ namespace globebrowsing {
return{ Tile::TileUnavailable, uvTransform };
}
ChunkTile TileSelector::getHighestResolutionTile(const TileProviderGroup& tileProviderGroup, TileIndex tileIndex) {
ChunkTile TileSelector::getHighestResolutionTile(const LayerGroup& layerGroup, TileIndex tileIndex) {
ChunkTile mostHighResolution;
mostHighResolution.tile = Tile::TileUnavailable;
mostHighResolution.uvTransform.uvScale.x = 0;
auto activeProviders = tileProviderGroup.getActiveTileProviders();
for (size_t i = 0; i < activeProviders.size(); i++) {
ChunkTile chunkTile = getHighestResolutionTile(activeProviders[i].get(), tileIndex);
auto layers = layerGroup.activeLayers();
for (size_t i = 0; i < layers.size(); i++) {
ChunkTile chunkTile = getHighestResolutionTile(layers[i].tileProvider.get(), tileIndex);
bool tileIsOk = chunkTile.tile.status == Tile::Status::OK;
bool tileHasPreprocessData = chunkTile.tile.preprocessData != nullptr;
bool tileIsHigherResolution = chunkTile.uvTransform.uvScale.x > mostHighResolution.uvTransform.uvScale.x;
@@ -96,11 +96,11 @@ namespace globebrowsing {
return a.uvTransform.uvScale.x > b.uvTransform.uvScale.x;
}
std::vector<ChunkTile> TileSelector::getTilesSortedByHighestResolution(const TileProviderGroup& tileProviderGroup, const TileIndex& tileIndex) {
auto activeProviders = tileProviderGroup.getActiveTileProviders();
std::vector<ChunkTile> TileSelector::getTilesSortedByHighestResolution(const LayerGroup& layerGroup, const TileIndex& tileIndex) {
auto layers = layerGroup.activeLayers();
std::vector<ChunkTile> tiles;
for (auto provider : activeProviders){
tiles.push_back(getHighestResolutionTile(provider.get(), tileIndex));
for (auto layer : layers){
tiles.push_back(getHighestResolutionTile(layer.tileProvider.get(), tileIndex));
}
std::sort(tiles.begin(), tiles.end(), TileSelector::HIGHEST_RES);
modules/globebrowsing/tile/tileselector.h
+2 -2
View File
@@ -38,8 +38,8 @@ namespace globebrowsing {
class TileSelector {
public:
static ChunkTile getHighestResolutionTile(TileProvider* tileProvider, TileIndex tileIndex, int parents = 0);
static ChunkTile getHighestResolutionTile(const TileProviderGroup& tileProviderGroup, TileIndex tileIndex);
static std::vector<ChunkTile> getTilesSortedByHighestResolution(const TileProviderGroup&, const TileIndex& tileIndex);
static ChunkTile getHighestResolutionTile(const LayerGroup& layerGroup, TileIndex tileIndex);
static std::vector<ChunkTile> getTilesSortedByHighestResolution(const LayerGroup&, const TileIndex& tileIndex);
struct CompareResolution {
bool operator() (const ChunkTile& a, const ChunkTile& b);