mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-01-05 19:19:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Add Spice kernels for Mercury and Saturn magnetosphere rendering, implement inside volume rendering for kameleon volumes

Browse Source 
Conflicts:
	data/scene/mercury/mercury.mod
	data/scene/saturn/saturn/saturn.mod
This commit is contained in:
Emil Axelsson
2016-10-26 14:43:37 +02:00
parent cb7e81cf3d
commit 686fec4f9d
13 changed files with 202 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
data/scene/mercury/mercury.mod
View File

@@ -1,3 +1,5 @@
MercuryRadius = 2.4397E6;
return {
-- Mercury barycenter module
{
@@ -22,7 +24,7 @@ return {
Body = "MERCURY",
Geometry = {
Type = "SimpleSphere",
Radius = { 2.440, 6 },
Radius = {MercuryRadius, 1.0},
Segments = 100
},
Textures = {

5
data/scene/saturn/saturn/saturn.mod
View File

@@ -1,3 +1,6 @@
SaturnRadius = 5.8232E7;
return {
-- Saturn barycenter module
{
@@ -23,7 +26,7 @@ return {
Body = "SATURN BARYCENTER",
Geometry = {
Type = "SimpleSphere",
Radius = { 5.8232, 7 },
Radius = {SaturnRadius, 0},
Segments = 100
},
Textures = {

76
data/spice/iSWAKernels/openspace_SE.ti Normal file
View File

@@ -0,0 +1,76 @@
OpenSpace ecliptic frames:
Mercury-centric Solar Ecliptic (MERCURYSE) frame
Saturn-centric Solar Ecliptic (SATURNSE) frame
These frames are only defined as helper frames for OpenSpace.
+X is parallel to the geometric planet-sun position vector.
+Y axis is the normalized component of the geometric planet-sun velocity
vector orthogonal to the frame's +X axis.
+Z axis is parallel to the cross product of the frame's +X axis
and the frame's +Y axis.
\begindata
FRAME_MERCURYSE = 4600199
FRAME_4600199_NAME = 'MERCURYSE'
FRAME_4600199_CLASS = 5
FRAME_4600199_CLASS_ID = 4600199
FRAME_4600199_CENTER = 199
FRAME_4600199_RELATIVE = 'J2000'
FRAME_4600199_DEF_STYLE = 'PARAMETERIZED'
FRAME_4600199_FAMILY = 'TWO-VECTOR'
FRAME_4600199_PRI_AXIS = 'X'
FRAME_4600199_PRI_VECTOR_DEF = 'OBSERVER_TARGET_POSITION'
FRAME_4600199_PRI_OBSERVER = 'MERCURY'
FRAME_4600199_PRI_TARGET = 'SUN'
FRAME_4600199_PRI_ABCORR = 'NONE'
FRAME_4600199_SEC_AXIS = 'Y'
FRAME_4600199_SEC_VECTOR_DEF = 'OBSERVER_TARGET_VELOCITY'
FRAME_4600199_SEC_OBSERVER = 'MERCURY'
FRAME_4600199_SEC_TARGET = 'SUN'
FRAME_4600199_SEC_ABCORR = 'NONE'
FRAME_4600199_SEC_FRAME = 'J2000'
FRAME_SATURNSE = 4600699
FRAME_4600699_NAME = 'SATURNSE'
FRAME_4600699_CLASS = 5
FRAME_4600699_CLASS_ID = 4600699
FRAME_4600699_CENTER = 699
FRAME_4600699_RELATIVE = 'J2000'
FRAME_4600699_DEF_STYLE = 'PARAMETERIZED'
FRAME_4600699_FAMILY = 'TWO-VECTOR'
FRAME_4600699_PRI_AXIS = 'X'
FRAME_4600699_PRI_VECTOR_DEF = 'OBSERVER_TARGET_POSITION'
FRAME_4600699_PRI_OBSERVER = 'SATURN BARYCENTER'
FRAME_4600699_PRI_TARGET = 'SUN'
FRAME_4600699_PRI_ABCORR = 'NONE'
FRAME_4600699_SEC_AXIS = 'Y'
FRAME_4600699_SEC_VECTOR_DEF = 'OBSERVER_TARGET_VELOCITY'
FRAME_4600699_SEC_OBSERVER = 'SATURN BARYCENTER'
FRAME_4600699_SEC_TARGET = 'SUN'
FRAME_4600699_SEC_ABCORR = 'NONE'
FRAME_4600699_SEC_FRAME = 'J2000'
FRAME_SATURNSEINV = 4600698
FRAME_4600698_NAME = 'SATURNSEINV'
FRAME_4600698_CLASS = 5
FRAME_4600698_CLASS_ID = 4600699
FRAME_4600698_CENTER = 699
FRAME_4600698_RELATIVE = 'J2000'
FRAME_4600698_DEF_STYLE = 'PARAMETERIZED'
FRAME_4600698_FAMILY = 'TWO-VECTOR'
FRAME_4600698_PRI_AXIS = 'X'
FRAME_4600698_PRI_VECTOR_DEF = 'OBSERVER_TARGET_POSITION'
FRAME_4600698_PRI_OBSERVER = 'SATURN BARYCENTER'
FRAME_4600698_PRI_TARGET = 'SUN'
FRAME_4600698_PRI_ABCORR = 'NONE'
FRAME_4600698_SEC_AXIS = 'Y'
FRAME_4600698_SEC_VECTOR_DEF = 'OBSERVER_TARGET_VELOCITY'
FRAME_4600698_SEC_OBSERVER = 'SUN'
FRAME_4600698_SEC_TARGET = 'SATURN BARYCENTER'
FRAME_4600698_SEC_ABCORR = 'NONE'
FRAME_4600698_SEC_FRAME = 'J2000'

7
include/openspace/rendering/abufferrenderer.h
View File

@@ -71,8 +71,8 @@ public:
void setResolution(glm::ivec2 res) override;
void setNAaSamples(int nAaSamples) override;
void preRaycast(ghoul::opengl::ProgramObject& programObject);
void postRaycast(ghoul::opengl::ProgramObject& programObject);
void preRaycast(const RaycasterTask& raycasterTask);
void postRaycast(const RaycasterTask& raycasterTask);
void update();
void render(float blackoutFactor, bool doPerformanceMeasurements) override;
@@ -130,9 +130,6 @@ private:
GLuint _vertexPositionBuffer;
int _nAaSamples;
std::unique_ptr<RendererTasks> _rendererTasks;
std::unique_ptr<RenderData> _renderData;
float _blackoutFactor;
ghoul::Dictionary _rendererData;

1
modules/kameleon/include/kameleonwrapper.h
View File

@@ -136,7 +136,6 @@ public:
Model model();
GridType gridType();
std::string getParent();
std::string getFrame();
std::vector<std::string> getVariables();
std::vector<std::string> getLoadedVariables();

20
modules/kameleon/src/kameleonwrapper.cpp
View File

@@ -1008,24 +1008,6 @@ glm::vec4 KameleonWrapper::classifyFieldline(FieldlineEnd fEnd, FieldlineEnd bEn
return color;
}
std::string KameleonWrapper::getParent(){
if( _type == KameleonWrapper::Model::BATSRUS ||
_type == KameleonWrapper::Model::OpenGGCM ||
_type == KameleonWrapper::Model::LFM)
{
return "Earth";
}else if(
_type == KameleonWrapper::Model::ENLIL ||
_type == KameleonWrapper::Model::MAS ||
_type == KameleonWrapper::Model::Adapt3D ||
_type == KameleonWrapper::Model::SWMF)
{
return "Sun";
}else{
return "";
}
}
std::string KameleonWrapper::getFrame(){
if( _type == KameleonWrapper::Model::BATSRUS ||
_type == KameleonWrapper::Model::OpenGGCM ||
@@ -1050,8 +1032,6 @@ std::vector<std::string> KameleonWrapper::getVariables(){
int numVariables = _model->getNumberOfVariables();
for(int i=0; i<numVariables; i++){
// std::cout << _model->getVariableName(i) << " ";
// std::cout << _model->getVariableName(i) << std::endl;
variableNames.push_back(_model->getVariableName(i));;
}
return variableNames;

43
modules/kameleonvolume/rendering/kameleonvolumeraycaster.cpp
View File

@@ -60,9 +60,14 @@ void KameleonVolumeRaycaster::deinitialize() {
}
void KameleonVolumeRaycaster::renderEntryPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) {
//program.setUniform("modelTransform", _modelTransform);
program.setUniform("viewProjection", data.camera.viewProjectionMatrix());
Renderable::setPscUniforms(program, data.camera, data.position);
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
glm::dmat4(data.modelTransform.rotation) * // Spice rotation
glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
program.setUniform("modelViewTransform", glm::mat4(modelViewTransform));
program.setUniform("projectionTransform", data.camera.projectionMatrix());
// Cull back face
glEnable(GL_CULL_FACE);
@@ -72,11 +77,15 @@ void KameleonVolumeRaycaster::renderEntryPoints(const RenderData& data, ghoul::o
_boundingBox.render();
}
void KameleonVolumeRaycaster::renderExitPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) {
// Uniforms
//program.setUniform("modelTransform", _modelTransform);
program.setUniform("viewProjection", data.camera.viewProjectionMatrix());
Renderable::setPscUniforms(program, data.camera, data.position);
void KameleonVolumeRaycaster::renderExitPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) {
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
program.setUniform("modelViewTransform", glm::mat4(modelViewTransform));
program.setUniform("projectionTransform", data.camera.projectionMatrix());
// Cull front face
glEnable(GL_CULL_FACE);
@@ -113,6 +122,20 @@ void KameleonVolumeRaycaster::postRaycast(const RaycastData& data, ghoul::opengl
_textureUnit = nullptr;
_tfUnit = nullptr;
}
bool KameleonVolumeRaycaster::cameraIsInside(const RenderData & data, glm::vec3 & localPosition)
{
glm::dmat4 modelTransform =
glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
glm::dmat4(data.modelTransform.rotation) *
glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
glm::vec4 modelPos = glm::inverse(modelViewTransform) * glm::vec4(0.0, 0.0, 0.0, 1.0);
localPosition = (glm::vec3(modelPos) + glm::vec3(0.5));
return (localPosition.x > 0 && localPosition.y > 0 && localPosition.z > 0 && localPosition.x < 1 && localPosition.y < 1 && localPosition.z < 1);
}
std::string KameleonVolumeRaycaster::getBoundsVsPath() const {
return GlslBoundsVsPath;
@@ -138,5 +161,9 @@ void KameleonVolumeRaycaster::setGridType(VolumeGridType gridType)
{
_gridType = gridType;
}
void KameleonVolumeRaycaster::setModelTransform(const glm::mat4 & transform) {
_modelTransform = transform;
}
}

3
modules/kameleonvolume/rendering/kameleonvolumeraycaster.h
View File

@@ -65,6 +65,7 @@ public:
void renderExitPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) override;
void preRaycast(const RaycastData& data, ghoul::opengl::ProgramObject& program) override;
void postRaycast(const RaycastData& data, ghoul::opengl::ProgramObject& program) override;
bool cameraIsInside(const RenderData& data, glm::vec3& localPosition) override;
std::string getBoundsVsPath() const override;
std::string getBoundsFsPath() const override;
@@ -73,11 +74,13 @@ public:
void setStepSize(float stepSize);
void setGridType(VolumeGridType gridType);
void setModelTransform(const glm::mat4& transform);
private:
std::shared_ptr<ghoul::opengl::Texture> _volumeTexture;
std::shared_ptr<TransferFunction> _transferFunction;
BoxGeometry _boundingBox;
VolumeGridType _gridType;
glm::mat4 _modelTransform;
std::unique_ptr<ghoul::opengl::TextureUnit> _tfUnit;
std::unique_ptr<ghoul::opengl::TextureUnit> _textureUnit;

30
modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
View File

@@ -53,6 +53,7 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
, _variable("variable", "Variable")
, _lowerDomainBound("lowerDomainBound", "Lower Domain Bound")
, _upperDomainBound("upperDomainBound", "Upper Domain Bound")
, _domainScale("domainScale", "Domain scale")
, _autoDomainBounds(false)
, _lowerValueBound("lowerValueBound", "Lower Value Bound", 0.0, 0.0, 1)
, _upperValueBound("upperValueBound", "Upper Value Bound", 1, 0.01, 1)
@@ -111,6 +112,13 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
_autoDomainBounds = true;
}
glm::vec3 domainScale;
if (dictionary.getValue("DomainScale", domainScale)) {
_domainScale = domainScale;
} else {
_domainScale = glm::vec3(1, 1, 1); // Assume meters if nothing else is specified.
}
float lowerValueBound;
if (dictionary.getValue("LowerValueBound", lowerValueBound)) {
_lowerValueBound = lowerValueBound;
@@ -168,6 +176,13 @@ bool RenderableKameleonVolume::initialize() {
_raycaster->setGridType(static_cast<VolumeGridType>(_gridType.value()));
});
updateRaycasterModelTransform();
_lowerDomainBound.onChange([this] {
updateRaycasterModelTransform();
});
_upperDomainBound.onChange([this] {
updateRaycasterModelTransform();
});
_raycaster->initialize();
@@ -193,6 +208,7 @@ bool RenderableKameleonVolume::initialize() {
addProperty(_variable);
addProperty(_lowerDomainBound);
addProperty(_upperDomainBound);
addProperty(_domainScale);
addProperty(_lowerValueBound);
addProperty(_upperValueBound);
addProperty(_gridType);
@@ -202,6 +218,19 @@ bool RenderableKameleonVolume::initialize() {
return true;
}
void RenderableKameleonVolume::updateRaycasterModelTransform() {
glm::vec3 lowerBoundingBoxBound = _domainScale.value() * _lowerDomainBound.value();
glm::vec3 upperBoundingBoxBound = _domainScale.value() * _upperDomainBound.value();
glm::vec3 scale = upperBoundingBoxBound - lowerBoundingBoxBound;
glm::vec3 translation = (lowerBoundingBoxBound + upperBoundingBoxBound) * 0.5f;
glm::mat4 modelTransform = glm::translate(glm::mat4(1.0), translation);
modelTransform = glm::scale(modelTransform, scale);
_raycaster->setModelTransform(modelTransform);
}
bool RenderableKameleonVolume::cachingEnabled() {
return _cache;
}
@@ -331,6 +360,7 @@ bool RenderableKameleonVolume::isReady() const {
}
void RenderableKameleonVolume::update(const UpdateData& data) {
// forward this transformation!
if (_raycaster) {
_raycaster->setStepSize(_stepSize);
}

2
modules/kameleonvolume/rendering/renderablekameleonvolume.h
View File

@@ -63,11 +63,13 @@ private:
std::string cacheSuffix();
void updateTextureFromVolume();
void updateRaycasterModelTransform();
properties::UVec3Property _dimensions;
properties::StringProperty _variable;
properties::Vec3Property _lowerDomainBound;
properties::Vec3Property _upperDomainBound;
properties::Vec3Property _domainScale;
bool _autoDomainBounds;
properties::FloatProperty _lowerValueBound;

8
modules/kameleonvolume/shaders/boundsfs.glsl
View File

@@ -22,15 +22,15 @@
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
in vec3 vPosition;
in vec4 worldPosition;
in vec4 positionLocalSpace;
in vec4 positionCameraSpace;
#include "PowerScaling/powerScaling_fs.hglsl"
#include "fragment.glsl"
Fragment getFragment() {
vec4 fragColor = vec4(vPosition+0.5, 1.0);
vec4 position = worldPosition;
vec4 fragColor = vec4(positionLocalSpace.xyz+0.5, 1.0);
vec4 position = positionCameraSpace;
float depth = pscDepth(position);
Fragment frag;

26
modules/kameleonvolume/shaders/boundsvs.glsl
View File

@@ -24,23 +24,25 @@
#version __CONTEXT__
layout(location = 0) in vec4 vertPosition;
layout(location = 0) in vec3 vertPosition;
uniform mat4 viewProjection;
uniform mat4 modelViewTransform;
uniform mat4 projectionTransform;
out vec3 vPosition;
out vec4 worldPosition;
out vec4 positionLocalSpace;
out vec4 positionCameraSpace;
#include "PowerScaling/powerScaling_vs.hglsl"
void main() {
vPosition = vertPosition.xyz;
worldPosition = vertPosition;
vec4 position = pscTransform(worldPosition, mat4(1.0));
// project the position to view space
gl_Position = viewProjection * position;
gl_Position.z = 1.0;
positionLocalSpace = vec4(vertPosition, 1.0);
positionCameraSpace = modelViewTransform * positionLocalSpace;
vec4 positionClipSpace = projectionTransform * positionCameraSpace;
vec4 positionScreenSpace = z_normalization(positionClipSpace);
//positionScreenSpace.z = 1.0;
// project the position to view space
gl_Position = positionScreenSpace;
}

55
src/rendering/abufferrenderer.cpp
View File

@@ -268,9 +268,6 @@ void ABufferRenderer::render(float blackoutFactor, bool doPerformanceMeasurement
RenderData data{ *_camera, psc(), doPerformanceMeasurements, renderBinMask };
RendererTasks tasks;
_scene->render(data, tasks);
_rendererTasks = std::make_unique<RendererTasks>(tasks);
_renderData = std::make_unique<RenderData>(data);
_blackoutFactor = blackoutFactor;
glBindFramebuffer(GL_FRAMEBUFFER, defaultFbo);
@@ -314,10 +311,21 @@ void ABufferRenderer::render(float blackoutFactor, bool doPerformanceMeasurement
// END TEMPORARY GAMMA CORRECTION.
preRaycast(*_resolveProgram);
_resolveProgram->setUniform("mainColorTexture", _mainColorTextureUnit->unitNumber());
_resolveProgram->setUniform("mainDepthTexture", _mainDepthTextureUnit->unitNumber());
_resolveProgram->setUniform("blackoutFactor", _blackoutFactor);
_resolveProgram->setUniform("nAaSamples", _nAaSamples);
for (const RaycasterTask& raycasterTask : tasks.raycasterTasks) {
preRaycast(raycasterTask);
}
glBindVertexArray(_screenQuad);
glDrawArrays(GL_TRIANGLES, 0, 6);
postRaycast(*_resolveProgram);
for (const RaycasterTask& raycasterTask : tasks.raycasterTasks) {
postRaycast(raycasterTask);
}
_resolveProgram->deactivate();
@@ -326,32 +334,27 @@ void ABufferRenderer::render(float blackoutFactor, bool doPerformanceMeasurement
}
void ABufferRenderer::preRaycast(ghoul::opengl::ProgramObject& program) {
void ABufferRenderer::preRaycast(const RaycasterTask& raycasterTask) {
VolumeRaycaster& raycaster = *raycasterTask.raycaster;
const RaycastData& raycastData = _raycastData[&raycaster];
const RenderData& renderData = raycasterTask.renderData;
program.setUniform("mainColorTexture", _mainColorTextureUnit->unitNumber());
program.setUniform("mainDepthTexture", _mainDepthTextureUnit->unitNumber());
for (const auto& raycastData : _raycastData) {
raycastData.first->preRaycast(raycastData.second, program);
raycaster.preRaycast(raycastData, *_resolveProgram);
glm::vec3 localCameraPosition;
bool cameraIsInside = raycastData.first->cameraIsInside(*_renderData, localCameraPosition);
int uniformIndex = raycastData.second.id + 1; // uniforms are indexed from 1 (not from 0)
program.setUniform("insideRaycaster" + std::to_string(uniformIndex), cameraIsInside);
if (cameraIsInside) {
program.setUniform("cameraPosInRaycaster" + std::to_string(uniformIndex), localCameraPosition);
}
glm::vec3 localCameraPosition;
bool cameraIsInside = raycaster.cameraIsInside(renderData, localCameraPosition);
int uniformIndex = raycastData.id + 1; // uniforms are indexed from 1 (not from 0)
_resolveProgram->setUniform("insideRaycaster" + std::to_string(uniformIndex), cameraIsInside);
if (cameraIsInside) {
_resolveProgram->setUniform("cameraPosInRaycaster" + std::to_string(uniformIndex), localCameraPosition);
}
// 3b: Set "global" uniforms, and start the resolve pass.
program.setUniform("blackoutFactor", _blackoutFactor);
program.setUniform("nAaSamples", _nAaSamples);
}
void ABufferRenderer::postRaycast(ghoul::opengl::ProgramObject& program) {
for (const auto& raycastData : _raycastData) {
raycastData.first->postRaycast(raycastData.second, program);
}
void ABufferRenderer::postRaycast(const RaycasterTask& raycasterTask) {
VolumeRaycaster& raycaster = *raycasterTask.raycaster;
const RaycastData& raycastData = _raycastData[&raycaster];
raycaster.postRaycast(raycastData, *_resolveProgram);
}
void ABufferRenderer::setScene(Scene* scene) {