mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-04-24 21:18:32 -05:00
Code Issues Packages Projects Releases Wiki Activity

Collapse layer category rendering code in to for loop.

Browse Source
This commit is contained in:
Kalle Bladin
2016-06-14 00:20:37 -04:00
parent 164e133ce9
commit 0b7ce79e80
10 changed files with 125 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files
data/scene/debugglobe/debugglobe.mod
+1 -1
View File
@@ -32,7 +32,7 @@ return {
SegmentsPerPatch = 64,
TextureInitData = {
ColorTextureMinimumSize = 1024,
OverlayMinimumSize = 1024,
OverlayMinimumSize = 4096,
HeightMapMinimumSize = 64,
},
Textures = {
modules/globebrowsing/chunk/chunkedlodglobe.h
+2 -5
View File
@@ -104,11 +104,8 @@ namespace openspace {
float chunkHeight;
// Layered rendering
bool blendHeightMap;
bool blendColorMap;
bool blendNightTexture;
bool blendWaterMask;
bool blendOverlay;
std::array<bool, LayeredTextures::NUM_TEXTURE_CATEGORIES>
blendProperties;
bool atmosphereEnabled;
bool showChunkEdges;
bool levelByProjArea;
modules/globebrowsing/chunk/chunkrenderer.cpp
+105 -383
View File
@@ -165,39 +165,21 @@ namespace openspace {
{
const ChunkIndex& chunkIndex = chunk.index();
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.
// Create information for the shader provider
LayeredTextureInfo layeredTextureInfoHeight;
LayeredTextureInfo layeredTextureInfoColor;
LayeredTextureInfo layeredTextureInfoNight;
LayeredTextureInfo layeredTextureInfoOverlay;
LayeredTextureInfo layeredTextureInfoWater;
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.layerBlendingEnabled = chunk.owner()->blendColorMap;
layeredTextureInfoNight.layerBlendingEnabled = chunk.owner()->blendNightTexture;
layeredTextureInfoOverlay.layerBlendingEnabled = chunk.owner()->blendOverlay;
layeredTextureInfoWater.layerBlendingEnabled = chunk.owner()->blendWaterMask;
std::array<std::vector<std::shared_ptr<TileProvider> >,
LayeredTextures::NUM_TEXTURE_CATEGORIES> tileProviders;
LayeredTexturePreprocessingData layeredTexturePreprocessingData;
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;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++)
{
tileProviders[category] = _tileProviderManager->getActivatedLayerCategory(
LayeredTextures::TextureCategory(category));
LayeredTextureInfo layeredTextureInfo;
layeredTextureInfo.lastLayerIdx = tileProviders[category].size() - 1;
layeredTextureInfo.layerBlendingEnabled = chunk.owner()->blendProperties[category];
layeredTexturePreprocessingData.layeredTextureInfo[category] = layeredTextureInfo;
}
layeredTexturePreprocessingData.keyValuePairs.push_back(
std::pair<std::string, std::string>(
@@ -215,362 +197,91 @@ namespace openspace {
layeredTextureShaderProvider->getUpdatedShaderProgram(
layeredTexturePreprocessingData);
programUniformHandler->updateIds(layeredTextureShaderProvider);
programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider);
// Activate the shader program
programObject->activate();
// Initialize all texture units
struct BlendTexUnits {
ghoul::opengl::TextureUnit blendTexture0;
ghoul::opengl::TextureUnit blendTexture1;
ghoul::opengl::TextureUnit blendTexture2;
};
std::array<std::vector<BlendTexUnits>,
LayeredTextures::NUM_TEXTURE_CATEGORIES> texUnits;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
texUnits[category].resize(tileProviders[category].size());
}
// Create all the texture units
std::vector<ghoul::opengl::TextureUnit> texUnitHeight;
std::vector<ghoul::opengl::TextureUnit> texUnitHeightParent1;
std::vector<ghoul::opengl::TextureUnit> texUnitHeightParent2;
texUnitHeight.resize(heightMapProviders.size());
texUnitHeightParent1.resize(heightMapProviders.size());
texUnitHeightParent2.resize(heightMapProviders.size());
std::vector<ghoul::opengl::TextureUnit> texUnitColor;
std::vector<ghoul::opengl::TextureUnit> texUnitColorParent1;
std::vector<ghoul::opengl::TextureUnit> texUnitColorParent2;
texUnitColor.resize(colorTextureProviders.size());
texUnitColorParent1.resize(colorTextureProviders.size());
texUnitColorParent2.resize(colorTextureProviders.size());
std::vector<ghoul::opengl::TextureUnit> texUnitNight;
std::vector<ghoul::opengl::TextureUnit> texUnitNightParent1;
std::vector<ghoul::opengl::TextureUnit> texUnitNightParent2;
texUnitNight.resize(nightTextureProviders.size());
texUnitNightParent1.resize(nightTextureProviders.size());
texUnitNightParent2.resize(nightTextureProviders.size());
std::vector<ghoul::opengl::TextureUnit> texUnitOverlay;
std::vector<ghoul::opengl::TextureUnit> texUnitOverlayParent1;
std::vector<ghoul::opengl::TextureUnit> texUnitOverlayParent2;
texUnitOverlay.resize(overlayProviders.size());
texUnitOverlayParent1.resize(overlayProviders.size());
texUnitOverlayParent2.resize(overlayProviders.size());
std::vector<ghoul::opengl::TextureUnit> texUnitWater;
std::vector<ghoul::opengl::TextureUnit> texUnitWaterParent1;
std::vector<ghoul::opengl::TextureUnit> texUnitWaterParent2;
texUnitWater.resize(waterMaskProviders.size());
texUnitWaterParent1.resize(waterMaskProviders.size());
texUnitWaterParent2.resize(waterMaskProviders.size());
// Go through all the height map providers
int i = 0;
for (auto it = heightMapProviders.begin(); it != heightMapProviders.end(); it++)
// Go through all the categories
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++)
{
// Go through all the providers in this category
int i = 0;
for (auto it = tileProviders[category].begin(); it != tileProviders[category].end(); it++)
{
auto tileProvider = *it;
// Get the texture that should be used for rendering
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none,
i,
texUnits[category][i].blendTexture0,
tileAndTransform);
// If blending is enabled, two more textures are needed
if (layeredTexturePreprocessingData.layeredTextureInfo[category].layerBlendingEnabled) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent1,
i,
texUnits[category][i].blendTexture1,
tileAndTransformParent1);
TileAndTransform tileAndTransformParent2 = tileProvider->getHighestResolutionTile(chunkIndex, 2);
if (tileAndTransformParent2.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent2 = tileAndTransformParent1;
}
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory(category),
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnits[category][i].blendTexture2,
tileAndTransformParent2);
}
i++;
}
}
// Go through all the height maps and set depth tranforms
int i = 0;
for (auto it = tileProviders[LayeredTextures::HeightMaps].begin();
it != tileProviders[LayeredTextures::HeightMaps].end(); it++) {
auto tileProvider = *it;
// Get the texture that should be used for rendering
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
TileDepthTransform depthTransform = tileProvider->depthTransform();
//std::string indexedTileKey = "heightTiles[" + std::to_string(i) + "]";
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) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
//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(
programUniformHandler,
LayeredTextures::TextureCategory::HeightMaps,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnitHeightParent2[i],
tileAndTransformParent2);
//activateTileAndSetTileUniforms(programObject, texUnitHeightParent2[i], indexedTileKeyParent2, tileAndTransformParent2);
}
i++;
}
// Go through all the color texture providers
i = 0;
for (auto it = colorTextureProviders.begin(); it != colorTextureProviders.end(); it++)
{
auto tileProvider = *it;
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
//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(
programUniformHandler,
LayeredTextures::TextureCategory::ColorTextures,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none,
i,
texUnitColor[i],
tileAndTransform);
// If blending is enabled, two more textures are needed
if (layeredTextureInfoColor.layerBlendingEnabled) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
//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);
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory::ColorTextures,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnitColorParent2[i],
tileAndTransformParent2);
}
i++;
}
// Go through all the night texture providers
i = 0;
for (auto it = nightTextureProviders.begin(); it != nightTextureProviders.end(); it++)
{
auto tileProvider = *it;
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
//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(
programUniformHandler,
LayeredTextures::TextureCategory::NightTextures,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none,
i,
texUnitNight[i],
tileAndTransform);
// If blending is enabled, two more textures are needed
if (layeredTextureInfoNight.layerBlendingEnabled) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
//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);
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory::NightTextures,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnitNightParent2[i],
tileAndTransformParent2);
}
i++;
}
// Go through all the overlay providers
i = 0;
for (auto it = overlayProviders.begin(); it != overlayProviders.end(); it++)
{
auto tileProvider = *it;
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
//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(
programUniformHandler,
LayeredTextures::TextureCategory::Overlays,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none,
i,
texUnitOverlay[i],
tileAndTransform);
// If blending is enabled, two more textures are needed
if (layeredTextureInfoOverlay.layerBlendingEnabled) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
//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);
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory::Overlays,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnitOverlayParent2[i],
tileAndTransformParent2);
}
i++;
}
// Go through all the water mask providers
i = 0;
for (auto it = waterMaskProviders.begin(); it != waterMaskProviders.end(); it++)
{
auto tileProvider = *it;
TileAndTransform tileAndTransform = tileProvider->getHighestResolutionTile(chunkIndex);
if (tileAndTransform.tile.status == Tile::Status::Unavailable) {
// don't render if no tile was available
programObject->deactivate();
return nullptr;
}
//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(
programUniformHandler,
LayeredTextures::TextureCategory::WaterMasks,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::none,
i,
texUnitWater[i],
tileAndTransform);
// If blending is enabled, two more textures are needed
if (layeredTextureInfoWater.layerBlendingEnabled) {
TileAndTransform tileAndTransformParent1 = tileProvider->getHighestResolutionTile(chunkIndex, 1);
if (tileAndTransformParent1.tile.status == Tile::Status::Unavailable) {
tileAndTransformParent1 = tileAndTransform;
}
//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);
activateTileAndSetTileUniforms(
programUniformHandler,
LayeredTextures::TextureCategory::WaterMasks,
LayeredTextureShaderUniformIdHandler::BlendLayerSuffix::Parent2,
i,
texUnitWaterParent2[i],
tileAndTransformParent2);
}
i++;
}
@@ -599,11 +310,16 @@ namespace openspace {
const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid();
// This information is only needed when doing blending
if ((heightMapProviders.size() > 0 && chunk.owner()->blendHeightMap) ||
(colorTextureProviders.size() > 0 && chunk.owner()->blendColorMap) ||
(nightTextureProviders.size() > 0 && chunk.owner()->blendNightTexture) ||
(overlayProviders.size() > 0 && chunk.owner()->blendOverlay) ||
(waterMaskProviders.size() > 0 && chunk.owner()->blendWaterMask)) {
bool blendAny = false;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
blendAny |= chunk.owner()->blendProperties[category];
}
if (blendAny &&
((heightMapProviders.size() > 0 ) ||
(colorTextureProviders.size() > 0 ) ||
(nightTextureProviders.size() > 0 ) ||
(overlayProviders.size() > 0 ) ||
(waterMaskProviders.size() > 0))) {
float distanceScaleFactor = chunk.owner()->lodScaleFactor * ellipsoid.minimumRadius();
programObject->setUniform("cameraPosition", vec3(data.camera.positionVec3()));
programObject->setUniform("distanceScaleFactor", distanceScaleFactor);
@@ -665,11 +381,17 @@ namespace openspace {
auto waterMaskProviders = _tileProviderManager->getActivatedLayerCategory(LayeredTextures::WaterMasks);
const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid();
if ((heightMapProviders.size() > 0 && chunk.owner()->blendHeightMap) ||
(colorTextureProviders.size() > 0 && chunk.owner()->blendColorMap) ||
(nightTextureProviders.size() > 0 && chunk.owner()->blendNightTexture) ||
(overlayProviders.size() > 0 && chunk.owner()->blendOverlay) ||
(waterMaskProviders.size() > 0 && chunk.owner()->blendWaterMask)) {
// This information is only needed when doing blending
bool blendAny = false;
for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
blendAny |= chunk.owner()->blendProperties[category];
}
if (blendAny &&
((heightMapProviders.size() > 0) ||
(colorTextureProviders.size() > 0) ||
(nightTextureProviders.size() > 0) ||
(overlayProviders.size() > 0) ||
(waterMaskProviders.size() > 0))) {
float distanceScaleFactor = chunk.owner()->lodScaleFactor * chunk.owner()->ellipsoid().minimumRadius();
programObject->setUniform("distanceScaleFactor", distanceScaleFactor);
programObject->setUniform("chunkLevel", chunk.index().level);
modules/globebrowsing/globes/renderableglobe.cpp
+5 -5
View File
@@ -201,11 +201,11 @@ namespace openspace {
_chunkedLodGlobe->initChunkVisible = initChunkVisible.value();
_chunkedLodGlobe->chunkHeight = chunkHeight.value();
_chunkedLodGlobe->blendHeightMap = blendHeightMap.value();
_chunkedLodGlobe->blendColorMap = blendColorMap.value();
_chunkedLodGlobe->blendNightTexture = blendNightTexture.value();
_chunkedLodGlobe->blendOverlay = blendOverlay.value();
_chunkedLodGlobe->blendWaterMask = blendWaterMask.value();
_chunkedLodGlobe->blendProperties[LayeredTextures::HeightMaps] = blendHeightMap.value();
_chunkedLodGlobe->blendProperties[LayeredTextures::ColorTextures] = blendColorMap.value();
_chunkedLodGlobe->blendProperties[LayeredTextures::NightTextures] = blendNightTexture.value();
_chunkedLodGlobe->blendProperties[LayeredTextures::Overlays] = blendOverlay.value();
_chunkedLodGlobe->blendProperties[LayeredTextures::WaterMasks] = blendWaterMask.value();
_chunkedLodGlobe->atmosphereEnabled = atmosphereEnabled.value();
_chunkedLodGlobe->showChunkEdges = showChunkEdges.value();
_chunkedLodGlobe->levelByProjArea = levelByProjArea.value();
modules/globebrowsing/tile/TileProviderManager.cpp
+3 -2
View File
@@ -148,10 +148,11 @@ namespace openspace {
}
const std::vector<std::shared_ptr<TileProvider> >
TileProviderManager::getActivatedLayerCategory(LayeredTextures::TextureCategory category)
TileProviderManager::getActivatedLayerCategory(
LayeredTextures::TextureCategory textureCategory)
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
for each (auto tileProviderWithName in _layerCategories[category]) {
for each (auto tileProviderWithName in _layerCategories[textureCategory]) {
if (tileProviderWithName.isActive) {
tileProviders.push_back(tileProviderWithName.tileProvider);
}
modules/globebrowsing/tile/TileProviderManager.h
+1 -1
View File
@@ -73,7 +73,7 @@ namespace openspace {
static std::shared_ptr<TileProvider> initProvider(const std::string& file,
const TileProviderInitData& initData);
std::array<LayerCategory, LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES> _layerCategories;
std::array<LayerCategory, LayeredTextures::NUM_TEXTURE_CATEGORIES> _layerCategories;
};
} // namespace openspace
modules/globebrowsing/tile/layeredtextures.cpp
+1 -1
View File
@@ -33,7 +33,7 @@ namespace {
namespace openspace {
const size_t LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES;
const size_t LayeredTextures::NUM_TEXTURE_CATEGORIES;
const size_t LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY;
const std::string LayeredTextures::TEXTURE_CATEGORY_NAMES[] =
modules/globebrowsing/tile/layeredtextures.h
+2 -2
View File
@@ -35,7 +35,7 @@ namespace openspace {
public:
static const size_t MAX_NUM_TEXTURE_CATEGORIES = 5;
static const size_t NUM_TEXTURE_CATEGORIES = 5;
static const size_t MAX_NUM_TEXTURES_PER_CATEGORY = 5;
enum TextureCategory {
@@ -46,7 +46,7 @@ namespace openspace {
Overlays,
};
static const std::string TEXTURE_CATEGORY_NAMES[MAX_NUM_TEXTURE_CATEGORIES];
static const std::string TEXTURE_CATEGORY_NAMES[NUM_TEXTURE_CATEGORIES];
};
} // namespace openspace
modules/globebrowsing/tile/layeredtextureshaderprovider.cpp
+2 -24
View File
@@ -37,11 +37,6 @@ namespace {
namespace openspace {
const std::string LayeredTextureInfo::glslKeyPrefixes[NUM_SETTINGS_PER_CATEGORY] =
{
"lastLayerIndex",
@@ -49,12 +44,10 @@ namespace openspace {
"blend",
};
bool LayeredTextureInfo::operator==(const LayeredTextureInfo& other) const
{
return
lastLayerIdx == other.lastLayerIdx &&
category == other.category &&
layerBlendingEnabled == other.layerBlendingEnabled;
}
@@ -160,18 +153,6 @@ namespace openspace {
}
const std::string LayeredTextureShaderUniformIdHandler::glslTileDataNames[NUM_TILE_DATA_VARIABLES] =
{
"textureSampler",
@@ -197,13 +178,13 @@ namespace openspace {
{
}
void LayeredTextureShaderUniformIdHandler::updateIds(LayeredTextureShaderProvider* shaderProvider)
void LayeredTextureShaderUniformIdHandler::updateIdsIfNecessary(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 i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++)
{
for (size_t j = 0; j < NUM_BLEND_TEXTURES; j++)
{
@@ -239,7 +220,4 @@ namespace openspace {
return *_shaderProvider->_programObject;
}
} // namespace openspace
modules/globebrowsing/tile/layeredtextureshaderprovider.h
+3 -10
View File
@@ -52,7 +52,6 @@ namespace openspace {
};
static const std::string glslKeyPrefixes[NUM_SETTINGS_PER_CATEGORY];
LayeredTextures::TextureCategory category;
int lastLayerIdx;
bool layerBlendingEnabled;
@@ -61,7 +60,7 @@ namespace openspace {
struct LayeredTexturePreprocessingData
{
std::array<LayeredTextureInfo, LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES> layeredTextureInfo;
std::array<LayeredTextureInfo, LayeredTextures::NUM_TEXTURE_CATEGORIES> layeredTextureInfo;
std::vector<std::pair<std::string, std::string> > keyValuePairs;
bool operator==(const LayeredTexturePreprocessingData& other) const;
};
@@ -93,12 +92,6 @@ namespace openspace {
bool _updatedOnLastCall;
};
class LayeredTextureShaderUniformIdHandler
{
@@ -123,7 +116,7 @@ namespace openspace {
LayeredTextureShaderUniformIdHandler();
~LayeredTextureShaderUniformIdHandler();
void updateIds(LayeredTextureShaderProvider* shaderProvider);
void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider);
GLint getId(
LayeredTextures::TextureCategory category,
@@ -140,7 +133,7 @@ namespace openspace {
std::array<
std::array<
GLint,
LayeredTextures::MAX_NUM_TEXTURE_CATEGORIES>,
LayeredTextures::NUM_TEXTURE_CATEGORIES>,
LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY>,
NUM_BLEND_TEXTURES>,
NUM_TILE_DATA_VARIABLES>