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

Layers can be turned on and off during runtime and shaders will be recompiled accordingly.

Browse Source
This commit is contained in:
Kalle Bladin
2016-05-31 19:26:42 -04:00
parent aa5e64c31b
commit 0202828c73
7 changed files with 112 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
data/scene/debugglobe/debugglobe.mod
View File

@@ -10,32 +10,20 @@ return {
Textures = {
ColorTextures = {
{
Name = "ESRI Imagery World 2D",
FilePath = "map_service_configs/ESRI_Imagery_World_2D.wms",
Name = "VIIRS_SNPP_CorrectedReflectance_TrueColor",
FilePath = "map_service_configs/VIIRS_SNPP_CorrectedReflectance_TrueColor.xml"
},
--[[
{
Name = "Coastlines",
FilePath = "map_service_configs/Coastlines.xml",
},
{
Name = "VIIRS_SNPP_CorrectedReflectance_TrueColor",
FilePath = "map_service_configs/VIIRS_SNPP_CorrectedReflectance_TrueColor.xml"
},
{
Name = "ESRI Imagery World 2D",
FilePath = "map_service_configs/ESRI_Imagery_World_2D.wms",
},
{
Name = "MODIS_Terra_CorrectedReflectance_TrueColor",
FilePath = "map_service_configs/MODIS_Terra_CorrectedReflectance_TrueColor.xml",
},
--]]
},
HeightMaps = {
{
Name = "Terrain tileset",

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

@@ -130,7 +130,10 @@ namespace openspace {
std::shared_ptr<TileProvider> colorTextureProvider = std::shared_ptr<TileProvider>(
new TileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
_tileProviderManager->addColorTexture(name, colorTextureProvider);
_tileProviderManager->addColorTexture(name, colorTextureProvider, true);
// Create property for this tile provider
_activeColorLayers.push_back(properties::BoolProperty(name, name, true));
}
ghoul::Dictionary heightMapsDictionary;
@@ -158,8 +161,20 @@ namespace openspace {
new TileProvider(tileReader, cacheSize, frameUntilFlushRequestQueue));
_tileProviderManager->addHeightMap(name, heightMapProvider);
_tileProviderManager->addHeightMap(name, heightMapProvider, true);
// Create property for this tile provider
_activeHeightMapLayers.push_back(properties::BoolProperty(name, name, true));
}
// Add properties for the tile providers
for (auto it = _activeColorLayers.begin(); it != _activeColorLayers.end(); it++) {
addProperty(*it);
}
for (auto it = _activeHeightMapLayers.begin(); it != _activeHeightMapLayers.end(); it++) {
addProperty(*it);
}
_chunkedLodGlobe = std::shared_ptr<ChunkedLodGlobe>(
new ChunkedLodGlobe(_ellipsoid, patchSegments, _tileProviderManager));
@@ -198,17 +213,31 @@ namespace openspace {
_chunkedLodGlobe->setSaveCamera(nullptr);
}
}
_chunkedLodGlobe->doFrustumCulling = doFrustumCulling.value();
_chunkedLodGlobe->doHorizonCulling = doHorizonCulling.value();
_chunkedLodGlobe->mergeInvisible = mergeInvisible.value();
_chunkedLodGlobe->lodScaleFactor= lodScaleFactor.value();
_chunkedLodGlobe->initChunkVisible = initChunkVisible.value();
_distanceSwitch.render(data);
}
void RenderableGlobe::update(const UpdateData& data) {
_time = data.time;
_distanceSwitch.update(data);
_chunkedLodGlobe->doFrustumCulling = doFrustumCulling.value();
_chunkedLodGlobe->doHorizonCulling = doHorizonCulling.value();
_chunkedLodGlobe->mergeInvisible = mergeInvisible.value();
_chunkedLodGlobe->lodScaleFactor = lodScaleFactor.value();
_chunkedLodGlobe->initChunkVisible = initChunkVisible.value();
std::vector<TileProviderManager::TileProviderWithName>& colorTextureProviders =
_tileProviderManager->colorTextureProviders();
std::vector<TileProviderManager::TileProviderWithName>& heightMapProviders =
_tileProviderManager->heightMapProviders();
for (size_t i = 0; i < colorTextureProviders.size(); i++) {
colorTextureProviders[i].isActive = _activeColorLayers[i].value();
}
for (size_t i = 0; i < heightMapProviders.size(); i++) {
heightMapProviders[i].isActive = _activeHeightMapLayers[i].value();
}
}
glm::dvec3 RenderableGlobe::geodeticSurfaceProjection(glm::dvec3 position) {

3
modules/globebrowsing/globes/renderableglobe.h
View File

@@ -88,6 +88,9 @@ private:
properties::BoolProperty _saveOrThrowCamera;
std::vector<properties::BoolProperty> _activeColorLayers;
std::vector<properties::BoolProperty> _activeHeightMapLayers;
DistanceSwitch _distanceSwitch;
};

42
modules/globebrowsing/other/TileProviderManager.cpp
View File

@@ -44,29 +44,57 @@ namespace openspace {
void TileProviderManager::addHeightMap(
std::string name,
std::shared_ptr<TileProvider> tileProvider)
std::shared_ptr<TileProvider> tileProvider,
bool isActive)
{
_heightMapProviders.push_back(tileProvider);
_heightMapProviders.push_back({ name , tileProvider, isActive});
}
void TileProviderManager::addColorTexture(
std::string name,
std::shared_ptr<TileProvider> tileProvider)
std::shared_ptr<TileProvider> tileProvider,
bool isActive)
{
_colorTextureProviders.push_back(tileProvider);
_colorTextureProviders.push_back({ name , tileProvider, isActive });
}
const std::vector<std::shared_ptr<TileProvider> >&
std::vector<TileProviderManager::TileProviderWithName>&
TileProviderManager::heightMapProviders()
{
return _heightMapProviders;
}
const std::vector<std::shared_ptr<TileProvider> >&
std::vector<TileProviderManager::TileProviderWithName>&
TileProviderManager::colorTextureProviders()
{
return _colorTextureProviders;
}
const std::vector<std::shared_ptr<TileProvider> >
TileProviderManager::getActiveHeightMapProviders()
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
for (auto it = _heightMapProviders.begin(); it != _heightMapProviders.end(); it++)
{
if (it->isActive) {
tileProviders.push_back(it->tileProvider);
}
}
return tileProviders;
}
const std::vector<std::shared_ptr<TileProvider> >
TileProviderManager::getActiveColorTextureProviders()
{
std::vector<std::shared_ptr<TileProvider> > tileProviders;
for (auto it = _colorTextureProviders.begin(); it != _colorTextureProviders.end(); it++)
{
if (it->isActive) {
tileProviders.push_back(it->tileProvider);
}
}
return tileProviders;
}
} // namespace openspace

27
modules/globebrowsing/other/TileProviderManager.h
View File

@@ -37,23 +37,38 @@ namespace openspace {
class TileProviderManager {
public:
struct TileProviderWithName {
std::string name;
std::shared_ptr<TileProvider> tileProvider;
bool isActive;
};
TileProviderManager();
~TileProviderManager();
static ThreadPool tileRequestThreadPool;
void addHeightMap(std::string name, std::shared_ptr<TileProvider> tileProvider);
void addColorTexture(std::string name, std::shared_ptr<TileProvider> tileProvider);
void addHeightMap(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
bool isActive);
void addColorTexture(
std::string name,
std::shared_ptr<TileProvider> tileProvider,
bool isActive);
/*
std::shared_ptr<TileProvider> getHeightMap(std::string name);
std::shared_ptr<TileProvider> getColorTexture(std::string name);
*/
const std::vector<std::shared_ptr<TileProvider> >& heightMapProviders();
const std::vector<std::shared_ptr<TileProvider> >& colorTextureProviders();
const std::vector<std::shared_ptr<TileProvider> > getActiveHeightMapProviders();
const std::vector<std::shared_ptr<TileProvider> > getActiveColorTextureProviders();
std::vector<TileProviderWithName>& heightMapProviders();
std::vector<TileProviderWithName>& colorTextureProviders();
private:
std::vector<std::shared_ptr<TileProvider> > _heightMapProviders;
std::vector<std::shared_ptr<TileProvider> > _colorTextureProviders;
std::vector<TileProviderWithName> _heightMapProviders;
std::vector<TileProviderWithName> _colorTextureProviders;
};
} // namespace openspace

3
modules/globebrowsing/other/layeredtextureshaderprovider.cpp
View File

@@ -107,6 +107,9 @@ namespace openspace {
textureTypes[i].keyNumLayers, textureTypes[i].numLayers);
}
// Remove old program
_programObject.release();
_programObject = OsEng.renderEngine().buildRenderProgram(
_shaderName,
_vsPath,

210
modules/globebrowsing/rendering/patchrenderer.cpp
View File

@@ -69,12 +69,12 @@ namespace openspace {
}
void PatchRenderer::update() {
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto heightMapProviders = _tileProviderManager->getActiveHeightMapProviders();
for (auto iter = heightMapProviders.begin(); iter != heightMapProviders.end(); iter++)
{
iter->get()->prerender();
}
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto colorTextureProviders = _tileProviderManager->getActiveColorTextureProviders();
for (auto iter = colorTextureProviders.begin(); iter != colorTextureProviders.end(); iter++)
{
iter->get()->prerender();
@@ -101,24 +101,6 @@ namespace openspace {
"LocalChunkedLodPatch",
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_vs.glsl",
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_fs.glsl"));
/*
_programObjectGlobalRendering = OsEng.renderEngine().buildRenderProgram(
"GlobalChunkedLodPatch",
"${MODULE_GLOBEBROWSING}/shaders/globalchunkedlodpatch_vs.glsl",
"${MODULE_GLOBEBROWSING}/shaders/globalchunkedlodpatch_fs.glsl");
ghoul_assert(_programObjectGlobalRendering != nullptr, "Failed to initialize programObject!");
_programObjectLocalRendering = OsEng.renderEngine().buildRenderProgram(
"LocalChunkedLodPatch",
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_vs.glsl",
"${MODULE_GLOBEBROWSING}/shaders/localchunkedlodpatch_fs.glsl");
ghoul_assert(_programObjectLocalRendering != nullptr, "Failed to initialize programObject!");
using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
_programObjectGlobalRendering->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
_programObjectLocalRendering->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
*/
}
void ChunkRenderer::renderChunk(const Chunk& chunk, const RenderData& data) {
@@ -134,8 +116,8 @@ namespace openspace {
using namespace glm;
// All providers of tiles
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto heightMapProviders = _tileProviderManager->getActiveHeightMapProviders();
auto colorTextureProviders = _tileProviderManager->getActiveColorTextureProviders();
int numHeightMapProviders = heightMapProviders.size();
int numColorTextureProviders = colorTextureProviders.size();
@@ -261,73 +243,6 @@ namespace openspace {
// disable shader
programObject->deactivate();
/*
// activate shader
_programObjectGlobalRendering->activate();
// For now just pick the first one from height maps
//auto heightMapProviders = _tileProviderManager->heightMapProviders();
//auto tileProviderHeight = heightMapProviders.begin()->second;
// Get the textures that should be used for rendering
Tile heightTile = tileProviderHeight->getHighestResolutionTile(chunk.index());
// Bind and use the texture
ghoul::opengl::TextureUnit texUnitHeight;
texUnitHeight.activate();
heightTile.texture->bind();
_programObjectGlobalRendering->setUniform("heightTile.textureSampler", texUnitHeight);
_programObjectGlobalRendering->setUniform("heightTile.uvTransform.uvScale", heightTile.uvTransform.uvScale);
_programObjectGlobalRendering->setUniform("heightTile.uvTransform.uvOffset", heightTile.uvTransform.uvOffset);
TileDepthTransform depthTransformHeight = tileProviderHeight->depthTransform();
_programObjectGlobalRendering->setUniform("heightTile.depthTransform.depthScale", depthTransformHeight.depthScale);
_programObjectGlobalRendering->setUniform("heightTile.depthTransform.depthOffset", depthTransformHeight.depthOffset);
// Pick the first color texture
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto tileProviderColor = colorTextureProviders.begin()->second;
Tile colorTile = tileProviderColor->getHighestResolutionTile(chunk.index());
// Bind and use the texture
ghoul::opengl::TextureUnit texUnitColor;
texUnitColor.activate();
colorTile.texture->bind();
_programObjectGlobalRendering->setUniform("colorTile.textureSampler", texUnitColor);
_programObjectGlobalRendering->setUniform("colorTile.uvTransform.uvScale", colorTile.uvTransform.uvScale);
_programObjectGlobalRendering->setUniform("colorTile.uvTransform.uvOffset", colorTile.uvTransform.uvOffset);
Geodetic2 swCorner = chunk.surfacePatch().southWestCorner();
auto patchSize = chunk.surfacePatch().size();
const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid();
_programObjectGlobalRendering->setUniform("modelViewProjectionTransform", modelViewProjectionTransform);
_programObjectGlobalRendering->setUniform("minLatLon", vec2(swCorner.toLonLatVec2()));
_programObjectGlobalRendering->setUniform("lonLatScalingFactor", vec2(patchSize.toLonLatVec2()));
_programObjectGlobalRendering->setUniform("radiiSquared", vec3(ellipsoid.radiiSquared()));
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// render
_grid->geometry().drawUsingActiveProgram();
// disable shader
_programObjectGlobalRendering->deactivate();
*/
}
void ChunkRenderer::renderChunkLocally(const Chunk& chunk, const RenderData& data)
@@ -335,8 +250,8 @@ namespace openspace {
using namespace glm;
// All providers of tiles
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto heightMapProviders = _tileProviderManager->getActiveHeightMapProviders();
auto colorTextureProviders = _tileProviderManager->getActiveColorTextureProviders();
int numHeightMapProviders = heightMapProviders.size();
int numColorTextureProviders = colorTextureProviders.size();
@@ -434,12 +349,6 @@ namespace openspace {
}
// Calculate other uniform variables needed for rendering
// TODO : Model transform should be fetched as a matrix directly.
@@ -499,105 +408,6 @@ namespace openspace {
// disable shader
programObject->deactivate();
/*
using namespace glm;
// TODO : Model transform should be fetched as a matrix directly.
mat4 modelTransform = translate(mat4(1), data.position.vec3());
mat4 viewTransform = data.camera.combinedViewMatrix();
mat4 modelViewTransform = viewTransform * modelTransform;
// activate shader
_programObjectLocalRendering->activate();
// For now just pick the first one from height maps
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto tileProviderHeight = heightMapProviders.begin()->second;
// Get the textures that should be used for rendering
Tile heightTile = tileProviderHeight->getHighestResolutionTile(chunk.index());
// Bind and use the texture
ghoul::opengl::TextureUnit texUnitHeight;
texUnitHeight.activate();
heightTile.texture->bind();
_programObjectLocalRendering->setUniform("heightTile.textureSampler", texUnitHeight);
_programObjectLocalRendering->setUniform("heightTile.uvTransform.uvScale", heightTile.uvTransform.uvScale);
_programObjectLocalRendering->setUniform("heightTile.uvTransform.uvOffset", heightTile.uvTransform.uvOffset);
TileDepthTransform depthTransformHeight = tileProviderHeight->depthTransform();
_programObjectLocalRendering->setUniform("heightTile.depthTransform.depthScale", depthTransformHeight.depthScale);
_programObjectLocalRendering->setUniform("heightTile.depthTransform.depthOffset", depthTransformHeight.depthOffset);
// Pick the first color texture
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto tileProviderColor = colorTextureProviders.begin()->second;
Tile colorTile = tileProviderColor->getHighestResolutionTile(chunk.index());
// Bind and use the texture
ghoul::opengl::TextureUnit texUnitColor;
texUnitColor.activate();
colorTile.texture->bind();
_programObjectLocalRendering->setUniform("colorTile.textureSampler", texUnitColor);
_programObjectLocalRendering->setUniform("colorTile.uvTransform.uvScale", colorTile.uvTransform.uvScale);
_programObjectLocalRendering->setUniform("colorTile.uvTransform.uvOffset", colorTile.uvTransform.uvOffset);
Geodetic2 sw = chunk.surfacePatch().southWestCorner();
Geodetic2 se = chunk.surfacePatch().southEastCorner();
Geodetic2 nw = chunk.surfacePatch().northWestCorner();
Geodetic2 ne = chunk.surfacePatch().northEastCorner();
const Ellipsoid& ellipsoid = chunk.owner()->ellipsoid();
// Get model space positions of the four control points
Vec3 patchSwModelSpace = ellipsoid.cartesianSurfacePosition(sw);
Vec3 patchSeModelSpace = ellipsoid.cartesianSurfacePosition(se);
Vec3 patchNwModelSpace = ellipsoid.cartesianSurfacePosition(nw);
Vec3 patchNeModelSpace = ellipsoid.cartesianSurfacePosition(ne);
// Transform all control points to camera space
Vec3 patchSwCameraSpace = Vec3(dmat4(modelViewTransform) * glm::dvec4(patchSwModelSpace, 1));
Vec3 patchSeCameraSpace = Vec3(dmat4(modelViewTransform) * glm::dvec4(patchSeModelSpace, 1));
Vec3 patchNwCameraSpace = Vec3(dmat4(modelViewTransform) * glm::dvec4(patchNwModelSpace, 1));
Vec3 patchNeCameraSpace = Vec3(dmat4(modelViewTransform) * glm::dvec4(patchNeModelSpace, 1));
// Send control points to shader
_programObjectLocalRendering->setUniform("p00", vec3(patchSwCameraSpace));
_programObjectLocalRendering->setUniform("p10", vec3(patchSeCameraSpace));
_programObjectLocalRendering->setUniform("p01", vec3(patchNwCameraSpace));
_programObjectLocalRendering->setUniform("p11", vec3(patchNeCameraSpace));
vec3 patchNormalCameraSpace = normalize(
cross(patchSeCameraSpace - patchSwCameraSpace,
patchNwCameraSpace - patchSwCameraSpace));
_programObjectLocalRendering->setUniform(
"patchNormalCameraSpace",
patchNormalCameraSpace);
_programObjectLocalRendering->setUniform(
"projectionTransform",
data.camera.projectionMatrix());
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// render
_grid->geometry().drawUsingActiveProgram();
// disable shader
_programObjectLocalRendering->deactivate();
*/
}
//////////////////////////////////////////////////////////////////////////////////////
@@ -692,7 +502,7 @@ namespace openspace {
// For now just pick the first one from height maps
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto heightMapProviders = _tileProviderManager->getActiveHeightMapProviders();
auto tileProviderHeight = heightMapProviders[0];
PatchCoverage patchCoverageHeight = _patchCoverageProvider.getCoverage(newPatch, tileProviderHeight);
@@ -747,7 +557,7 @@ namespace openspace {
// Pick the first color texture
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto colorTextureProviders = _tileProviderManager->getActiveColorTextureProviders();
auto tileProviderColor = colorTextureProviders[0];
PatchCoverage patchCoverageColor = _patchCoverageProvider.getCoverage(newPatch, tileProviderColor);
@@ -879,7 +689,7 @@ namespace openspace {
_programObjectLocalRendering->setUniform("patchNormal", patchNormal);
// For now just pick the first one from height maps
auto heightMapProviders = _tileProviderManager->heightMapProviders();
auto heightMapProviders = _tileProviderManager->getActiveHeightMapProviders();
auto tileProviderHeight = heightMapProviders[0];
PatchCoverage patchCoverageHeight = _patchCoverageProvider.getCoverage(newPatch, tileProviderHeight);
@@ -935,7 +745,7 @@ namespace openspace {
// Pick the first color texture
auto colorTextureProviders = _tileProviderManager->colorTextureProviders();
auto colorTextureProviders = _tileProviderManager->getActiveColorTextureProviders();
auto tileProviderColor = colorTextureProviders[0];
PatchCoverage patchCoverageColor = _patchCoverageProvider.getCoverage(newPatch, tileProviderColor);