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

Merge branch 'feature/globebrowsing' of github.com:OpenSpace/OpenSpace-Development into feature/globebrowsing

Browse Source
This commit is contained in:
Kalle
2016-07-12 15:02:10 -04:00
parent 6e827e4337 f1d8e42dff
commit 703ab140c1
7 changed files with 90 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -101,7 +101,7 @@ namespace openspace {
// 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()->getTileProviderManager();
auto heightMapProviders = tileProvidermanager->getActivatedLayerCategory(LayeredTextures::HeightMaps);
auto heightMapProviders = tileProvidermanager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
if (heightMapProviders.size() > 0) {
TileAndTransform tileAndTransform = TileSelector::getHighestResolutionTile(heightMapProviders[0].get(), _index);
if (tileAndTransform.tile.status == Tile::Status::OK) {

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

@@ -162,7 +162,7 @@ namespace openspace {
int EvaluateChunkLevelByAvailableTileData::getDesiredLevel(const Chunk& chunk, const RenderData& data) const {
auto tileProvidermanager = chunk.owner()->getTileProviderManager();
auto heightMapProviders = tileProvidermanager->getActivatedLayerCategory(LayeredTextures::HeightMaps);
auto heightMapProviders = tileProvidermanager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
int currLevel = chunk.index().level;
// simply check the first heigtmap

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

@@ -166,12 +166,11 @@ namespace openspace {
LayeredTexturePreprocessingData layeredTexturePreprocessingData;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
tileProviders[category] = _tileProviderManager->getActivatedLayerCategory(
LayeredTextures::TextureCategory(category));
tileProviders[category] = _tileProviderManager->getTileProviderGroup(category).getActiveTileProviders();
LayeredTextureInfo layeredTextureInfo;
layeredTextureInfo.lastLayerIdx = tileProviders[category].size() - 1;
layeredTextureInfo.layerBlendingEnabled = _tileProviderManager->levelBlendingEnabled[category];
layeredTextureInfo.layerBlendingEnabled = _tileProviderManager->getTileProviderGroup(category).levelBlendingEnabled;
layeredTexturePreprocessingData.layeredTextureInfo[category] = layeredTextureInfo;
}
@@ -332,7 +331,7 @@ namespace openspace {
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
LayeredTextures::TextureCategory category = (LayeredTextures::TextureCategory)i;
if(_tileProviderManager->levelBlendingEnabled[i] && _tileProviderManager->getActivatedLayerCategory(category).size() > 0){
if(_tileProviderManager->getTileProviderGroup(i).levelBlendingEnabled && _tileProviderManager->getTileProviderGroup(category).getActiveTileProviders().size() > 0){
performAnyBlending = true;
break;
}
@@ -365,7 +364,7 @@ namespace openspace {
programObject->setUniform("lonLatScalingFactor", vec2(patchSize.toLonLatVec2()));
programObject->setUniform("radiiSquared", vec3(ellipsoid.radiiSquared()));
if (_tileProviderManager->getActivatedLayerCategory(LayeredTextures::NightTextures).size() > 0) {
if (_tileProviderManager->getTileProviderGroup(LayeredTextures::NightTextures).getActiveTileProviders().size() > 0) {
programObject->setUniform("modelViewTransform", modelViewTransform);
}
@@ -402,7 +401,7 @@ namespace openspace {
bool performAnyBlending = false;
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
LayeredTextures::TextureCategory category = (LayeredTextures::TextureCategory)i;
if (_tileProviderManager->levelBlendingEnabled[i] && _tileProviderManager->getActivatedLayerCategory(category).size() > 0) {
if (_tileProviderManager->getTileProviderGroup(i).levelBlendingEnabled && _tileProviderManager->getTileProviderGroup(category).getActiveTileProviders().size() > 0) {
performAnyBlending = true;
break;
}

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

@@ -117,11 +117,11 @@ namespace openspace {
std::string categoryName = std::to_string(i+1) + ". " + LayeredTextures::TEXTURE_CATEGORY_NAMES[i];
auto selection = std::make_unique<ReferencedBoolSelection>(categoryName, categoryName);
auto& categoryProviders = _tileProviderManager->getLayerCategory(category);
for (auto& provider : categoryProviders) {
auto& categoryProviders = _tileProviderManager->getTileProviderGroup(category);
for (auto& provider : categoryProviders.tileProviders) {
selection->addOption(provider.name, &provider.isActive);
}
selection->addOption(" - Blend tile levels - ", &_tileProviderManager->levelBlendingEnabled[category]);
selection->addOption(" - Blend tile levels - ", &_tileProviderManager->getTileProviderGroup(i).levelBlendingEnabled);
addProperty(selection.get());
_categorySelections.push_back(std::move(selection));
@@ -208,7 +208,7 @@ namespace openspace {
float RenderableGlobe::getHeight(glm::dvec3 position) {
// Get the tile provider for the height map
const auto& heightMapProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::HeightMaps);
const auto& heightMapProviders = _tileProviderManager->getTileProviderGroup(LayeredTextures::HeightMaps).getActiveTileProviders();
if (heightMapProviders.size() == 0)
return 0;
const auto& tileProvider = heightMapProviders[0];

64
modules/globebrowsing/tile/TileProviderManager.cpp
View File

@@ -37,7 +37,35 @@ namespace {
namespace openspace {
ThreadPool TileProviderManager::tileRequestThreadPool(1);
//////////////////////////////////////////////////////////////////////////////////////
// Tile Provider Group //
//////////////////////////////////////////////////////////////////////////////////////
void TileProviderGroup::update() {
for (auto tileProviderWithName : tileProviders) {
if (tileProviderWithName.isActive) {
tileProviderWithName.tileProvider->update();
}
}
}
const std::vector<std::shared_ptr<TileProvider>> TileProviderGroup::getActiveTileProviders() const {
std::vector<std::shared_ptr<TileProvider>> activeTileProviders;
for (auto tileProviderWithName : tileProviders) {
if (tileProviderWithName.isActive) {
activeTileProviders.push_back(tileProviderWithName.tileProvider);
}
}
return activeTileProviders;
}
//////////////////////////////////////////////////////////////////////////////////////
// Tile Provider Manager //
//////////////////////////////////////////////////////////////////////////////////////
TileProviderManager::TileProviderManager(
const ghoul::Dictionary& textureCategoriesDictionary,
@@ -78,12 +106,12 @@ namespace openspace {
i == LayeredTextures::HeightMapOverlays; // Only preprocess height maps.
initTexures(
_layerCategories[i],
_layerCategories[i].tileProviders,
texturesDict,
initData);
// init level blending to be true
levelBlendingEnabled[i] = true;
_layerCategories[i].levelBlendingEnabled = true;
}
}
@@ -119,24 +147,23 @@ namespace openspace {
}
}
TileProviderManager::LayerCategory& TileProviderManager::getLayerCategory(LayeredTextures::TextureCategory category)
{
TileProviderGroup& TileProviderManager::getTileProviderGroup(size_t groupId) {
return _layerCategories[groupId];
}
TileProviderGroup& TileProviderManager::getTileProviderGroup(LayeredTextures::TextureCategory category) {
return _layerCategories[category];
}
void TileProviderManager::update() {
for (auto layerCategory : _layerCategories) {
for (auto tileProviderWithName : layerCategory) {
if (tileProviderWithName.isActive) {
tileProviderWithName.tileProvider->update();
}
}
for (auto tileProviderGroup : _layerCategories) {
tileProviderGroup.update();
}
}
void TileProviderManager::reset(bool includingInactive) {
for (auto layerCategory : _layerCategories) {
for (auto tileProviderWithName : layerCategory) {
for (auto tileProviderWithName : layerCategory.tileProviders) {
if (tileProviderWithName.isActive) {
tileProviderWithName.tileProvider->reset();
}
@@ -147,17 +174,6 @@ namespace openspace {
}
}
const std::vector<std::shared_ptr<TileProvider> >
TileProviderManager::getActivatedLayerCategory(
LayeredTextures::TextureCategory textureCategory)
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
for (auto tileProviderWithName : _layerCategories[textureCategory]) {
if (tileProviderWithName.isActive) {
tileProviders.push_back(tileProviderWithName.tileProvider);
}
}
return tileProviders;
}
} // namespace openspace

47
modules/globebrowsing/tile/TileProviderManager.h
View File

@@ -42,39 +42,50 @@
namespace openspace {
struct TileProviderWithName {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
bool isActive;
};
struct TileProviderGroup {
void update();
const std::vector<std::shared_ptr<TileProvider>> TileProviderGroup::getActiveTileProviders() const;
std::vector<TileProviderWithName> tileProviders;
bool levelBlendingEnabled;
};
class TileProviderManager {
public:
struct TileProviderWithName {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
bool isActive;
};
typedef std::vector<TileProviderWithName> LayerCategory;
TileProviderManager(
const ghoul::Dictionary& textureCategoriesDictionary,
const ghoul::Dictionary& textureInitDictionary);
~TileProviderManager();
static ThreadPool tileRequestThreadPool;
LayerCategory& getLayerCategory(LayeredTextures::TextureCategory);
const std::vector<std::shared_ptr<TileProvider> >
getActivatedLayerCategory(LayeredTextures::TextureCategory);
TileProviderGroup& getTileProviderGroup(size_t groupId);
TileProviderGroup& getTileProviderGroup(LayeredTextures::TextureCategory);
void update();
void reset(bool includingInactive = false);
std::array<bool, LayeredTextures::NUM_TEXTURE_CATEGORIES> levelBlendingEnabled;
private:
static void initTexures(std::vector<TileProviderWithName>& destination,
const ghoul::Dictionary& dict, const TileProviderInitData& initData);
static void initTexures(
std::vector<TileProviderWithName>& destination,
const ghoul::Dictionary& dict,
const TileProviderInitData& initData);
std::array<LayerCategory, LayeredTextures::NUM_TEXTURE_CATEGORIES> _layerCategories;
std::array<TileProviderGroup, LayeredTextures::NUM_TEXTURE_CATEGORIES> _layerCategories;
};
} // namespace openspace

23
modules/globebrowsing/tile/tiledataset.cpp
View File

@@ -592,25 +592,22 @@ namespace openspace {
}
}
LDEBUG(indentation << "rasterIO read: " << io.read.region);
LDEBUG(indentation << "rasterIO write: " << io.write.region);
if (depth == 0) {
LDEBUG(indentation << "main rasterIO read: " << io.read.region);
LDEBUG(indentation << "main rasterIO write: " << io.write.region);
}
else if (worstError > CPLErr::CE_None) {
LDEBUG(indentation << "Error reading padding: " << worstError);
}
CPLErr err = rasterIO(rasterBand, io, dataDestination);
worstError = std::max(worstError, err);
// The return error from a repeated rasterIO is ONLY based on the main region,
// which in the usual case will cover the main area of the patch anyway
if (err > CPLErr::CE_None) {
if (depth == 0) {
LDEBUG(indentation << "Error reading main region: " << err);
}
}
else if (worstError > CPLErr::CE_None) {
//LDEBUG(indentation << "Error reading padding: " << worstError);
}
return err;
}