mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-03-13 17:09:05 -05:00
Code Issues Packages Projects Releases Wiki Activity

Intermediate commit: pre shader refactorization

Browse Source
This commit is contained in:
Erik Broberg
2016-10-20 18:54:44 +02:00
parent 2af1731583
commit fd6dd16417
16 changed files with 180 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -97,13 +97,14 @@ namespace globebrowsing {
}
void ChunkRenderer::setDepthTransformUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
size_t layerIndex,
const TileDepthTransform& tileDepthTransform)
{
uniformIdHandler->programObject().setUniform(
programObject->setUniform(
uniformIdHandler->getId(
textureCategory,
blendLayerSuffix,
@@ -111,7 +112,7 @@ namespace globebrowsing {
LayeredTextures::GlslTileDataId::depthTransform_depthScale),
tileDepthTransform.depthScale);
uniformIdHandler->programObject().setUniform(
programObject->setUniform(
uniformIdHandler->getId(
textureCategory,
blendLayerSuffix,
@@ -122,6 +123,7 @@ namespace globebrowsing {
}
void ChunkRenderer::activateTileAndSetTileUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -134,21 +136,21 @@ namespace globebrowsing {
texUnit.activate();
chunkTile.tile.texture->bind();
uniformIdHandler->programObject().setUniform(
programObject->setUniform(
uniformIdHandler->getId(
textureCategory,
blendLayerSuffix,
layerIndex,
LayeredTextures::GlslTileDataId::textureSampler),
texUnit);
uniformIdHandler->programObject().setUniform(
programObject->setUniform(
uniformIdHandler->getId(
textureCategory,
blendLayerSuffix,
layerIndex,
LayeredTextures::GlslTileDataId::uvTransform_uvScale),
chunkTile.uvTransform.uvScale);
uniformIdHandler->programObject().setUniform(
programObject->setUniform(
uniformIdHandler->getId(
textureCategory,
blendLayerSuffix,
@@ -158,6 +160,7 @@ namespace globebrowsing {
}
void ChunkRenderer::setLayerSettingsUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
size_t layerIndex,
@@ -165,7 +168,7 @@ namespace globebrowsing {
for (int i = 0; i < settings.array().size(); i++) {
settings.array()[i]->uploadUniform(
uniformIdHandler->programObject(),
*programObject,
uniformIdHandler->getSettingsId(
textureCategory,
layerIndex,
@@ -229,7 +232,11 @@ namespace globebrowsing {
layeredTextureShaderProvider->getUpdatedShaderProgram(
layeredTexturePreprocessingData);
programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider);
if (layeredTextureShaderProvider->updatedOnLastCall()) {
// Need to update uniforms
programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider, _layerManager.get());
}
// Activate the shader program
programObject->activate();
@@ -248,54 +255,18 @@ namespace globebrowsing {
// Go through all the categories
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
// Go through all the providers in this category
LayerGroup& layerGroup = _layerManager->layerGroup(category);
int i = 0;
for (const Layer& layer : _layerManager->layerGroup(category).activeLayers()) {
for (const Layer& layer : layerGroup.activeLayers()) {
TileProvider* tileProvider = layer.tileProvider.get();
// Get the texture that should be used for rendering
ChunkTile chunkTile = TileSelector::getHighestResolutionTile(tileProvider, tileIndex);
if (chunkTile.tile.status == Tile::Status::Unavailable) {
chunkTile.tile = tileProvider->getDefaultTile();
chunkTile.uvTransform.uvOffset = { 0, 0 };
chunkTile.uvTransform.uvScale = { 1, 1 };
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextures::BlendLayerSuffixes::none,
i,
texUnits[category][i].blendTexture0,
chunkTile);
// If blending is enabled, two more textures are needed
if (layeredTexturePreprocessingData.layeredTextureInfo[category].layerBlendingEnabled) {
ChunkTile chunkTileParent1 = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, 1);
if (chunkTileParent1.tile.status == Tile::Status::Unavailable) {
chunkTileParent1 = chunkTile;
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextures::BlendLayerSuffixes::Parent1,
i,
texUnits[category][i].blendTexture1,
chunkTileParent1);
ChunkTile chunkTileParent2 = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, 2);
if (chunkTileParent2.tile.status == Tile::Status::Unavailable) {
chunkTileParent2 = chunkTileParent1;
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextures::BlendLayerSuffixes::Parent2,
i,
texUnits[category][i].blendTexture2,
chunkTileParent2);
}
int pileSize = layeredTexturePreprocessingData.layeredTextureInfo[category].layerBlendingEnabled ? 3 : 1;
ChunkTilePile chunkTilePile = TileSelector::getHighestResolutionTilePile(tileProvider, tileIndex, pileSize);
programUniformHandler->_gpuLayerGroups[category].gpuActiveLayers[i].setValue(programObject, chunkTilePile);
setLayerSettingsUniforms(
programObject,
programUniformHandler,
LayeredTextures::TextureCategory(category),
i,
@@ -321,6 +292,7 @@ namespace globebrowsing {
for (const Layer& heightLayer : heightLayers) {
TileDepthTransform depthTransform = heightLayer.tileProvider->depthTransform();
setDepthTransformUniforms(
programObject,
programUniformHandler,
LayeredTextures::TextureCategory::HeightMaps,
LayeredTextures::BlendLayerSuffixes::none,
@@ -409,11 +381,19 @@ namespace globebrowsing {
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
TileIndex ti(2,2,2);
TileProvider* tp = _layerManager->layerGroup(0).activeLayers()[0].tileProvider.get();
ChunkTilePile tilePile = TileSelector::getHighestResolutionTilePile(tp, ti);
_globalRenderingShaderProvider->gpuChunkTilePile.updateUniformLocations(programObject, "test.");
_globalRenderingShaderProvider->gpuChunkTilePile.setValue(programObject, tilePile);
/*
TileIndex ti(5,5,5);
const auto& layers = _layerManager->layerGroup(0).activeLayers();
if(layers.size() > 0){
TileProvider* tp = layers[0].tileProvider.get();
int pileSize = _layerManager->layerGroup(0).levelBlendingEnabled ? 3 : 1;
ChunkTilePile tilePile = TileSelector::getHighestResolutionTilePile(tp, ti, pileSize);
auto& gpuChunkTilePile = _globalRenderingShaderProvider->gpuChunkTilePile;
gpuChunkTilePile.updateUniformLocations(programObject, "test.", pileSize);
gpuChunkTilePile.setValue(programObject, tilePile);
}
*/
// render
_grid->geometry().drawUsingActiveProgram();

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

@@ -90,6 +90,7 @@ namespace globebrowsing {
void renderChunkLocally(const Chunk& chunk, const RenderData& data);
void setDepthTransformUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -97,6 +98,7 @@ namespace globebrowsing {
const TileDepthTransform& tileDepthTransform);
void activateTileAndSetTileUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -105,6 +107,7 @@ namespace globebrowsing {
const ChunkTile& chunkTile);
void setLayerSettingsUniforms(
ProgramObject* programObject,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
LayeredTextures::TextureCategory textureCategory,
size_t layerIndex,

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

@@ -95,6 +95,7 @@ namespace globebrowsing {
for (auto setting : layer.settings.array()) {
prop.addProperty(setting->property());
}
addPropertySubOwner(prop);
}

15
modules/globebrowsing/layered_rendering/layeredtextures.cpp
View File

@@ -85,22 +85,19 @@ namespace globebrowsing {
PerLayerSettings::PerLayerSettings()
{
// Here, all the per layer settings are specified and added
_array[LayeredTextures::LayerSettingsIds::opacity] =
std::make_shared<PerLayerFloatSetting>(
_array[LayeredTextures::LayerSettingsIds::opacity] = std::make_shared<PerLayerFloatSetting>(
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::opacity],
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::opacity],
1,
0,
1);
_array[LayeredTextures::LayerSettingsIds::gamma] =
std::make_shared<PerLayerFloatSetting>(
_array[LayeredTextures::LayerSettingsIds::gamma] = std::make_shared<PerLayerFloatSetting>(
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::gamma],
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::gamma],
1,
0,
5);
_array[LayeredTextures::LayerSettingsIds::multiplier] =
std::make_shared<PerLayerFloatSetting>(
_array[LayeredTextures::LayerSettingsIds::multiplier] = std::make_shared<PerLayerFloatSetting>(
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::multiplier],
LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::multiplier],
1,
@@ -119,7 +116,7 @@ namespace globebrowsing {
const std::array<std::shared_ptr<PerLayerSetting>,
LayeredTextures::NUM_LAYER_SETTINGS_VARIABLES>& PerLayerSettings::array() const {
return _array;
}
}
} // namespace globebrowsing
} // namespace openspace
} // namespace globebrowsing
} // namespace openspace

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

@@ -161,33 +161,24 @@ namespace globebrowsing {
{}
void LayeredTextureShaderUniformIdHandler::updateIdsIfNecessary(
LayeredTextureShaderProvider* shaderProvider)
{
if (shaderProvider->updatedOnLastCall())
{
_shaderProvider = shaderProvider;
// Ignore errors since this loops through even uniforms that does not exist.
_shaderProvider->_programObject->setIgnoreUniformLocationError(
ProgramObject::IgnoreError::Yes);
for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++)
{
for (size_t j = 0; j < LayeredTextures::NUM_BLEND_TEXTURES; j++)
{
for (size_t k = 0; k < LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY;
k++)
{
for (size_t l = 0; l < LayeredTextures::NUM_TILE_DATA_VARIABLES; l++)
{
_tileUniformIds[i][j][k][l] =
_shaderProvider->_programObject->uniformLocation(
LayeredTextures::TEXTURE_CATEGORY_NAMES[i] +
LayeredTextures::blendLayerSuffixes[j] +
"[" + std::to_string(k) + "]." +
LayeredTextures::glslTileDataNames[l]);
}
}
}
LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager) {
if (shaderProvider->updatedOnLastCall()) {
ProgramObject* programObject = shaderProvider->_programObject.get();
programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::No);
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
LayerGroup& layerGroup = layerManager->layerGroup(category);
std::string nameBase = LayeredTextures::TEXTURE_CATEGORY_NAMES[category];
int pileSize = layerGroup.levelBlendingEnabled ? 3 : 1;
int numActiveLayers = layerGroup.activeLayers().size();
_gpuLayerGroups[category].updateUniformLocations(programObject, nameBase, pileSize, numActiveLayers);
}
// Ignore errors since this loops through even uniforms that does not exist.
programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::Yes);
for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++)
{
for (size_t k = 0; k < LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY;
@@ -196,7 +187,7 @@ namespace globebrowsing {
for (size_t l = 0; l < LayeredTextures::NUM_LAYER_SETTINGS_VARIABLES; l++)
{
_layerSettingsUniformIds[i][k][l] =
_shaderProvider->_programObject->uniformLocation(
programObject->uniformLocation(
LayeredTextures::TEXTURE_CATEGORY_NAMES[i] +
"Settings" +
"[" + std::to_string(k) + "]." +
@@ -205,7 +196,7 @@ namespace globebrowsing {
}
}
// Reset ignore errors
_shaderProvider->_programObject->setIgnoreUniformLocationError(
programObject->setIgnoreUniformLocationError(
ProgramObject::IgnoreError::No);
}
}
@@ -226,11 +217,5 @@ namespace globebrowsing {
{
return _layerSettingsUniformIds[category][layerIndex][layerSettingsId];
}
ProgramObject& LayeredTextureShaderUniformIdHandler::programObject()
{
return *_shaderProvider->_programObject;
}
} // namespace globebrowsing
} // namespace openspace

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

@@ -28,6 +28,7 @@
#include <modules/globebrowsing/layered_rendering/layeredtextures.h>
#include <modules/globebrowsing/tile/gpustructs.h>
#include <modules/globebrowsing/tile/layermanager.h>
#include "ghoul/opengl/programobject.h"
@@ -98,7 +99,6 @@ namespace globebrowsing {
bool updatedOnLastCall();
GPUChunkTilePile gpuChunkTilePile;
private:
@@ -124,7 +124,7 @@ namespace globebrowsing {
LayeredTextureShaderUniformIdHandler();
~LayeredTextureShaderUniformIdHandler();
void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider);
void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager);
/**
* \param <code>category</code> can be one of the categories specified in
@@ -152,6 +152,8 @@ namespace globebrowsing {
size_t layerIndex,
LayeredTextures::LayerSettingsIds layerSettingsId);
ProgramObject& programObject();
std::array<GPULayerGroup, LayeredTextures::NUM_TEXTURE_CATEGORIES> _gpuLayerGroups;
private:
std::array<
@@ -164,6 +166,9 @@ namespace globebrowsing {
LayeredTextures::NUM_BLEND_TEXTURES>,
LayeredTextures::NUM_TEXTURE_CATEGORIES>
_tileUniformIds;
std::array<
std::array<
@@ -173,8 +178,6 @@ namespace globebrowsing {
LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY>,
LayeredTextures::NUM_TEXTURE_CATEGORIES>
_layerSettingsUniformIds;
LayeredTextureShaderProvider* _shaderProvider;
};
} // namespace globebrowsing

28
modules/globebrowsing/shaders/tile.hglsl
View File

@@ -71,12 +71,6 @@ struct Tile {
TileUvTransform uvTransform;
};
struct ChunkTilePile {
Tile chunkTile0;
Tile chunkTile1;
Tile chunkTile2;
};
vec2 compensateSourceTextureSampling(vec2 startOffset, vec2 sizeDiff, const Tile tile, vec2 tileUV){
ivec2 resolution = textureSize(tile.textureSampler, 0);
@@ -104,10 +98,10 @@ vec4 getTexVal(const Tile tile, vec2 tileUV){
/////////////////////////////////////////////////////////////////////
// Multi Level Tile //
/////////////////////////////////////////////////////////////////////
struct MultiLevelTile {
Tile tile0;
Tile tile1;
Tile tile2;
struct MultiChunkTile {
Tile level0;
Tile level1;
Tile level2;
};
struct LevelWeights {
@@ -139,16 +133,10 @@ LevelWeights getDefaultLevelWeights(){
}
vec4 getTexVal(const MultiLevelTile multiLevelTile, const LevelWeights w, const vec2 uv){
return w.w1 * getTexVal(multiLevelTile.tile0, uv) +
w.w2 * getTexVal(multiLevelTile.tile1, uv) +
w.w3 * getTexVal(multiLevelTile.tile2, uv);
}
vec4 getTexVal(const ChunkTilePile chunkTilePine, const LevelWeights w, const vec2 uv){
return w.w1 * getTexVal(chunkTilePine.chunkTile0, uv) +
w.w2 * getTexVal(chunkTilePine.chunkTile1, uv) +
w.w3 * getTexVal(chunkTilePine.chunkTile2, uv);
vec4 getTexVal(const MultiChunkTile multiChunkTile, const LevelWeights w, const vec2 uv){
return w.w1 * getTexVal(multiChunkTile.level0, uv) +
w.w2 * getTexVal(multiChunkTile.level1, uv) +
w.w3 * getTexVal(multiChunkTile.level2, uv);
}
// PerLayerSettings

2
modules/globebrowsing/shaders/tilefragcolor.hglsl
View File

@@ -98,7 +98,6 @@ in vec3 positionCameraSpace;
// The value increases with the distance from the vertex (or fragment) to the camera
in LevelWeights levelWeights;
uniform ChunkTilePile test;
/////////////////////////////////////////////////////////////////////
@@ -269,7 +268,6 @@ vec4 getTileFragColor(){
#endif
#endif
color = 0.1*color + getTexVal(test, levelWeights, fs_uv);
return color;
}

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

@@ -46,7 +46,7 @@ namespace globebrowsing {
struct ChunkTilePile {
static const size_t SIZE = 3;
std::array<ChunkTile, SIZE> chunkTiles;
std::vector<ChunkTile> chunkTiles;
};
} // namespace globebrowsing

36
modules/globebrowsing/tile/gpustructs.cpp
View File

@@ -24,10 +24,11 @@
#include <modules/globebrowsing/tile/gpustructs.h>
#include <modules/globebrowsing/tile/tileIndex.h>
#include <modules/globebrowsing/tile/chunktile.h>
#include <modules/globebrowsing/tile/tileselector.h>
#include <modules/globebrowsing/tile/tileselector.h>
#include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
#include <modules/globebrowsing/tile/layermanager.h>
#include <modules/globebrowsing/layered_rendering/layeredtextures.h>
@@ -89,15 +90,36 @@ namespace globebrowsing {
// ChunkTilePile
void GPUChunkTilePile::setValue(ProgramObject* programObject, const ChunkTilePile& chunkTilePile){
for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
gpuChunkTilePile[i].setValue(programObject, chunkTilePile.chunkTiles[i]);
ghoul_assert(gpuChunkTiles.size() == chunkTilePile.chunkTiles.size(), "GPU and CPU ChunkTilePile must have same size!");
for (size_t i = 0; i < gpuChunkTiles.size(); ++i){
gpuChunkTiles[i].setValue(programObject, chunkTilePile.chunkTiles[i]);
}
}
void GPUChunkTilePile::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase){
for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
std::string nameExtension = "chunkTile" + std::to_string(i) + ".";
gpuChunkTilePile[i].updateUniformLocations(programObject, nameBase + nameExtension);
void GPUChunkTilePile::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize){
gpuChunkTiles.resize(pileSize);
for (size_t i = 0; i < gpuChunkTiles.size(); ++i){
std::string nameExtension = "level" + std::to_string(i) + ".";
gpuChunkTiles[i].updateUniformLocations(programObject, nameBase + nameExtension);
}
}
// LayerGroup
void GPULayerGroup::setValue(ProgramObject* programObject, const LayerGroup& layerGroup){
size_t numActiveLayers = layerGroup.activeLayers().size();
ghoul_assert(numActiveLayers == gpuActiveLayers.size(), "GPU and CPU active layers must have same size!");
for (int i = 0; i < numActiveLayers; ++i){
//gpuActiveLayers[i].setValue(programObject, layerGroup.activeLayers()[i]);
}
}
void GPULayerGroup::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize, int numActiveLayers){
gpuActiveLayers.resize(numActiveLayers);
for (size_t i = 0; i < gpuActiveLayers.size(); ++i){
std::string nameExtension = "[" + std::to_string(i) + "].";
gpuActiveLayers[i].updateUniformLocations(programObject, nameBase + nameExtension, pileSize);
}
}

31
modules/globebrowsing/tile/gpustructs.h
View File

@@ -30,7 +30,7 @@
#include <glm/glm.hpp>
#include <array>
#include <vector>
namespace ghoul{
@@ -88,10 +88,35 @@ class GPUChunkTilePile{
public:
void setValue(ProgramObject* programObject, const ChunkTilePile& chunkTilePile);
void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase);
void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize);
private:
std::array<GPUChunkTile, ChunkTilePile::SIZE> gpuChunkTilePile;
std::vector<GPUChunkTile> gpuChunkTiles;
};
class LayerSettings;
class GPULayerSettings{
public:
void setValue(ProgramObject* programObject, const LayerSettings& layerSettings);
void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase);
private:
GPUData<int> gpu_hej;
GPUData<float> gpu_tja;
GPUData<bool> gpu_senare;
};
class LayerGroup;
class GPULayerGroup{
public:
void setValue(ProgramObject* programObject, const LayerGroup& layerGroup);
void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize, int numActiveLayers);
std::vector<GPUChunkTilePile> gpuActiveLayers;
};

6
modules/globebrowsing/tile/layermanager.cpp
View File

@@ -26,6 +26,8 @@
#include <modules/globebrowsing/tile/layermanager.h>
#include <openspace/properties/scalarproperty.h>
#include <ghoul/logging/logmanager.h>
#include "cpl_minixml.h"
@@ -36,8 +38,10 @@ namespace {
namespace openspace {
namespace globebrowsing {
//////////////////////////////////////////////////////////////////////////////////////
// Tile Provider Group //
// Layer Group //
//////////////////////////////////////////////////////////////////////////////////////
void LayerGroup::update() {

27
modules/globebrowsing/tile/layermanager.h
View File

@@ -32,6 +32,8 @@
#include <ghoul/misc/dictionary.h>
#include <ghoul/misc/assert.h>
#include <openspace/util/gpudata.h>
#include <memory>
#include <vector>
#include <string>
@@ -39,12 +41,37 @@
namespace openspace {
namespace globebrowsing {
template<typename T> class LayerSetting;
class ILayerSetting{
public:
virtual void setValue(ProgramObject* programObject) = 0;
};
template<typename T>
class LayerSetting : public ILayerSetting {
public:
LayerSetting(T t): data(t) {}
virtual void setValue(ProgramObject* programObject) override {
gpuData.setValue(programObject, data);
}
private:
GPUData<T> gpuData;
T data;
};
struct Layer {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
bool isActive;
PerLayerSettings settings;
std::vector<ILayerSetting*> isettings;
};
struct LayerGroup {

19
modules/globebrowsing/tile/tileselector.cpp
View File

@@ -23,10 +23,10 @@
****************************************************************************************/
#include <modules/globebrowsing/tile/tileselector.h>
#include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
#include <ghoul/logging/logmanager.h>
#include <ghoul/misc/assert.h>
#include <sstream>
#include <algorithm>
@@ -42,19 +42,16 @@ namespace globebrowsing {
const TileSelector::CompareResolution TileSelector::HIGHEST_RES = TileSelector::CompareResolution();
ChunkTilePile TileSelector::getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex){
ChunkTilePile TileSelector::getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex, int pileSize){
ghoul_assert(pileSize >= 0, "pileSize must be positive");
ChunkTilePile chunkTilePile;
for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
chunkTilePile.chunkTiles.resize(pileSize);
for (size_t i = 0; i < pileSize; ++i){
chunkTilePile.chunkTiles[i] = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, i);
if (chunkTilePile.chunkTiles[i].tile.status == Tile::Status::Unavailable) {
if(i>0){
chunkTilePile.chunkTiles[i] = chunkTilePile.chunkTiles[i-1];
}
else{
chunkTilePile.chunkTiles[i].tile = tileProvider->getDefaultTile();
chunkTilePile.chunkTiles[i].uvTransform.uvOffset = { 0, 0 };
chunkTilePile.chunkTiles[i].uvTransform.uvScale = { 1, 1 };
}
chunkTilePile.chunkTiles[i].tile = tileProvider->getDefaultTile();
chunkTilePile.chunkTiles[i].uvTransform.uvOffset = { 0, 0 };
chunkTilePile.chunkTiles[i].uvTransform.uvScale = { 1, 1 };
}
}
return std::move(chunkTilePile);

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

@@ -39,7 +39,7 @@ namespace globebrowsing {
public:
static ChunkTile getHighestResolutionTile(TileProvider* tileProvider, TileIndex tileIndex, int parents = 0);
static ChunkTile getHighestResolutionTile(const LayerGroup& layerGroup, TileIndex tileIndex);
static ChunkTilePile getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex);
static ChunkTilePile getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex, int pileSize);
static std::vector<ChunkTile> getTilesSortedByHighestResolution(const LayerGroup&, const TileIndex& tileIndex);
struct CompareResolution {

2
src/util/gpudata.cpp
View File

@@ -43,7 +43,7 @@ namespace openspace {
void UpdatableUniformLocation::updateUniformLocations(ProgramObject* program, const std::string& name){
_uniformLocation = program->uniformLocation(name);
LDEBUG(name);
}
}
} // namespace openspace