diff --git a/data/scene/debugglobe/debugglobe.mod b/data/scene/debugglobe/debugglobe.mod index e611120d09..6f238a9064 100644 --- a/data/scene/debugglobe/debugglobe.mod +++ b/data/scene/debugglobe/debugglobe.mod @@ -32,54 +32,59 @@ return { SegmentsPerPatch = 64, Textures = { ColorTextures = { - { - Name = "Temporal VIIRS SNPP", - FilePath = "map_service_configs/Temporal_VIIRS_SNPP_CorrectedReflectance_TrueColor.xml" - }, - { - Name = "Temporal MODIS Aqua CorrectedRecflectance TrueColor", - FilePath = "map_service_configs/Temporal_MODIS_Aqua_CorrectedReflectance_TrueColor.xml" - }, - { - Name = "MODIS_Terra_CorrectedReflectance_TrueColor", - FilePath = "map_service_configs/MODIS_Terra_CorrectedReflectance_TrueColor.xml" - }, - { - Name = "ESRI Imagery World 2D", - FilePath = "map_service_configs/ESRI_Imagery_World_2D.wms", - }, + { + Name = "Temporal VIIRS SNPP", + FilePath = "map_service_configs/Temporal_VIIRS_SNPP_CorrectedReflectance_TrueColor.xml" + }, + { + Name = "Temporal MODIS Aqua CorrectedRecflectance TrueColor", + FilePath = "map_service_configs/Temporal_MODIS_Aqua_CorrectedReflectance_TrueColor.xml" + }, + { + Name = "MODIS_Terra_CorrectedReflectance_TrueColor", + FilePath = "map_service_configs/MODIS_Terra_CorrectedReflectance_TrueColor.xml" + }, + + { + Name = "ESRI Imagery World 2D", + FilePath = "map_service_configs/ESRI_Imagery_World_2D.wms", + }, }, NightTextures = { - { - Name = "Earth at Night 2012", - FilePath = "map_service_configs/VIIRS_CityLights_2012.xml", + + { + Name = "Earth at Night 2012", + FilePath = "map_service_configs/VIIRS_CityLights_2012.xml", + }, }, - }, HeightMaps = { - { - Name = "Terrain tileset", - FilePath = "map_service_configs/TERRAIN.wms", - }, + + { + Name = "Terrain tileset", + FilePath = "map_service_configs/TERRAIN.wms", + }, }, WaterMasks = { - { - Name = "MODIS_Water_Mask", - FilePath = "map_service_configs/MODIS_Water_Mask.xml" + + { + Name = "MODIS_Water_Mask", + FilePath = "map_service_configs/MODIS_Water_Mask.xml" + }, }, - }, Overlays = { - { - Name = "Coastlines", - FilePath = "map_service_configs/Coastlines.xml", - }, - { - Name = "Reference_Features", - FilePath = "map_service_configs/Reference_Features.xml", - }, - { - Name = "Reference_Labels", - FilePath = "map_service_configs/Reference_Labels.xml", - }, + + { + Name = "Coastlines", + FilePath = "map_service_configs/Coastlines.xml", + }, + { + Name = "Reference_Features", + FilePath = "map_service_configs/Reference_Features.xml", + }, + { + Name = "Reference_Labels", + FilePath = "map_service_configs/Reference_Labels.xml", + }, }, }, }, diff --git a/modules/globebrowsing/CMakeLists.txt b/modules/globebrowsing/CMakeLists.txt index d8bc91a8ec..d37bb04201 100644 --- a/modules/globebrowsing/CMakeLists.txt +++ b/modules/globebrowsing/CMakeLists.txt @@ -52,6 +52,7 @@ set(HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.h ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.h ${CMAKE_CURRENT_SOURCE_DIR}/tile/layeredtextureshaderprovider.h + ${CMAKE_CURRENT_SOURCE_DIR}/tile/layeredtextures.h ${CMAKE_CURRENT_SOURCE_DIR}/other/distanceswitch.h ${CMAKE_CURRENT_SOURCE_DIR}/other/lrucache.h @@ -89,6 +90,7 @@ set(SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tile/asynctilereader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tile/tileprovidermanager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tile/layeredtextureshaderprovider.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/tile/layeredtextures.cpp ${CMAKE_CURRENT_SOURCE_DIR}/other/distanceswitch.cpp ${CMAKE_CURRENT_SOURCE_DIR}/other/lrucache.inl diff --git a/modules/globebrowsing/chunk/chunk.cpp b/modules/globebrowsing/chunk/chunk.cpp index 943f2a3f8d..61a75e34b0 100644 --- a/modules/globebrowsing/chunk/chunk.cpp +++ b/modules/globebrowsing/chunk/chunk.cpp @@ -29,6 +29,7 @@ #include #include +#include #include @@ -201,7 +202,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("HeightMaps"); + auto heightMapProviders = tileProvidermanager->getActivatedLayerCategory(LayeredTextures::HeightMaps); if (heightMapProviders.size() > 0) { TileAndTransform tileAndTransform = heightMapProviders[0]->getHighestResolutionTile(_index); if (tileAndTransform.tile.status == Tile::Status::OK) { diff --git a/modules/globebrowsing/chunk/chunkrenderer.cpp b/modules/globebrowsing/chunk/chunkrenderer.cpp index dd654a5e77..173035f460 100644 --- a/modules/globebrowsing/chunk/chunkrenderer.cpp +++ b/modules/globebrowsing/chunk/chunkrenderer.cpp @@ -25,6 +25,7 @@ #include #include +#include // open space includes #include @@ -60,17 +61,24 @@ namespace openspace { : _tileProviderManager(tileProviderManager) , _grid(grid) { - _globalRenderingShaderProvider = std::unique_ptr + _globalRenderingShaderProvider = std::shared_ptr (new LayeredTextureShaderProvider( "GlobalChunkedLodPatch", "${MODULE_GLOBEBROWSING}/shaders/globalchunkedlodpatch_vs.glsl", "${MODULE_GLOBEBROWSING}/shaders/globalchunkedlodpatch_fs.glsl")); - _localRenderingShaderProvider = std::unique_ptr + _localRenderingShaderProvider = std::shared_ptr (new LayeredTextureShaderProvider( "LocalChunkedLodPatch", "${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_vs.glsl", "${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_fs.glsl")); + + _globalProgramUniformHandler = std::shared_ptr + (new LayeredTextureShaderUniformIdHandler()); + + _localProgramUniformHandler = std::shared_ptr + (new LayeredTextureShaderUniformIdHandler()); + } void ChunkRenderer::renderChunk(const Chunk& chunk, const RenderData& data) { @@ -88,20 +96,36 @@ namespace openspace { void ChunkRenderer::setDepthTransformUniforms( - ProgramObject* programObject, const std::string& indexedTileKey, const TileDepthTransform& tileDepthTransform) + std::shared_ptr uniformIdHandler, + LayeredTextures::TextureCategory textureCategory, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix blendLayerSuffix, + size_t layerIndex, + const TileDepthTransform& tileDepthTransform) { - programObject->setUniform( - indexedTileKey + ".depthTransform.depthScale", + uniformIdHandler->programObject().setUniform( + uniformIdHandler->getId( + textureCategory, + blendLayerSuffix, + layerIndex, + LayeredTextureShaderUniformIdHandler::GlslTileDataId::depthTransform_depthScale), tileDepthTransform.depthScale); - programObject->setUniform( - indexedTileKey + ".depthTransform.depthOffset", + + uniformIdHandler->programObject().setUniform( + uniformIdHandler->getId( + textureCategory, + blendLayerSuffix, + layerIndex, + LayeredTextureShaderUniformIdHandler::GlslTileDataId::depthTransform_depthOffset), tileDepthTransform.depthOffset); + } void ChunkRenderer::activateTileAndSetTileUniforms( - ProgramObject* programObject, + std::shared_ptr uniformIdHandler, + LayeredTextures::TextureCategory textureCategory, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix blendLayerSuffix, + size_t layerIndex, ghoul::opengl::TextureUnit& texUnit, - const std::string indexedTileKey, const TileAndTransform& tileAndTransform) { @@ -109,27 +133,43 @@ namespace openspace { // The texture needs a unit to sample from texUnit.activate(); tileAndTransform.tile.texture->bind(); - programObject->setUniform(indexedTileKey + ".textureSampler", texUnit); - programObject->setUniform( - indexedTileKey + ".uvTransform.uvScale", + + uniformIdHandler->programObject().setUniform( + uniformIdHandler->getId( + textureCategory, + blendLayerSuffix, + layerIndex, + LayeredTextureShaderUniformIdHandler::GlslTileDataId::textureSampler), + texUnit); + uniformIdHandler->programObject().setUniform( + uniformIdHandler->getId( + textureCategory, + blendLayerSuffix, + layerIndex, + LayeredTextureShaderUniformIdHandler::GlslTileDataId::uvTransform_uvScale), tileAndTransform.uvTransform.uvScale); - programObject->setUniform( - indexedTileKey + ".uvTransform.uvOffset", + uniformIdHandler->programObject().setUniform( + uniformIdHandler->getId( + textureCategory, + blendLayerSuffix, + layerIndex, + LayeredTextureShaderUniformIdHandler::GlslTileDataId::uvTransform_uvOffset), tileAndTransform.uvTransform.uvOffset); } ProgramObject* ChunkRenderer::getActivatedProgramWithTileData( LayeredTextureShaderProvider* layeredTextureShaderProvider, + std::shared_ptr programUniformHandler, const Chunk& chunk) { const ChunkIndex& chunkIndex = chunk.index(); - auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory("HeightMaps"); - auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory("ColorTextures"); - auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory("NightTextures"); - auto overlayProviders = _tileProviderManager->getActivatedLayerCategory("Overlays"); - auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory("WaterMasks"); + auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::HeightMaps); + auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::ColorTextures); + auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::NightTextures); + auto overlayProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::Overlays); + auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::WaterMasks); // TODO: This does not need to be updated every time. Maybe flag as dirty when // needing update instead. @@ -140,47 +180,24 @@ namespace openspace { LayeredTextureInfo layeredTextureInfoOverlay; LayeredTextureInfo layeredTextureInfoWater; - layeredTextureInfoHeight.keyLastLayerIndex = "lastLayerIndexHeight"; - layeredTextureInfoHeight.lastLayerIndex = heightMapProviders.size() - 1; - layeredTextureInfoHeight.keyUseThisLayerType = "useHeightMap"; - layeredTextureInfoHeight.keyLayerBlendingEnabled = "heightMapBlendingEnabled"; + layeredTextureInfoHeight.lastLayerIdx = heightMapProviders.size() - 1; + layeredTextureInfoColor.lastLayerIdx = colorTextureProviders.size() - 1; + layeredTextureInfoNight.lastLayerIdx = nightTextureProviders.size() - 1; + layeredTextureInfoOverlay.lastLayerIdx = overlayProviders.size() - 1; + layeredTextureInfoWater.lastLayerIdx = waterMaskProviders.size() - 1; + layeredTextureInfoHeight.layerBlendingEnabled = chunk.owner()->blendHeightMap; - - layeredTextureInfoColor.keyLastLayerIndex = "lastLayerIndexColor"; - layeredTextureInfoColor.lastLayerIndex = colorTextureProviders.size() - 1; - layeredTextureInfoColor.keyUseThisLayerType = "useColorTexture"; - layeredTextureInfoColor.keyLayerBlendingEnabled = "colorTextureBlendingEnabled"; layeredTextureInfoColor.layerBlendingEnabled = chunk.owner()->blendColorMap; - - layeredTextureInfoNight.keyLastLayerIndex = "lastLayerIndexNight"; - layeredTextureInfoNight.lastLayerIndex = nightTextureProviders.size() - 1; - layeredTextureInfoNight.keyUseThisLayerType = "useNightTexture"; - layeredTextureInfoNight.keyLayerBlendingEnabled = "nightTextureBlendingEnabled"; layeredTextureInfoNight.layerBlendingEnabled = chunk.owner()->blendNightTexture; - - layeredTextureInfoOverlay.keyLastLayerIndex = "lastLayerIndexOverlay"; - layeredTextureInfoOverlay.lastLayerIndex = overlayProviders.size() - 1; - layeredTextureInfoOverlay.keyUseThisLayerType = "useOverlay"; - layeredTextureInfoOverlay.keyLayerBlendingEnabled = "overlayBlendingEnabled"; layeredTextureInfoOverlay.layerBlendingEnabled = chunk.owner()->blendOverlay; - - layeredTextureInfoWater.keyLastLayerIndex = "lastLayerIndexWater"; - layeredTextureInfoWater.lastLayerIndex = waterMaskProviders.size() - 1; - layeredTextureInfoWater.keyUseThisLayerType = "useWaterMask"; - layeredTextureInfoWater.keyLayerBlendingEnabled = "waterMaskBlendingEnabled"; layeredTextureInfoWater.layerBlendingEnabled = chunk.owner()->blendWaterMask; LayeredTexturePreprocessingData layeredTexturePreprocessingData; - layeredTexturePreprocessingData.layeredTextureInfo.push_back( - layeredTextureInfoHeight); - layeredTexturePreprocessingData.layeredTextureInfo.push_back( - layeredTextureInfoColor); - layeredTexturePreprocessingData.layeredTextureInfo.push_back( - layeredTextureInfoNight); - layeredTexturePreprocessingData.layeredTextureInfo.push_back( - layeredTextureInfoOverlay); - layeredTexturePreprocessingData.layeredTextureInfo.push_back( - layeredTextureInfoWater); + layeredTexturePreprocessingData.layeredTextureInfo[LayeredTextures::ColorTextures] = layeredTextureInfoColor; + layeredTexturePreprocessingData.layeredTextureInfo[LayeredTextures::NightTextures] = layeredTextureInfoNight; + layeredTexturePreprocessingData.layeredTextureInfo[LayeredTextures::HeightMaps] = layeredTextureInfoHeight; + layeredTexturePreprocessingData.layeredTextureInfo[LayeredTextures::WaterMasks] = layeredTextureInfoWater; + layeredTexturePreprocessingData.layeredTextureInfo[LayeredTextures::Overlays] = layeredTextureInfoOverlay; layeredTexturePreprocessingData.keyValuePairs.push_back( std::pair( @@ -198,6 +215,8 @@ namespace openspace { layeredTextureShaderProvider->getUpdatedShaderProgram( layeredTexturePreprocessingData); + programUniformHandler->updateIds(layeredTextureShaderProvider); + // Activate the shader program programObject->activate(); @@ -261,10 +280,24 @@ namespace openspace { } TileDepthTransform depthTransform = tileProvider->depthTransform(); - std::string indexedTileKey = "heightTiles[" + std::to_string(i) + "]"; + //std::string indexedTileKey = "heightTiles[" + std::to_string(i) + "]"; - setDepthTransformUniforms(programObject, indexedTileKey, depthTransform); - activateTileAndSetTileUniforms(programObject, texUnitHeight[i], indexedTileKey, tileAndTransform); + setDepthTransformUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::HeightMaps, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + depthTransform); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::HeightMaps, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + texUnitHeight[i], + tileAndTransform); + + //setDepthTransformUniforms(programObject, indexedTileKey, depthTransform); + //activateTileAndSetTileUniforms(programObject, texUnitHeight[i], indexedTileKey, tileAndTransform); // If blending is enabled, two more textures are needed if (layeredTextureInfoHeight.layerBlendingEnabled) { @@ -272,15 +305,29 @@ namespace openspace { if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) { tileAndTransformParent1 = tileAndTransform; } - std::string indexedTileKeyParent1 = "heightTilesParent1[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitHeightParent1[i], indexedTileKeyParent1, tileAndTransformParent1); + //std::string indexedTileKeyParent1 = "heightTilesParent1[" + std::to_string(i) + "]"; + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::HeightMaps, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1, + i, + texUnitHeightParent1[i], + tileAndTransformParent1); + //activateTileAndSetTileUniforms(programObject, texUnitHeightParent1[i], indexedTileKeyParent1, tileAndTransformParent1); TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2); if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) { tileAndTransformParent2 = tileAndTransformParent1; } - std::string indexedTileKeyParent2 = "heightTilesParent2[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitHeightParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + //std::string indexedTileKeyParent2 = "heightTilesParent2[" + std::to_string(i) + "]"; + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::HeightMaps, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2, + i, + texUnitHeightParent2[i], + tileAndTransformParent2); + //activateTileAndSetTileUniforms(programObject, texUnitHeightParent2[i], indexedTileKeyParent2, tileAndTransformParent2); } i++; } @@ -299,11 +346,18 @@ namespace openspace { return nullptr; } - std::string indexedTileKey = "colorTiles[" + std::to_string(i) + "]"; + //std::string indexedTileKey = "colorTiles[" + std::to_string(i) + "]"; // Blend tile with two parents // The texture needs a unit to sample from - activateTileAndSetTileUniforms(programObject, texUnitColor[i], indexedTileKey, tileAndTransform); + //activateTileAndSetTileUniforms(programObject, texUnitColor[i], indexedTileKey, tileAndTransform); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::ColorTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + texUnitColor[i], + tileAndTransform); // If blending is enabled, two more textures are needed if (layeredTextureInfoColor.layerBlendingEnabled) { @@ -312,17 +366,29 @@ namespace openspace { tileAndTransformParent1 = tileAndTransform; } - std::string indexedTileKeyParent1 = "colorTilesParent1[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitColorParent1[i], indexedTileKeyParent1, tileAndTransformParent1); - + //std::string indexedTileKeyParent1 = "colorTilesParent1[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitColorParent1[i], indexedTileKeyParent1, tileAndTransformParent1); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::ColorTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1, + i, + texUnitColorParent1[i], + tileAndTransformParent1); TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2); if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) { tileAndTransformParent2 = tileAndTransformParent1; } - std::string indexedTileKeyParent2 = "colorTilesParent2[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitColorParent2[i], indexedTileKeyParent2, tileAndTransformParent2); - + //std::string indexedTileKeyParent2 = "colorTilesParent2[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitColorParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::ColorTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2, + i, + texUnitColorParent2[i], + tileAndTransformParent2); } i++; } @@ -340,11 +406,19 @@ namespace openspace { return nullptr; } - std::string indexedTileKey = "nightTiles[" + std::to_string(i) + "]"; + //std::string indexedTileKey = "nightTiles[" + std::to_string(i) + "]"; // Blend tile with two parents // The texture needs a unit to sample from - activateTileAndSetTileUniforms(programObject, texUnitNight[i], indexedTileKey, tileAndTransform); + //activateTileAndSetTileUniforms(programObject, texUnitNight[i], indexedTileKey, tileAndTransform); + + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::NightTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + texUnitNight[i], + tileAndTransform); // If blending is enabled, two more textures are needed if (layeredTextureInfoNight.layerBlendingEnabled) { @@ -353,17 +427,29 @@ namespace openspace { tileAndTransformParent1 = tileAndTransform; } - std::string indexedTileKeyParent1 = "nightTilesParent1[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitNightParent1[i], indexedTileKeyParent1, tileAndTransformParent1); - + //std::string indexedTileKeyParent1 = "nightTilesParent1[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitNightParent1[i], indexedTileKeyParent1, tileAndTransformParent1); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::NightTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1, + i, + texUnitNightParent1[i], + tileAndTransformParent1); TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2); if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) { tileAndTransformParent2 = tileAndTransformParent1; } - std::string indexedTileKeyParent2 = "nightTilesParent2[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitNightParent2[i], indexedTileKeyParent2, tileAndTransformParent2); - + //std::string indexedTileKeyParent2 = "nightTilesParent2[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitNightParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::NightTextures, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2, + i, + texUnitNightParent2[i], + tileAndTransformParent2); } i++; } @@ -381,11 +467,18 @@ namespace openspace { return nullptr; } - std::string indexedTileKey = "overlayTiles[" + std::to_string(i) + "]"; + //std::string indexedTileKey = "overlayTiles[" + std::to_string(i) + "]"; // Blend tile with two parents // The texture needs a unit to sample from - activateTileAndSetTileUniforms(programObject, texUnitOverlay[i], indexedTileKey, tileAndTransform); + //activateTileAndSetTileUniforms(programObject, texUnitOverlay[i], indexedTileKey, tileAndTransform); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::Overlays, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + texUnitOverlay[i], + tileAndTransform); // If blending is enabled, two more textures are needed if (layeredTextureInfoOverlay.layerBlendingEnabled) { @@ -394,16 +487,29 @@ namespace openspace { tileAndTransformParent1 = tileAndTransform; } - std::string indexedTileKeyParent1 = "overlayTilesParent1[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitOverlayParent1[i], indexedTileKeyParent1, tileAndTransformParent1); - + //std::string indexedTileKeyParent1 = "overlayTilesParent1[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitOverlayParent1[i], indexedTileKeyParent1, tileAndTransformParent1); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::Overlays, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1, + i, + texUnitOverlayParent1[i], + tileAndTransformParent1); TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2); if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) { tileAndTransformParent2 = tileAndTransformParent1; } - std::string indexedTileKeyParent2 = "overlayTilesParent2[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitOverlayParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + //std::string indexedTileKeyParent2 = "overlayTilesParent2[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitOverlayParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::Overlays, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2, + i, + texUnitOverlayParent2[i], + tileAndTransformParent2); } i++; } @@ -421,11 +527,18 @@ namespace openspace { return nullptr; } - std::string indexedTileKey = "waterTiles[" + std::to_string(i) + "]"; + //std::string indexedTileKey = "waterTiles[" + std::to_string(i) + "]"; // Blend tile with two parents // The texture needs a unit to sample from - activateTileAndSetTileUniforms(programObject, texUnitWater[i], indexedTileKey, tileAndTransform); + //activateTileAndSetTileUniforms(programObject, texUnitWater[i], indexedTileKey, tileAndTransform); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::WaterMasks, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none, + i, + texUnitWater[i], + tileAndTransform); // If blending is enabled, two more textures are needed if (layeredTextureInfoWater.layerBlendingEnabled) { @@ -434,16 +547,29 @@ namespace openspace { tileAndTransformParent1 = tileAndTransform; } - std::string indexedTileKeyParent1 = "waterTilesParent1[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitWaterParent1[i], indexedTileKeyParent1, tileAndTransformParent1); - + //std::string indexedTileKeyParent1 = "waterTilesParent1[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitWaterParent1[i], indexedTileKeyParent1, tileAndTransformParent1); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::WaterMasks, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1, + i, + texUnitWaterParent1[i], + tileAndTransformParent1); TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2); if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) { tileAndTransformParent2 = tileAndTransformParent1; } - std::string indexedTileKeyParent2 = "waterTilesParent2[" + std::to_string(i) + "]"; - activateTileAndSetTileUniforms(programObject, texUnitWaterParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + //std::string indexedTileKeyParent2 = "waterTilesParent2[" + std::to_string(i) + "]"; + //activateTileAndSetTileUniforms(programObject, texUnitWaterParent2[i], indexedTileKeyParent2, tileAndTransformParent2); + activateTileAndSetTileUniforms( + programUniformHandler, + LayeredTextures::TextureCategory::WaterMasks, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2, + i, + texUnitWaterParent2[i], + tileAndTransformParent2); } i++; } @@ -457,16 +583,19 @@ namespace openspace { void ChunkRenderer::renderChunkGlobally(const Chunk& chunk, const RenderData& data){ - ProgramObject* programObject = getActivatedProgramWithTileData(_globalRenderingShaderProvider.get(), chunk); + ProgramObject* programObject = getActivatedProgramWithTileData( + _globalRenderingShaderProvider.get(), + _globalProgramUniformHandler, + chunk); if (programObject == nullptr) { return; } - auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory("HeightMaps"); - auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory("ColorTextures"); - auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory("NightTextures"); - auto overlayProviders = _tileProviderManager->getActivatedLayerCategory("Overlays"); - auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory("WaterMasks"); + auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::HeightMaps); + auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::ColorTextures); + auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::NightTextures); + auto overlayProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::Overlays); + auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::WaterMasks); const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid(); // This information is only needed when doing blending @@ -519,18 +648,21 @@ namespace openspace { void ChunkRenderer::renderChunkLocally(const Chunk& chunk, const RenderData& data) { - ProgramObject* programObject = getActivatedProgramWithTileData(_localRenderingShaderProvider.get(), chunk); + ProgramObject* programObject = getActivatedProgramWithTileData( + _localRenderingShaderProvider.get(), + _localProgramUniformHandler, + chunk); if (programObject == nullptr) { return; } using namespace glm; - auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory("HeightMaps"); - auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory("ColorTextures"); - auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory("NightTextures"); - auto overlayProviders = _tileProviderManager->getActivatedLayerCategory("Overlays"); - auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory("WaterMasks"); + auto heightMapProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::HeightMaps); + auto colorTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::ColorTextures); + auto nightTextureProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::NightTextures); + auto overlayProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::Overlays); + auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::WaterMasks); const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid(); if ((heightMapProviders.size() > 0 && chunk.owner()->blendHeightMap) || diff --git a/modules/globebrowsing/chunk/chunkrenderer.h b/modules/globebrowsing/chunk/chunkrenderer.h index e2956c2545..d5bf5379f2 100644 --- a/modules/globebrowsing/chunk/chunkrenderer.h +++ b/modules/globebrowsing/chunk/chunkrenderer.h @@ -63,18 +63,23 @@ namespace openspace { void renderChunkLocally(const Chunk& chunk, const RenderData& data); void setDepthTransformUniforms( - ProgramObject* programObject, - const std::string& indexedTileKey, + std::shared_ptr uniformIdHandler, + LayeredTextures::TextureCategory textureCategory, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix blendLayerSuffix, + size_t layerIndex, const TileDepthTransform& tileDepthTransform); void activateTileAndSetTileUniforms( - ProgramObject* programObject, - ghoul::opengl::TextureUnit& texUnit, - const std::string indexedTileKey, + std::shared_ptr uniformIdHandler, + LayeredTextures::TextureCategory textureCategory, + LayeredTextureShaderUniformIdHandler::BlendLayerSuffix blendLayerSuffix, + size_t layerIndex, + ghoul::opengl::TextureUnit& texUnit, const TileAndTransform& tileAndTransform); ProgramObject* getActivatedProgramWithTileData( - LayeredTextureShaderProvider* layeredTextureShaderProvider, + LayeredTextureShaderProvider* layeredTextureShaderProvider, + std::shared_ptr programUniformHandler, const Chunk& chunk); ////////////////////////////////////////////////////////////////////////////////// @@ -84,9 +89,11 @@ namespace openspace { std::shared_ptr _grid; std::shared_ptr _tileProviderManager; - std::unique_ptr _globalRenderingShaderProvider; - std::unique_ptr _localRenderingShaderProvider; + std::shared_ptr _globalRenderingShaderProvider; + std::shared_ptr _localRenderingShaderProvider; + std::shared_ptr _globalProgramUniformHandler; + std::shared_ptr _localProgramUniformHandler; }; } // namespace openspace diff --git a/modules/globebrowsing/globes/renderableglobe.cpp b/modules/globebrowsing/globes/renderableglobe.cpp index 73bf623a6e..d2bf6e005c 100644 --- a/modules/globebrowsing/globes/renderableglobe.cpp +++ b/modules/globebrowsing/globes/renderableglobe.cpp @@ -112,17 +112,17 @@ namespace openspace { _tileProviderManager = std::shared_ptr( new TileProviderManager(texturesDictionary)); - auto colorProviders = _tileProviderManager->getLayerCategory("ColorTextures"); - auto nightProviders = _tileProviderManager->getLayerCategory("NightTextures"); - auto overlayProviders = _tileProviderManager->getLayerCategory("Overlays"); - auto heightProviders = _tileProviderManager->getLayerCategory("HeightMaps"); - auto waterProviders = _tileProviderManager->getLayerCategory("WaterMasks"); + auto& colorTextureProviders = _tileProviderManager->getLayerCategory(LayeredTextures::ColorTextures); + auto& nightTextureProviders = _tileProviderManager->getLayerCategory(LayeredTextures::NightTextures); + auto& heightMapProviders = _tileProviderManager->getLayerCategory(LayeredTextures::HeightMaps); + auto& overlayProviders = _tileProviderManager->getLayerCategory(LayeredTextures::Overlays); + auto& waterMaskProviders =_tileProviderManager->getLayerCategory(LayeredTextures::WaterMasks); - addToggleLayerProperties(colorProviders, _activeColorLayers); - addToggleLayerProperties(nightProviders, _activeNightLayers); + addToggleLayerProperties(colorTextureProviders, _activeColorLayers); + addToggleLayerProperties(nightTextureProviders, _activeNightLayers); addToggleLayerProperties(overlayProviders, _activeOverlays); - addToggleLayerProperties(heightProviders, _activeHeightMapLayers); - addToggleLayerProperties(waterProviders, _activeWaterMaskLayers); + addToggleLayerProperties(heightMapProviders, _activeHeightMapLayers); + addToggleLayerProperties(waterMaskProviders, _activeWaterMaskLayers); _chunkedLodGlobe = std::shared_ptr( new ChunkedLodGlobe(_ellipsoid, patchSegments, _tileProviderManager)); @@ -205,15 +205,15 @@ namespace openspace { _chunkedLodGlobe->showChunkEdges = showChunkEdges.value(); std::vector& colorTextureProviders = - _tileProviderManager->getLayerCategory("ColorTextures"); + _tileProviderManager->getLayerCategory(LayeredTextures::ColorTextures); std::vector& nightTextureProviders = - _tileProviderManager->getLayerCategory("NightTextures"); + _tileProviderManager->getLayerCategory(LayeredTextures::NightTextures); std::vector& overlayProviders = - _tileProviderManager->getLayerCategory("Overlays"); + _tileProviderManager->getLayerCategory(LayeredTextures::Overlays); std::vector& heightMapProviders = - _tileProviderManager->getLayerCategory("HeightMaps"); + _tileProviderManager->getLayerCategory(LayeredTextures::HeightMaps); std::vector& waterMaskProviders = - _tileProviderManager->getLayerCategory("WaterMasks"); + _tileProviderManager->getLayerCategory(LayeredTextures::WaterMasks); for (size_t i = 0; i < colorTextureProviders.size(); i++) { colorTextureProviders[i].isActive = _activeColorLayers[i].value(); diff --git a/modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl b/modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl index 3c7b4bf19a..2482fef8aa 100644 --- a/modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl +++ b/modules/globebrowsing/shaders/globalchunkedlodpatch_fs.glsl @@ -29,27 +29,27 @@ #include "fragment.glsl" #if USE_COLORTEXTURE -uniform Tile colorTiles[NUMLAYERS_COLORTEXTURE]; -uniform Tile colorTilesParent1[NUMLAYERS_COLORTEXTURE]; -uniform Tile colorTilesParent2[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTextures[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTexturesParent1[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTexturesParent2[NUMLAYERS_COLORTEXTURE]; #endif // USE_COLORTEXTURE #if USE_NIGHTTEXTURE -uniform Tile nightTiles[NUMLAYERS_NIGHTTEXTURE]; -uniform Tile nightTilesParent1[NUMLAYERS_NIGHTTEXTURE]; -uniform Tile nightTilesParent2[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTextures[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTexturesParent1[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTexturesParent2[NUMLAYERS_NIGHTTEXTURE]; #endif // USE_NIGHTTEXTURE #if USE_OVERLAY -uniform Tile overlayTiles[NUMLAYERS_OVERLAY]; -uniform Tile overlayTilesParent1[NUMLAYERS_OVERLAY]; -uniform Tile overlayTilesParent2[NUMLAYERS_OVERLAY]; +uniform Tile Overlays[NUMLAYERS_OVERLAY]; +uniform Tile OverlaysParent1[NUMLAYERS_OVERLAY]; +uniform Tile OverlaysParent2[NUMLAYERS_OVERLAY]; #endif // USE_OVERLAY #if USE_WATERMASK -uniform Tile waterTiles[NUMLAYERS_WATERMASK]; -uniform Tile waterTilesParent1[NUMLAYERS_WATERMASK]; -uniform Tile waterTilesParent2[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasks[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasksParent1[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasksParent2[NUMLAYERS_WATERMASK]; #endif // USE_WATERMASK #if USE_ATMOSPHERE @@ -74,9 +74,9 @@ Fragment getFragment() { frag.color = calculateColor( fs_uv, levelWeights,//levelInterpolationParameter, - colorTiles, - colorTilesParent1, - colorTilesParent2); + ColorTextures, + ColorTexturesParent1, + ColorTexturesParent2); #endif // USE_COLORTEXTURE @@ -86,9 +86,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - waterTiles, - waterTilesParent1, - waterTilesParent2); + WaterMasks, + WaterMasksParent1, + WaterMasksParent2); #endif // USE_WATERMASK @@ -98,9 +98,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - nightTiles, - nightTilesParent1, - nightTilesParent2, + NightTextures, + NightTexturesParent1, + NightTexturesParent2, ellipsoidNormalCameraSpace); #endif // USE_NIGHTTEXTURE @@ -115,9 +115,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - overlayTiles, - overlayTilesParent1, - overlayTilesParent2); + Overlays, + OverlaysParent1, + OverlaysParent2); #endif // USE_OVERLAY diff --git a/modules/globebrowsing/shaders/globalchunkedlodpatch_vs.glsl b/modules/globebrowsing/shaders/globalchunkedlodpatch_vs.glsl index 6d814e2b00..75300fa530 100644 --- a/modules/globebrowsing/shaders/globalchunkedlodpatch_vs.glsl +++ b/modules/globebrowsing/shaders/globalchunkedlodpatch_vs.glsl @@ -40,9 +40,9 @@ uniform int xSegments; uniform float skirtLength; #if USE_HEIGHTMAP -uniform Tile heightTiles[NUMLAYERS_HEIGHTMAP]; -uniform Tile heightTilesParent1[NUMLAYERS_HEIGHTMAP]; -uniform Tile heightTilesParent2[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMaps[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMapsParent1[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMapsParent2[NUMLAYERS_HEIGHTMAP]; #endif // USE_HEIGHTMAP uniform vec3 cameraPosition; @@ -84,7 +84,7 @@ void main() height = calculateHeight( in_uv, levelWeights, // Variable to determine which texture to sample from - heightTiles, heightTilesParent1, heightTilesParent2); // Three textures to sample from + HeightMaps, HeightMapsParent1, HeightMapsParent2); // Three textures to sample from #endif // USE_HEIGHTMAP diff --git a/modules/globebrowsing/shaders/localchunkedlodpatch_fs.glsl b/modules/globebrowsing/shaders/localchunkedlodpatch_fs.glsl index 659f491c30..f650b62d88 100644 --- a/modules/globebrowsing/shaders/localchunkedlodpatch_fs.glsl +++ b/modules/globebrowsing/shaders/localchunkedlodpatch_fs.glsl @@ -28,27 +28,27 @@ #include "fragment.glsl" #if USE_COLORTEXTURE -uniform Tile colorTiles[NUMLAYERS_COLORTEXTURE]; -uniform Tile colorTilesParent1[NUMLAYERS_COLORTEXTURE]; -uniform Tile colorTilesParent2[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTextures[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTexturesParent1[NUMLAYERS_COLORTEXTURE]; +uniform Tile ColorTexturesParent2[NUMLAYERS_COLORTEXTURE]; #endif // USE_COLORTEXTURE #if USE_NIGHTTEXTURE -uniform Tile nightTiles[NUMLAYERS_NIGHTTEXTURE]; -uniform Tile nightTilesParent1[NUMLAYERS_NIGHTTEXTURE]; -uniform Tile nightTilesParent2[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTextures[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTexturesParent1[NUMLAYERS_NIGHTTEXTURE]; +uniform Tile NightTexturesParent2[NUMLAYERS_NIGHTTEXTURE]; #endif // USE_NIGHTTEXTURE #if USE_OVERLAY -uniform Tile overlayTiles[NUMLAYERS_OVERLAY]; -uniform Tile overlayTilesParent1[NUMLAYERS_OVERLAY]; -uniform Tile overlayTilesParent2[NUMLAYERS_OVERLAY]; +uniform Tile Overlays[NUMLAYERS_OVERLAY]; +uniform Tile OverlaysParent1[NUMLAYERS_OVERLAY]; +uniform Tile OverlaysParent2[NUMLAYERS_OVERLAY]; #endif // USE_OVERLAY #if USE_WATERMASK -uniform Tile waterTiles[NUMLAYERS_WATERMASK]; -uniform Tile waterTilesParent1[NUMLAYERS_WATERMASK]; -uniform Tile waterTilesParent2[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasks[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasksParent1[NUMLAYERS_WATERMASK]; +uniform Tile WaterMasksParent2[NUMLAYERS_WATERMASK]; #endif // USE_WATERMASK // levelInterpolationParameter is used to interpolate between a tile and its parent tiles @@ -69,9 +69,9 @@ Fragment getFragment() { frag.color = calculateColor( fs_uv, levelWeights, - colorTiles, - colorTilesParent1, - colorTilesParent2); + ColorTextures, + ColorTexturesParent1, + ColorTexturesParent2); #endif // USE_COLORTEXTURE @@ -82,9 +82,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - waterTiles, - waterTilesParent1, - waterTilesParent2); + WaterMasks, + WaterMasksParent1, + WaterMasksParent2); #endif // USE_WATERMASK @@ -95,9 +95,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - nightTiles, - nightTilesParent1, - nightTilesParent2, + NightTextures, + NightTexturesParent1, + NightTexturesParent2, ellipsoidNormalCameraSpace); #endif // USE_NIGHTTEXTURE @@ -112,9 +112,9 @@ Fragment getFragment() { frag.color, fs_uv, levelWeights, - overlayTiles, - overlayTilesParent1, - overlayTilesParent2); + Overlays, + OverlaysParent1, + OverlaysParent2); #endif // USE_OVERLAY diff --git a/modules/globebrowsing/shaders/localchunkedlodpatch_vs.glsl b/modules/globebrowsing/shaders/localchunkedlodpatch_vs.glsl index e079173722..491c7a94ea 100644 --- a/modules/globebrowsing/shaders/localchunkedlodpatch_vs.glsl +++ b/modules/globebrowsing/shaders/localchunkedlodpatch_vs.glsl @@ -29,9 +29,6 @@ #include <${MODULE_GLOBEBROWSING}/shaders/tile.hglsl> #include <${MODULE_GLOBEBROWSING}/shaders/texturetilemapping.hglsl> -#define NUMLAYERS_COLORTEXTURE #{lastLayerIndexColor} + 1 -#define NUMLAYERS_HEIGHTMAP #{lastLayerIndexHeight} + 1 - uniform mat4 projectionTransform; // Input points in camera space @@ -42,9 +39,9 @@ uniform vec3 p11; uniform vec3 patchNormalCameraSpace; #if USE_HEIGHTMAP -uniform Tile heightTiles[NUMLAYERS_HEIGHTMAP]; -uniform Tile heightTilesParent1[NUMLAYERS_HEIGHTMAP]; -uniform Tile heightTilesParent2[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMaps[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMapsParent1[NUMLAYERS_HEIGHTMAP]; +uniform Tile HeightMapsParent2[NUMLAYERS_HEIGHTMAP]; #endif // USE_HEIGHTMAP uniform int xSegments; @@ -92,7 +89,7 @@ void main() height = calculateHeight( in_uv, levelWeights, // Variable to determine which texture to sample from - heightTiles, heightTilesParent1, heightTilesParent2); // Three textures to sample from + HeightMaps, HeightMapsParent1, HeightMapsParent2); // Three textures to sample from #endif // USE_HEIGHTMAP diff --git a/modules/globebrowsing/shaders/texturetilemapping.hglsl b/modules/globebrowsing/shaders/texturetilemapping.hglsl index bb293013aa..7f0c7719dc 100644 --- a/modules/globebrowsing/shaders/texturetilemapping.hglsl +++ b/modules/globebrowsing/shaders/texturetilemapping.hglsl @@ -29,29 +29,29 @@ #include <${MODULE_GLOBEBROWSING}/shaders/blending.hglsl> // First layer type from LayeredTextureShaderProvider is height map -#define NUMLAYERS_HEIGHTMAP #{lastLayerIndexHeight} + 1 -#define USE_HEIGHTMAP #{useHeightMap} -#define HEIGHTMAP_BLENDING_ENABLED #{heightMapBlendingEnabled} +#define NUMLAYERS_HEIGHTMAP #{lastLayerIndexHeightMaps} + 1 +#define USE_HEIGHTMAP #{useHeightMaps} +#define HEIGHTMAP_BLENDING_ENABLED #{blendHeightMaps} // Second layer type from LayeredTextureShaderProvider is color texture -#define NUMLAYERS_COLORTEXTURE #{lastLayerIndexColor} + 1 -#define USE_COLORTEXTURE #{useColorTexture} -#define COLORTEXTURE_BLENDING_ENABLED #{colorTextureBlendingEnabled} +#define NUMLAYERS_COLORTEXTURE #{lastLayerIndexColorTextures} + 1 +#define USE_COLORTEXTURE #{useColorTextures} +#define COLORTEXTURE_BLENDING_ENABLED #{blendColorTextures} // Third layer type from LayeredTextureShaderProvider is water mask -#define NUMLAYERS_WATERMASK #{lastLayerIndexWater} + 1 -#define USE_WATERMASK #{useWaterMask} -#define WATERMASK_BLENDING_ENABLED #{waterMaskBlendingEnabled} +#define NUMLAYERS_WATERMASK #{lastLayerIndexWaterMasks} + 1 +#define USE_WATERMASK #{useWaterMasks} +#define WATERMASK_BLENDING_ENABLED #{blendWaterMasks} // Fourth layer type from LayeredTextureShaderProvider is night texture -#define NUMLAYERS_NIGHTTEXTURE #{lastLayerIndexNight} + 1 -#define USE_NIGHTTEXTURE #{useNightTexture} -#define NIGHTTEXTURE_BLENDING_ENABLED #{nightTextureBlendingEnabled} +#define NUMLAYERS_NIGHTTEXTURE #{lastLayerIndexNightTextures} + 1 +#define USE_NIGHTTEXTURE #{useNightTextures} +#define NIGHTTEXTURE_BLENDING_ENABLED #{blendNightTextures} // Fifth layer type from LayeredTextureShaderProvider is overlay -#define NUMLAYERS_OVERLAY #{lastLayerIndexOverlay} + 1 -#define USE_OVERLAY #{useOverlay} -#define OVERLAY_BLENDING_ENABLED #{overlayBlendingEnabled} +#define NUMLAYERS_OVERLAY #{lastLayerIndexOverlays} + 1 +#define USE_OVERLAY #{useOverlays} +#define OVERLAY_BLENDING_ENABLED #{blendOverlays} // Other key value pairs used for settings #define USE_ATMOSPHERE #{useAtmosphere} @@ -72,7 +72,7 @@ float calculateHeight( levelWeights = getDefaultLevelWeights(); #endif // HEIGHTMAP_BLENDING_ENABLED - #for i in 0..#{lastLayerIndexHeight} + #for i in 0..#{lastLayerIndexHeightMaps} { float untransformedHeight = levelWeights.w1 * getTexVal(heightTiles[#{i}], uv).r + @@ -102,7 +102,7 @@ vec4 calculateColor( levelWeights = getDefaultLevelWeights(); #endif // COLORTEXTURE_BLENDING_ENABLED - #for i in 0..#{lastLayerIndexColor} + #for i in 0..#{lastLayerIndexColorTextures} { vec4 colorSample = levelWeights.w1 * getTexVal(colorTiles[#{i}], uv) + @@ -136,7 +136,7 @@ vec4 calculateNight( levelWeights = getDefaultLevelWeights(); #endif // NIGHTTEXTURE_BLENDING_ENABLED - #for i in 0..#{lastLayerIndexNight} + #for i in 0..#{lastLayerIndexNightTextures} { vec4 colorSample = levelWeights.w1 * getTexVal(nightTiles[#{i}], uv) + @@ -169,7 +169,7 @@ vec4 calculateOverlay( levelWeights = getDefaultLevelWeights(); #endif // OVERLAY_BLENDING_ENABLED - #for i in 0..#{lastLayerIndexOverlay} + #for i in 0..#{lastLayerIndexOverlays} { vec4 colorSample = levelWeights.w1 * getTexVal(overlayTiles[#{i}], uv) + @@ -199,7 +199,7 @@ vec4 calculateWater( levelWeights = getDefaultLevelWeights(); #endif // WATERMASK_BLENDING_ENABLED - #for i in 0..#{lastLayerIndexWater} + #for i in 0..#{lastLayerIndexWaterMasks} { vec4 colorSample = levelWeights.w1 * getTexVal(waterTiles[#{i}], uv) + diff --git a/modules/globebrowsing/tile/TileProviderManager.cpp b/modules/globebrowsing/tile/TileProviderManager.cpp index d5df9f0046..c687355010 100644 --- a/modules/globebrowsing/tile/TileProviderManager.cpp +++ b/modules/globebrowsing/tile/TileProviderManager.cpp @@ -31,12 +31,6 @@ namespace { const std::string _loggerCat = "TileProviderManager"; - - const std::string keyColorTextures = "ColorTextures"; - const std::string keyNightTextures = "NightTextures"; - const std::string keyOverlays = "Overlays"; - const std::string keyHeightMaps = "HeightMaps"; - const std::string keyWaterMasks = "WaterMasks"; } @@ -46,9 +40,10 @@ namespace openspace { TileProviderManager::TileProviderManager(const ghoul::Dictionary& texDict){ // Color Texture - _layerCategories.insert(std::pair(keyColorTextures, LayerCategory())); ghoul::Dictionary colorTexturesDict; - texDict.getValue(keyColorTextures, colorTexturesDict); + texDict.getValue( + LayeredTextures::TEXTURE_CATEGORY_NAMES[LayeredTextures::ColorTextures], + colorTexturesDict); TileProviderInitData colorInitData; colorInitData.minimumPixelSize = 1024; @@ -57,12 +52,15 @@ namespace openspace { colorInitData.framesUntilRequestQueueFlush = 60; colorInitData.preprocessTiles = false; - initTexures(_layerCategories[keyColorTextures], colorTexturesDict, colorInitData); + initTexures( + _layerCategories[LayeredTextures::ColorTextures], + colorTexturesDict, colorInitData); // Night Texture - _layerCategories.insert(std::pair(keyNightTextures, LayerCategory())); ghoul::Dictionary nightTexturesDict; - texDict.getValue(keyNightTextures, nightTexturesDict); + texDict.getValue( + LayeredTextures::TEXTURE_CATEGORY_NAMES[LayeredTextures::NightTextures], + nightTexturesDict); TileProviderInitData nightInitData; nightInitData.minimumPixelSize = 1024; @@ -71,12 +69,15 @@ namespace openspace { nightInitData.framesUntilRequestQueueFlush = 60; nightInitData.preprocessTiles = false; - initTexures(_layerCategories[keyNightTextures], nightTexturesDict, nightInitData); + initTexures( + _layerCategories[LayeredTextures::NightTextures], + nightTexturesDict, nightInitData); // Overlays - _layerCategories.insert(std::pair(keyOverlays, LayerCategory())); ghoul::Dictionary overlaysDict; - texDict.getValue(keyOverlays, overlaysDict); + texDict.getValue( + LayeredTextures::TEXTURE_CATEGORY_NAMES[LayeredTextures::Overlays], + overlaysDict); TileProviderInitData overlayInitData; overlayInitData.minimumPixelSize = 1024; @@ -85,12 +86,16 @@ namespace openspace { overlayInitData.framesUntilRequestQueueFlush = 60; overlayInitData.preprocessTiles = false; - initTexures(_layerCategories[keyOverlays], overlaysDict, overlayInitData); + initTexures( + _layerCategories[LayeredTextures::Overlays], + overlaysDict, + overlayInitData); // Height maps - _layerCategories.insert(std::pair(keyHeightMaps, LayerCategory())); ghoul::Dictionary heightTexturesDict; - texDict.getValue(keyHeightMaps, heightTexturesDict); + texDict.getValue( + LayeredTextures::TEXTURE_CATEGORY_NAMES[LayeredTextures::HeightMaps], + heightTexturesDict); TileProviderInitData heightInitData; heightInitData.minimumPixelSize = 64; @@ -99,12 +104,16 @@ namespace openspace { heightInitData.framesUntilRequestQueueFlush = 60; heightInitData.preprocessTiles = true; - initTexures(_layerCategories[keyHeightMaps], heightTexturesDict, heightInitData); + initTexures( + _layerCategories[LayeredTextures::HeightMaps], + heightTexturesDict, + heightInitData); // Water masks - _layerCategories.insert(std::pair(keyWaterMasks, LayerCategory())); ghoul::Dictionary waterMaskDict; - texDict.getValue(keyWaterMasks, waterMaskDict); + texDict.getValue( + LayeredTextures::TEXTURE_CATEGORY_NAMES[LayeredTextures::WaterMasks], + waterMaskDict); TileProviderInitData waterInitData; waterInitData.minimumPixelSize = 2048; @@ -113,7 +122,9 @@ namespace openspace { waterInitData.framesUntilRequestQueueFlush = 60; waterInitData.preprocessTiles = false; - initTexures(_layerCategories[keyWaterMasks], waterMaskDict, waterInitData); + initTexures( + _layerCategories[LayeredTextures::WaterMasks], + waterMaskDict, waterInitData); } TileProviderManager::~TileProviderManager() @@ -168,14 +179,14 @@ namespace openspace { return tileProvider; } - TileProviderManager::LayerCategory& TileProviderManager::getLayerCategory(std::string categoryKey) + TileProviderManager::LayerCategory& TileProviderManager::getLayerCategory(LayeredTextures::TextureCategory category) { - return _layerCategories[categoryKey]; + return _layerCategories[category]; } void TileProviderManager::prerender() { - for each (auto layerCategoryPair in _layerCategories) { - for each (auto tileProviderWithName in layerCategoryPair.second) { + for each (auto layerCategory in _layerCategories) { + for each (auto tileProviderWithName in layerCategory) { if (tileProviderWithName.isActive) { tileProviderWithName.tileProvider->prerender(); } @@ -184,10 +195,10 @@ namespace openspace { } const std::vector > - TileProviderManager::getActivatedLayerCategory(std::string categoryKey) + TileProviderManager::getActivatedLayerCategory(LayeredTextures::TextureCategory category) { std::vector > tileProviders; - for each (auto tileProviderWithName in _layerCategories[categoryKey]) { + for each (auto tileProviderWithName in _layerCategories[category]) { if (tileProviderWithName.isActive) { tileProviders.push_back(tileProviderWithName.tileProvider); } diff --git a/modules/globebrowsing/tile/TileProviderManager.h b/modules/globebrowsing/tile/TileProviderManager.h index f2dc5e176d..ff980b428a 100644 --- a/modules/globebrowsing/tile/TileProviderManager.h +++ b/modules/globebrowsing/tile/TileProviderManager.h @@ -28,6 +28,7 @@ #include #include +#include #include @@ -43,6 +44,7 @@ namespace openspace { class TileProviderManager { public: + struct TileProviderWithName { std::string name; std::shared_ptr tileProvider; @@ -56,9 +58,9 @@ namespace openspace { static ThreadPool tileRequestThreadPool; - LayerCategory& getLayerCategory(std::string categoryKey); + LayerCategory& getLayerCategory(LayeredTextures::TextureCategory); const std::vector > - getActivatedLayerCategory(std::string categoryKey); + getActivatedLayerCategory(LayeredTextures::TextureCategory); void prerender(); @@ -69,7 +71,7 @@ namespace openspace { static std::shared_ptr initProvider(const std::string& file, const TileProviderInitData& initData); - std::map _layerCategories; + std::array _layerCategories; }; } // namespace openspace diff --git a/modules/globebrowsing/tile/layeredtextures.cpp b/modules/globebrowsing/tile/layeredtextures.cpp new file mode 100644 index 0000000000..b0453368e5 --- /dev/null +++ b/modules/globebrowsing/tile/layeredtextures.cpp @@ -0,0 +1,48 @@ +/***************************************************************************************** +* * +* OpenSpace * +* * +* Copyright (c) 2014-2016 * +* * +* Permission is hereby granted, free of charge, to any person obtaining a copy of this * +* software and associated documentation files (the "Software"), to deal in the Software * +* without restriction, including without limitation the rights to use, copy, modify, * +* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * +* permit persons to whom the Software is furnished to do so, subject to the following * +* conditions: * +* * +* The above copyright notice and this permission notice shall be included in all copies * +* or substantial portions of the Software. * +* * +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * +* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * +* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * +* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * +* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE * +* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * +****************************************************************************************/ + +#include + + +namespace { + const std::string _loggerCat = "LayeredTextures"; +} + + +namespace openspace { + + + const size_t LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES; + const size_t LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY; + + const std::string LayeredTextures::TEXTURE_CATEGORY_NAMES[] = + { + "ColorTextures", + "NightTextures", + "HeightMaps", + "WaterMasks", + "Overlays" + }; + +} // namespace openspace diff --git a/modules/globebrowsing/tile/layeredtextures.h b/modules/globebrowsing/tile/layeredtextures.h new file mode 100644 index 0000000000..f68dbc6859 --- /dev/null +++ b/modules/globebrowsing/tile/layeredtextures.h @@ -0,0 +1,53 @@ +/***************************************************************************************** +* * +* OpenSpace * +* * +* Copyright (c) 2014-2016 * +* * +* Permission is hereby granted, free of charge, to any person obtaining a copy of this * +* software and associated documentation files (the "Software"), to deal in the Software * +* without restriction, including without limitation the rights to use, copy, modify, * +* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to * +* permit persons to whom the Software is furnished to do so, subject to the following * +* conditions: * +* * +* The above copyright notice and this permission notice shall be included in all copies * +* or substantial portions of the Software. * +* * +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * +* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * +* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * +* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * +* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE * +* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * +****************************************************************************************/ + +#ifndef __LAYERED_TEXTURES_H__ +#define __LAYERED_TEXTURES_H__ + +#include +#include +#include + +namespace openspace { + + class LayeredTextures { + + public: + + static const size_t MAX_NUM_TEXTURE_CATEGORIES = 5; + static const size_t MAX_NUM_TEXTURES_PER_CATEGORY = 5; + + enum TextureCategory { + ColorTextures, + NightTextures, + HeightMaps, + WaterMasks, + Overlays, + }; + + static const std::string TEXTURE_CATEGORY_NAMES[MAX_NUM_TEXTURE_CATEGORIES]; + }; + +} // namespace openspace +#endif // __LAYERED_TEXTURES_H__ \ No newline at end of file diff --git a/modules/globebrowsing/tile/layeredtextureshaderprovider.cpp b/modules/globebrowsing/tile/layeredtextureshaderprovider.cpp index 77e90e57c8..aa9c124b7a 100644 --- a/modules/globebrowsing/tile/layeredtextureshaderprovider.cpp +++ b/modules/globebrowsing/tile/layeredtextureshaderprovider.cpp @@ -37,13 +37,24 @@ namespace { namespace openspace { + + + + + + const std::string LayeredTextureInfo::glslKeyPrefixes[NUM_SETTINGS_PER_CATEGORY] = + { + "lastLayerIndex", + "use", + "blend", + }; + + bool LayeredTextureInfo::operator==(const LayeredTextureInfo& other) const { return - lastLayerIndex == other.lastLayerIndex && - keyLastLayerIndex == other.keyLastLayerIndex && - keyUseThisLayerType == other.keyUseThisLayerType && - keyLayerBlendingEnabled == other.keyLayerBlendingEnabled && + lastLayerIdx == other.lastLayerIdx && + category == other.category && layerBlendingEnabled == other.layerBlendingEnabled; } @@ -75,6 +86,7 @@ namespace openspace { : _shaderName(shaderName) , _vsPath(vsPath) , _fsPath(fsPath) + , _updatedOnLastCall(false) { } @@ -91,9 +103,11 @@ namespace openspace { ProgramObject* LayeredTextureShaderProvider::getUpdatedShaderProgram( LayeredTexturePreprocessingData preprocessingData) { + _updatedOnLastCall = false; if (!(preprocessingData == _preprocessingData) || _programObject == nullptr) { // No need to recompile shader. Shader is up to date and can be returned. recompileShaderProgram(preprocessingData); + _updatedOnLastCall = true; } return _programObject.get(); } @@ -112,11 +126,14 @@ namespace openspace { // lastLayerIndex must be at least 0 for the shader to compile, // the layer type is inactivated by setting useThisLayerType to false shaderDictionary.setValue( - textureTypes[i].keyLastLayerIndex, glm::max(textureTypes[i].lastLayerIndex, 0)); + LayeredTextureInfo::glslKeyPrefixes[LayeredTextureInfo::GlslKeyPrefixes::lastLayerIndex] + + LayeredTextures::TEXTURE_CATEGORY_NAMES[i], glm::max(textureTypes[i].lastLayerIdx, 0)); shaderDictionary.setValue( - textureTypes[i].keyUseThisLayerType, textureTypes[i].lastLayerIndex >= 0); + LayeredTextureInfo::glslKeyPrefixes[LayeredTextureInfo::GlslKeyPrefixes::use] + + LayeredTextures::TEXTURE_CATEGORY_NAMES[i], textureTypes[i].lastLayerIdx >= 0); shaderDictionary.setValue( - textureTypes[i].keyLayerBlendingEnabled, textureTypes[i].layerBlendingEnabled); + LayeredTextureInfo::glslKeyPrefixes[LayeredTextureInfo::GlslKeyPrefixes::blend] + + LayeredTextures::TEXTURE_CATEGORY_NAMES[i], textureTypes[i].layerBlendingEnabled); } // Other settings such as "useAtmosphere" @@ -138,4 +155,91 @@ namespace openspace { _programObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes); } + bool LayeredTextureShaderProvider::updatedOnLastCall() { + return _updatedOnLastCall; + } + + + + + + + + + + + + + + + const std::string LayeredTextureShaderUniformIdHandler::glslTileDataNames[NUM_TILE_DATA_VARIABLES] = + { + "textureSampler", + "depthTransform.depthScale", + "depthTransform.depthOffset", + "uvTransform.uvOffset", + "uvTransform.uvScale" + }; + + const std::string LayeredTextureShaderUniformIdHandler::blendLayerSuffixes[NUM_BLEND_TEXTURES] = + { + "", + "Parent1", + "Parent2", + }; + + LayeredTextureShaderUniformIdHandler::LayeredTextureShaderUniformIdHandler() + { + + } + + LayeredTextureShaderUniformIdHandler::~LayeredTextureShaderUniformIdHandler() + { + } + + void LayeredTextureShaderUniformIdHandler::updateIds(LayeredTextureShaderProvider* shaderProvider) + { + if (shaderProvider->updatedOnLastCall()) + { + _shaderProvider = shaderProvider; + _shaderProvider->_programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::Yes); + for (size_t i = 0; i < LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES; i++) + { + for (size_t j = 0; j < NUM_BLEND_TEXTURES; j++) + { + for (size_t k = 0; k < LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY; k++) + { + for (size_t l = 0; l < NUM_TILE_DATA_VARIABLES; l++) + { + _tileUniformIds[i][j][k][l] = _shaderProvider->_programObject->uniformLocation( + LayeredTextures::TEXTURE_CATEGORY_NAMES[i] + + blendLayerSuffixes[j] + + "[" + std::to_string(k) + "]." + + glslTileDataNames[l]); + } + } + } + } + _shaderProvider->_programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::No); + } + } + + GLint LayeredTextureShaderUniformIdHandler::getId( + LayeredTextures::TextureCategory category, + size_t blendLayer, + size_t layerIndex, + GlslTileDataId tileDataId) + { + return _tileUniformIds[category][blendLayer][layerIndex][tileDataId]; + } + + + ProgramObject& LayeredTextureShaderUniformIdHandler::programObject() + { + return *_shaderProvider->_programObject; + } + + + + } // namespace openspace diff --git a/modules/globebrowsing/tile/layeredtextureshaderprovider.h b/modules/globebrowsing/tile/layeredtextureshaderprovider.h index 62a2744493..a19e196cc6 100644 --- a/modules/globebrowsing/tile/layeredtextureshaderprovider.h +++ b/modules/globebrowsing/tile/layeredtextureshaderprovider.h @@ -26,23 +26,34 @@ #define __LAYERED_TEXTURE_SHADER_PROVIDER__ #include +#include #include #include "ghoul/opengl/programobject.h" +#include + ////////////////////////////////////////////////////////////////////////////////////////// // LAYERED TEXTURE SHADER PROVIDER // ////////////////////////////////////////////////////////////////////////////////////////// namespace openspace { - using namespace ghoul::opengl; + class LayeredTextureShaderUniformIdHandler; + struct LayeredTextureInfo { - std::string keyLastLayerIndex; - std::string keyUseThisLayerType; - std::string keyLayerBlendingEnabled; - int lastLayerIndex; + static const size_t NUM_SETTINGS_PER_CATEGORY = 3; + enum GlslKeyPrefixes + { + lastLayerIndex, + use, + blend, + }; + static const std::string glslKeyPrefixes[NUM_SETTINGS_PER_CATEGORY]; + + LayeredTextures::TextureCategory category; + int lastLayerIdx; bool layerBlendingEnabled; bool operator==(const LayeredTextureInfo& other) const; @@ -50,7 +61,7 @@ namespace openspace { struct LayeredTexturePreprocessingData { - std::vector layeredTextureInfo; + std::array layeredTextureInfo; std::vector > keyValuePairs; bool operator==(const LayeredTexturePreprocessingData& other) const; }; @@ -67,7 +78,9 @@ namespace openspace { ProgramObject* getUpdatedShaderProgram( LayeredTexturePreprocessingData preprocessingData); + bool updatedOnLastCall(); private: + friend class LayeredTextureShaderUniformIdHandler; void recompileShaderProgram(LayeredTexturePreprocessingData preprocessingData); std::unique_ptr _programObject; @@ -76,6 +89,65 @@ namespace openspace { const std::string _shaderName; const std::string _vsPath; const std::string _fsPath; + + bool _updatedOnLastCall; + }; + + + + + + + + class LayeredTextureShaderUniformIdHandler + { + + public: + + static const size_t NUM_TILE_DATA_VARIABLES = 5; + static const size_t NUM_BLEND_TEXTURES = 3; + + enum GlslTileDataId { + textureSampler, + depthTransform_depthScale, + depthTransform_depthOffset, + uvTransform_uvOffset, + uvTransform_uvScale, + }; + + enum BlendLayerSuffix { + none, + Parent1, + Parent2, + }; + + LayeredTextureShaderUniformIdHandler(); + ~LayeredTextureShaderUniformIdHandler(); + void updateIds(LayeredTextureShaderProvider* shaderProvider); + + GLint getId( + LayeredTextures::TextureCategory category, + size_t blendLayer, + size_t layerIndex, + GlslTileDataId tileDataId); + ProgramObject& programObject(); + private: + static const std::string glslTileDataNames[NUM_TILE_DATA_VARIABLES]; + static const std::string blendLayerSuffixes[NUM_BLEND_TEXTURES]; + + std::array< + std::array< + std::array< + std::array< + GLint, + LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES>, + LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY>, + NUM_BLEND_TEXTURES>, + NUM_TILE_DATA_VARIABLES> + _tileUniformIds; + + LayeredTextureShaderProvider* _shaderProvider; + }; } // namespace openspace