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

Add GPULayerManager and remove LayeredTextureShaderUniformIdHandler

Browse Source
This commit is contained in:
Erik Broberg
2016-10-25 18:07:21 +02:00
parent ac3b67e3bb
commit 3dfbb4e6bf
8 changed files with 76 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -75,10 +75,8 @@ namespace globebrowsing {
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_vs.glsl",
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_fs.glsl");
_globalProgramUniformHandler =
std::make_shared<LayeredTextureShaderUniformIdHandler>();
_localProgramUniformHandler =
std::make_shared<LayeredTextureShaderUniformIdHandler>();
_globalGpuLayerManager = std::make_shared<GPULayerManager>();
_localGpuLayerManager = std::make_shared<GPULayerManager>();
}
@@ -98,7 +96,7 @@ namespace globebrowsing {
ProgramObject* ChunkRenderer::getActivatedProgramWithTileData(
LayeredTextureShaderProvider* layeredTextureShaderProvider,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> programUniformHandler,
GPULayerManager * gpuLayerManager,
const Chunk& chunk)
{
const TileIndex& tileIndex = chunk.tileIndex();
@@ -121,7 +119,7 @@ namespace globebrowsing {
const auto& debugProps = chunk.owner().debugProperties();
auto& pairs = layeredTexturePreprocessingData.keyValuePairs;
pairs.push_back(std::make_pair("useAtmosphere",std::to_string(generalProps.atmosphereEnabled)));
pairs.push_back(std::make_pair("useAtmosphere", std::to_string(generalProps.atmosphereEnabled)));
pairs.push_back(std::make_pair("performShading", std::to_string(generalProps.performShading)));
pairs.push_back(std::make_pair("showChunkEdges", std::to_string(debugProps.showChunkEdges)));
pairs.push_back(std::make_pair("showHeightResolution", std::to_string(debugProps.showHeightResolution)));
@@ -134,24 +132,14 @@ namespace globebrowsing {
layeredTexturePreprocessingData);
if (layeredTextureShaderProvider->updatedOnLastCall()) {
// Need to update uniforms
programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider, _layerManager.get());
gpuLayerManager->updateUniformLocations(programObject, *_layerManager);
}
// Activate the shader program
programObject->activate();
// Go through all the categories
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
LayerGroup& layerGroup = _layerManager->layerGroup(category);
GPULayerGroup* gpuLayerGroup = programUniformHandler->gpuLayerGroup(category);
int pileSize = layerGroup.levelBlendingEnabled ? 3 : 1;
gpuLayerGroup->setValue(programObject, layerGroup, tileIndex);
}
gpuLayerManager->setValue(programObject, *_layerManager, tileIndex);
// The length of the skirts is proportional to its size
programObject->setUniform("skirtLength", min(static_cast<float>(chunk.surfacePatch().halfSize().lat * 1000000), 8700.0f));
@@ -168,7 +156,7 @@ namespace globebrowsing {
ProgramObject* programObject = getActivatedProgramWithTileData(
_globalRenderingShaderProvider.get(),
_globalProgramUniformHandler,
_globalGpuLayerManager.get(),
chunk);
if (programObject == nullptr) {
return;
@@ -237,14 +225,11 @@ namespace globebrowsing {
// render
_grid->geometry().drawUsingActiveProgram();
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
_globalProgramUniformHandler->gpuLayerGroup(i)->deactivate();
}
_globalGpuLayerManager->deactivate();
// disable shader
programObject->deactivate();
}
@@ -253,7 +238,7 @@ namespace globebrowsing {
ProgramObject* programObject = getActivatedProgramWithTileData(
_localRenderingShaderProvider.get(),
_localProgramUniformHandler,
_localGpuLayerManager.get(),
chunk);
if (programObject == nullptr) {
return;
@@ -324,9 +309,7 @@ namespace globebrowsing {
// render
_grid->geometry().drawUsingActiveProgram();
for (int i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; ++i) {
_localProgramUniformHandler->gpuLayerGroup(i)->deactivate();
}
_localGpuLayerManager->deactivate();
// disable shader
programObject->deactivate();

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

@@ -92,7 +92,7 @@ namespace globebrowsing {
ProgramObject* getActivatedProgramWithTileData(
LayeredTextureShaderProvider* layeredTextureShaderProvider,
std::shared_ptr<LayeredTextureShaderUniformIdHandler> programUniformHandler,
GPULayerManager * gpuLayerManager,
const Chunk& chunk);
// shared pointer to a grid which can be the same for all rendered chunks.
@@ -104,8 +104,8 @@ namespace globebrowsing {
std::shared_ptr<LayeredTextureShaderProvider> _localRenderingShaderProvider;
// Layered texture uniforms are chached in the uniform ID handles.
std::shared_ptr<LayeredTextureShaderUniformIdHandler> _globalProgramUniformHandler;
std::shared_ptr<LayeredTextureShaderUniformIdHandler> _localProgramUniformHandler;
std::shared_ptr<GPULayerManager> _globalGpuLayerManager;
std::shared_ptr<GPULayerManager> _localGpuLayerManager;
};
} // namespace globebrowsing

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

@@ -39,14 +39,8 @@ namespace {
namespace openspace {
namespace globebrowsing {
LayeredTexturePreprocessingData::LayeredTexturePreprocessingData(LayerManager* tpm){
}
bool LayeredTextureInfo::operator==(const LayeredTextureInfo& other) const
{
return
lastLayerIdx == other.lastLayerIdx &&
bool LayeredTextureInfo::operator==(const LayeredTextureInfo& other) const {
return lastLayerIdx == other.lastLayerIdx &&
layerBlendingEnabled == other.layerBlendingEnabled;
}
@@ -154,37 +148,5 @@ namespace globebrowsing {
return _updatedOnLastCall;
}
LayeredTextureShaderUniformIdHandler::LayeredTextureShaderUniformIdHandler(){
for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++) {
_gpuLayerGroups[i] = std::make_unique<GPULayerGroup>();
}
}
LayeredTextureShaderUniformIdHandler::~LayeredTextureShaderUniformIdHandler()
{}
GPULayerGroup* LayeredTextureShaderUniformIdHandler::gpuLayerGroup(int i) const{
return _gpuLayerGroups[i].get();
}
void LayeredTextureShaderUniformIdHandler::updateIdsIfNecessary(
LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager) {
if (shaderProvider->updatedOnLastCall()) {
ProgramObject* programObject = shaderProvider->_programObject.get();
for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++) {
LayerGroup& layerGroup = layerManager->layerGroup(i);
std::string nameBase = LayeredTextures::TEXTURE_CATEGORY_NAMES[i];
_gpuLayerGroups[i]->updateUniformLocations(programObject, layerGroup, nameBase, i);
}
// Reset ignore errors
programObject->setIgnoreUniformLocationError(
ProgramObject::IgnoreError::No);
}
}
} // namespace globebrowsing
} // namespace openspace

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

@@ -43,8 +43,6 @@ namespace globebrowsing {
class LayerManager;
class LayeredTextureShaderUniformIdHandler;
/**
* Settings per texture category that contains shader preprocessing information.
*/
@@ -67,7 +65,6 @@ namespace globebrowsing {
* levels.
*/
struct LayeredTexturePreprocessingData {
LayeredTexturePreprocessingData(LayerManager* tpm = nullptr);
std::array<LayeredTextureInfo, LayeredTextures::NUM_TEXTURE_CATEGORIES>
layeredTextureInfo;
@@ -101,8 +98,6 @@ namespace globebrowsing {
private:
friend class LayeredTextureShaderUniformIdHandler;
void recompileShaderProgram(LayeredTexturePreprocessingData preprocessingData);
std::unique_ptr<ProgramObject> _programObject;
@@ -115,24 +110,6 @@ namespace globebrowsing {
bool _updatedOnLastCall;
};
/**
* This class caches OpenGL uniform IDs for <code>LayeredTextureShaderProvider</code>s.
*/
class LayeredTextureShaderUniformIdHandler
{
public:
LayeredTextureShaderUniformIdHandler();
~LayeredTextureShaderUniformIdHandler();
void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager);
ProgramObject& programObject();
GPULayerGroup* gpuLayerGroup(int i) const;
private:
std::array<std::unique_ptr<GPULayerGroup>, LayeredTextures::NUM_TEXTURE_CATEGORIES> _gpuLayerGroups;
};
} // namespace globebrowsing
} // namespace openspace

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

@@ -192,5 +192,39 @@ namespace globebrowsing {
}
// LayerManager
void GPULayerManager::setValue(ProgramObject* programObject, const LayerManager& layerManager, const TileIndex& tileIndex){
auto layerGroups = layerManager.layerGroups();
for (size_t i = 0; i < layerGroups.size(); ++i){
std::string nameBase = LayeredTextures::TEXTURE_CATEGORY_NAMES[i];
gpuLayerGroups[i]->setValue(programObject, *layerGroups[i], tileIndex);
}
}
void GPULayerManager::updateUniformLocations(ProgramObject* programObject, const LayerManager& layerManager){
auto layerGroups = layerManager.layerGroups();
if(gpuLayerGroups.size() != layerGroups.size()){
gpuLayerGroups.resize(layerGroups.size());
for(auto& gpuLayerGroup : gpuLayerGroups){
gpuLayerGroup = std::make_unique<GPULayerGroup>();
}
}
for (size_t i = 0; i < layerGroups.size(); ++i){
std::string nameBase = LayeredTextures::TEXTURE_CATEGORY_NAMES[i];
gpuLayerGroups[i]->updateUniformLocations(programObject, *layerGroups[i], nameBase, i);
}
}
void GPULayerManager::deactivate(){
for (size_t i = 0; i < gpuLayerGroups.size(); ++i){
gpuLayerGroups[i]->deactivate();
}
}
} // namespace globebrowsing
} // namespace openspace

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

@@ -147,6 +147,17 @@ private:
};
class LayerManager;
class GPULayerManager{
public:
virtual void setValue(ProgramObject* programObject, const LayerManager& layerManager, const TileIndex& tileIndex);
virtual void updateUniformLocations(ProgramObject* programObject, const LayerManager& layerManager);
virtual void deactivate();
private:
std::vector<std::unique_ptr<GPULayerGroup>> gpuLayerGroups;
};
} // namespace globebrowsing
} // namespace openspace

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

@@ -158,10 +158,10 @@ namespace globebrowsing {
initData.preprocessTiles = i == LayeredTextures::HeightMaps;
std::string groupName = LayeredTextures::TEXTURE_CATEGORY_NAMES[i];
layerGroups.push_back(std::make_shared<LayerGroup>(groupName, texturesDict));
_layerGroups.push_back(std::make_shared<LayerGroup>(groupName, texturesDict));
}
for(auto layerGroup : layerGroups){
for(auto layerGroup : _layerGroups){
addPropertySubOwner(layerGroup.get());
}
}
@@ -171,21 +171,26 @@ namespace globebrowsing {
}
LayerGroup& LayerManager::layerGroup(size_t groupId) {
return *layerGroups[groupId];
return *_layerGroups[groupId];
}
LayerGroup& LayerManager::layerGroup(LayeredTextures::TextureCategory category) {
return *layerGroups[category];
return *_layerGroups[category];
}
const std::vector<std::shared_ptr<LayerGroup>>& LayerManager::layerGroups() const {
return _layerGroups;
}
void LayerManager::update() {
for (auto& layerGroup : layerGroups) {
for (auto& layerGroup : _layerGroups) {
layerGroup->update();
}
}
void LayerManager::reset(bool includeDisabled) {
for (auto& layerGroup : layerGroups) {
for (auto& layerGroup : _layerGroups) {
for (auto layer : layerGroup->layers) {
if (layer->enabled() || includeDisabled) {
layer->tileProvider()->reset();

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

@@ -111,12 +111,14 @@ namespace globebrowsing {
LayerGroup& layerGroup(size_t groupId);
LayerGroup& layerGroup(LayeredTextures::TextureCategory);
const std::vector<std::shared_ptr<LayerGroup>>& layerGroups() const;
void update();
void reset(bool includingInactive = false);
private:
std::vector<std::shared_ptr<LayerGroup>> layerGroups;
std::vector<std::shared_ptr<LayerGroup>> _layerGroups;
};