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

Merge branch 'master' into issue/733

Browse Source
This commit is contained in:
Emma Broman
2020-07-08 15:33:39 +02:00
committed by GitHub
parent 9b58782771 ad5907f602
commit a7ea25d311
155 changed files with 3456 additions and 2102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/atmosphere/rendering/atmospheredeferredcaster.cpp
+80 -58
View File
@@ -60,11 +60,14 @@
#include <modules/atmosphere/rendering/atmospheredeferredcaster.h>
#include <modules/atmosphere/rendering/renderableatmosphere.h>
#include <openspace/util/updatestructures.h>
#include <openspace/util/spicemanager.h>
#include <openspace/engine/globals.h>
#include <openspace/rendering/renderable.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/rendering/renderer.h>
#include <openspace/scene/scenegraphnode.h>
#include <openspace/scene/scene.h>
#include <openspace/util/updatestructures.h>
#include <openspace/util/spicemanager.h>
#include <ghoul/glm.h>
#include <ghoul/filesystem/filesystem.h>
#include <ghoul/logging/logmanager.h>
@@ -111,6 +114,37 @@ namespace {
constexpr const float ATM_EPS = 2.f;
constexpr const float KM_TO_M = 1000.f;
void createRenderQuad(GLuint* vao, GLuint* vbo, GLfloat size) {
glGenVertexArrays(1, vao);
glGenBuffers(1, vbo);
glBindVertexArray(*vao);
glBindBuffer(GL_ARRAY_BUFFER, *vbo);
const GLfloat vertex_data[] = {
// x y z w
-size, -size, 0.0f, 1.0f,
size, size, 0.0f, 1.0f,
-size, size, 0.0f, 1.0f,
-size, -size, 0.0f, 1.0f,
size, -size, 0.0f, 1.0f,
size, size, 0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
glVertexAttribPointer(
0,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
nullptr
);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
}
} // namespace
namespace openspace {
@@ -169,12 +203,8 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData,
renderData.camera.sgctInternal.projectionMatrix()
) * renderData.camera.combinedViewMatrix();
if (!isAtmosphereInFrustum(
MV,
tPlanetPosWorld,
(_atmosphereRadius + ATM_EPS)*KM_TO_M)
)
{
const float totalAtmosphere = (_atmosphereRadius + ATM_EPS)* KM_TO_M;
if (!isAtmosphereInFrustum(MV, tPlanetPosWorld, totalAtmosphere)) {
program.setUniform(_uniformCache.cullAtmosphere, 1);
}
else {
@@ -290,6 +320,32 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData,
);
casterPos *= KM_TO_M; // converting to meters
const std::string source = shadowConf.source.first;
SceneGraphNode* sourceNode =
global::renderEngine.scene()->sceneGraphNode(source);
const std::string caster = shadowConf.caster.first;
SceneGraphNode* casterNode =
global::renderEngine.scene()->sceneGraphNode(caster);
const double sourceRadiusScale = std::max(
glm::compMax(sourceNode->scale()),
1.0
);
const double casterRadiusScale = std::max(
glm::compMax(casterNode->scale()),
1.0
);
if ((sourceNode == nullptr) || (casterNode == nullptr)) {
LERRORC(
"AtmosphereDeferredcaster",
"Invalid scenegraph node for the shadow's caster or shadow's "
"receiver."
);
return;
}
// First we determine if the caster is shadowing the current planet
// (all calculations in World Coordinates):
glm::dvec3 planetCasterVec =
@@ -300,9 +356,11 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData,
glm::dot(planetCasterVec, sourceCasterVec) /
(sc_length*sc_length)) * sourceCasterVec;
double d_test = glm::length(planetCasterVec - planetCaster_proj);
double xp_test = shadowConf.caster.second *
sc_length / (shadowConf.source.second + shadowConf.caster.second);
double rp_test = shadowConf.caster.second *
double xp_test = shadowConf.caster.second * casterRadiusScale *
sc_length /
(shadowConf.source.second * sourceRadiusScale +
shadowConf.caster.second * casterRadiusScale);
double rp_test = shadowConf.caster.second * casterRadiusScale *
(glm::length(planetCaster_proj) + xp_test) / xp_test;
double casterDistSun = glm::length(casterPos - sunPosWorld);
@@ -314,12 +372,12 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData,
shadowData.isShadowing = false;
if (((d_test - rp_test) < (_atmospherePlanetRadius * KM_TO_M)) &&
//if (((d_test - rp_test) < (_atmosphereRadius * KM_TO_M)) &&
(casterDistSun < planetDistSun)) {
(casterDistSun < planetDistSun))
{
// The current caster is shadowing the current planet
shadowData.isShadowing = true;
shadowData.rs = shadowConf.source.second;
shadowData.rc = shadowConf.caster.second;
shadowData.rs = shadowConf.source.second * sourceRadiusScale;
shadowData.rc = shadowConf.caster.second * casterRadiusScale;
shadowData.sourceCasterVec = glm::normalize(sourceCasterVec);
shadowData.xp = xp_test;
shadowData.xu = shadowData.rc * sc_length /
@@ -331,7 +389,7 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData,
const std::string uniformVarName("shadowDataArray[");
unsigned int counter = 0;
for (const ShadowRenderingStruct & sd : shadowDataArray) {
for (const ShadowRenderingStruct& sd : shadowDataArray) {
std::stringstream ss;
ss << uniformVarName << counter << "].isShadowing";
program.setUniform(ss.str(), sd.isShadowing);
@@ -464,30 +522,24 @@ void AtmosphereDeferredcaster::setSunRadianceIntensity(float sunRadiance) {
_sunRadianceIntensity = sunRadiance;
}
void AtmosphereDeferredcaster::setRayleighScatteringCoefficients(
const glm::vec3& rayScattCoeff)
void AtmosphereDeferredcaster::setRayleighScatteringCoefficients(glm::vec3 rayScattCoeff)
{
_rayleighScatteringCoeff = std::move(rayScattCoeff);
}
void AtmosphereDeferredcaster::setOzoneExtinctionCoefficients(
const glm::vec3& ozoneExtCoeff)
{
void AtmosphereDeferredcaster::setOzoneExtinctionCoefficients(glm::vec3 ozoneExtCoeff) {
_ozoneExtinctionCoeff = std::move(ozoneExtCoeff);
}
void AtmosphereDeferredcaster::setMieScatteringCoefficients(
const glm::vec3& mieScattCoeff)
{
void AtmosphereDeferredcaster::setMieScatteringCoefficients(glm::vec3 mieScattCoeff) {
_mieScatteringCoeff = std::move(mieScattCoeff);
}
void AtmosphereDeferredcaster::setMieExtinctionCoefficients(const glm::vec3& mieExtCoeff)
{
void AtmosphereDeferredcaster::setMieExtinctionCoefficients(glm::vec3 mieExtCoeff) {
_mieExtinctionCoeff = std::move(mieExtCoeff);
}
void AtmosphereDeferredcaster::setEllipsoidRadii(const glm::dvec3& radii) {
void AtmosphereDeferredcaster::setEllipsoidRadii(glm::dvec3 radii) {
_ellipsoidRadii = std::move(radii);
}
@@ -496,7 +548,7 @@ void AtmosphereDeferredcaster::setHardShadows(bool enabled) {
}
void AtmosphereDeferredcaster::setShadowConfigArray(
const std::vector<ShadowConfiguration>& shadowConfigArray)
std::vector<ShadowConfiguration> shadowConfigArray)
{
_shadowConfArray = std::move(shadowConfigArray);
}
@@ -1210,36 +1262,6 @@ void AtmosphereDeferredcaster::preCalculateAtmosphereParam() {
LDEBUG("Ended precalculations for Atmosphere effects...");
}
void AtmosphereDeferredcaster::createRenderQuad(GLuint* vao, GLuint* vbo, GLfloat size) {
glGenVertexArrays(1, vao);
glGenBuffers(1, vbo);
glBindVertexArray(*vao);
glBindBuffer(GL_ARRAY_BUFFER, *vbo);
const GLfloat vertex_data[] = {
// x y z w
-size, -size, 0.0f, 1.0f,
size, size, 0.0f, 1.0f,
-size, size, 0.0f, 1.0f,
-size, -size, 0.0f, 1.0f,
size, -size, 0.0f, 1.0f,
size, size, 0.0f, 1.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
glVertexAttribPointer(
0,
4,
GL_FLOAT,
GL_FALSE,
sizeof(GLfloat) * 4,
nullptr
);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
}
void AtmosphereDeferredcaster::loadAtmosphereDataIntoShaderProgram(
std::unique_ptr<ghoul::opengl::ProgramObject>& shaderProg)
{
modules/atmosphere/rendering/atmospheredeferredcaster.h
+6 -7
View File
@@ -79,12 +79,12 @@ public:
void setMieHeightScale(float mieHeightScale);
void setMiePhaseConstant(float miePhaseConstant);
void setSunRadianceIntensity(float sunRadiance);
void setRayleighScatteringCoefficients(const glm::vec3& rayScattCoeff);
void setOzoneExtinctionCoefficients(const glm::vec3& ozoneExtCoeff);
void setMieScatteringCoefficients(const glm::vec3& mieScattCoeff);
void setMieExtinctionCoefficients(const glm::vec3& mieExtCoeff);
void setEllipsoidRadii(const glm::dvec3& radii);
void setShadowConfigArray(const std::vector<ShadowConfiguration>& shadowConfigArray);
void setRayleighScatteringCoefficients(glm::vec3 rayScattCoeff);
void setOzoneExtinctionCoefficients(glm::vec3 ozoneExtCoeff);
void setMieScatteringCoefficients(glm::vec3 mieScattCoeff);
void setMieExtinctionCoefficients(glm::vec3 mieExtCoeff);
void setEllipsoidRadii(glm::dvec3 radii);
void setShadowConfigArray(std::vector<ShadowConfiguration> shadowConfigArray);
void setHardShadows(bool enabled);
void enableSunFollowing(bool enable);
@@ -99,7 +99,6 @@ private:
void deleteUnusedComputationTextures();
void executeCalculations(GLuint quadCalcVAO, GLenum drawBuffers[1],
GLsizei vertexSize);
void createRenderQuad(GLuint* vao, GLuint* vbo, GLfloat size);
void step3DTexture(std::unique_ptr<ghoul::opengl::ProgramObject>& shaderProg,
int layer, bool doCalculation = true);
void checkFrameBufferState(const std::string& codePosition) const;
modules/atmosphere/shaders/atmosphere_deferred_fs.glsl
+4 -3
View File
@@ -130,7 +130,7 @@ vec4 calcShadow(const ShadowRenderingStruct shadowInfoArray[numberOfShadows], co
return vec4(0.2, 0.2, 0.2, 1.0);
}
else {
return butterworthFunc(length_d, r_u_pi, 4.0);
return butterworthFunc(length_d, r_u_pi, 2.0);
}
}
else {
@@ -138,7 +138,8 @@ vec4 calcShadow(const ShadowRenderingStruct shadowInfoArray[numberOfShadows], co
return vec4(0.5, 0.5, 0.5, 1.0);
}
else {
return vec4(vec3(length_d/r_p_pi), 1.0);
//return vec4(vec3(length_d/r_p_pi), 1.0);
return butterworthFunc(length_d, r_u_pi, 2.0);
}
}
}
@@ -621,7 +622,7 @@ void main() {
// All calculations are done in Km:
pixelDepth *= 0.001;
positionObjectsCoords.xyz *= 0.001;
if (pixelDepth < offset) {
// ATM Occluded - Something in fron of ATM.
atmosphereFinalColor += color;
modules/base/rendering/renderablelabels.cpp
+2 -2
View File
@@ -350,7 +350,7 @@ RenderableLabels::RenderableLabels(const ghoul::Dictionary& dictionary)
setRenderBinFromOpacity();
break;
case BlendModeAdditive:
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
default:
throw ghoul::MissingCaseException();
@@ -608,7 +608,7 @@ void RenderableLabels::initialize() {
throw ghoul::RuntimeError("Error loading objects labels data.");
}
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
}
void RenderableLabels::initializeGL() {
modules/base/rendering/renderablemodel.cpp
+14 -3
View File
@@ -47,10 +47,11 @@ namespace {
constexpr const char* ProgramName = "ModelProgram";
constexpr const char* KeyGeometry = "Geometry";
constexpr const std::array<const char*, 11> UniformNames = {
constexpr const std::array<const char*, 12> UniformNames = {
"opacity", "nLightSources", "lightDirectionsViewSpace", "lightIntensities",
"modelViewTransform", "projectionTransform", "performShading", "texture1",
"ambientIntensity", "diffuseIntensity", "specularIntensity"
"modelViewTransform", "crippedModelViewTransform", "projectionTransform",
"performShading", "texture1", "ambientIntensity", "diffuseIntensity",
"specularIntensity"
};
constexpr openspace::properties::Property::PropertyInfo TextureInfo = {
@@ -380,6 +381,16 @@ void RenderableModel::render(const RenderData& data, RendererTasks&) {
_uniformCache.modelViewTransform,
glm::mat4(modelViewTransform)
);
glm::dmat4 crippedModelViewTransform = glm::transpose(glm::inverse(
glm::dmat4(glm::inverse(data.camera.sgctInternal.viewMatrix())) * modelViewTransform
));
_program->setUniform(
_uniformCache.crippedModelViewTransform,
glm::mat4(crippedModelViewTransform)
);
_program->setUniform(
_uniformCache.projectionTransform,
data.camera.projectionMatrix()
modules/base/rendering/renderablemodel.h
+3 -2
View File
@@ -88,8 +88,9 @@ private:
ghoul::opengl::ProgramObject* _program = nullptr;
UniformCache(opacity, nLightSources, lightDirectionsViewSpace, lightIntensities,
modelViewTransform, projectionTransform, performShading, texture,
ambientIntensity, diffuseIntensity, specularIntensity) _uniformCache;
modelViewTransform, crippedModelViewTransform, projectionTransform,
performShading, texture, ambientIntensity, diffuseIntensity,
specularIntensity) _uniformCache;
std::unique_ptr<ghoul::opengl::Texture> _texture;
std::vector<std::unique_ptr<LightSource>> _lightSources;
modules/base/rendering/renderableplane.cpp
+1 -1
View File
@@ -130,7 +130,7 @@ RenderablePlane::RenderablePlane(const ghoul::Dictionary& dictionary)
setRenderBinFromOpacity();
break;
case BlendModeAdditive:
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
default:
throw ghoul::MissingCaseException();
modules/base/rendering/renderableplaneimagelocal.cpp
+5 -2
View File
@@ -117,8 +117,11 @@ RenderablePlaneImageLocal::RenderablePlaneImageLocal(const ghoul::Dictionary& di
else if (renderType == "Opaque") {
setRenderBin(Renderable::RenderBin::Opaque);
}
else if (renderType == "Transparent") {
setRenderBin(Renderable::RenderBin::Transparent);
else if (renderType == "PreDeferredTransparent") {
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
}
else if (renderType == "PostDeferredTransparent") {
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
}
else if (renderType == "Overlay") {
setRenderBin(Renderable::RenderBin::Overlay);
modules/base/rendering/renderablesphere.cpp
+1 -1
View File
@@ -264,7 +264,7 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
_useAdditiveBlending = dictionary.value<bool>(UseAdditiveBlendingInfo.identifier);
if (_useAdditiveBlending) {
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
}
}
modules/base/rendering/renderabletrail.cpp
+22
View File
@@ -68,6 +68,14 @@ namespace {
{ "Points+Lines", RenderingModeLinesPoints }
};
// Fragile! Keep in sync with documentation
const std::map<std::string, openspace::Renderable::RenderBin> RenderBinModeConversion = {
{ "Background", openspace::Renderable::RenderBin::Background },
{ "Opaque", openspace::Renderable::RenderBin::Opaque },
{ "PreDeferredTransparent", openspace::Renderable::RenderBin::PreDeferredTransparent},
{ "PostDeferredTransparent", openspace::Renderable::RenderBin::PostDeferredTransparent}
};
static const openspace::properties::PropertyOwner::PropertyOwnerInfo
AppearanceInfo = {
"Appearance",
@@ -122,6 +130,13 @@ namespace {
"corresponding points (and subpoints) are shown. 'Lines+Points' shows both parts."
};
constexpr openspace::properties::Property::PropertyInfo RenderBinModeInfo = {
"RenderBinMode",
"RenderBin Mode",
"Determines if the trails will be rendered after all other elements, including"
"atmospheres if needed."
};
} // namespace
namespace openspace {
@@ -255,6 +270,13 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
}
addPropertySubOwner(_appearance);
if (dictionary.hasKeyAndValue<std::string>(RenderBinModeInfo.identifier)) {
openspace::Renderable::RenderBin cfgRenderBin = RenderBinModeConversion.at(
dictionary.value<std::string>(RenderBinModeInfo.identifier)
);
setRenderBin(cfgRenderBin);
}
}
void RenderableTrail::initializeGL() {
modules/base/rendering/renderabletrailorbit.cpp
+5 -2
View File
@@ -184,8 +184,11 @@ RenderableTrailOrbit::RenderableTrailOrbit(const ghoul::Dictionary& dictionary)
else if (renderType == "Opaque") {
setRenderBin(Renderable::RenderBin::Opaque);
}
else if (renderType == "Transparent") {
setRenderBin(Renderable::RenderBin::Transparent);
else if (renderType == "PreDeferredTransparent") {
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
}
else if (renderType == "PostDeferredTransparent") {
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
}
else if (renderType == "Overlay") {
setRenderBin(Renderable::RenderBin::Overlay);
modules/base/shaders/model_vs.glsl
+3 -3
View File
@@ -37,7 +37,7 @@ out vec4 vs_positionCameraSpace;
uniform mat4 modelViewTransform;
uniform mat4 projectionTransform;
uniform mat4 crippedModelViewTransform;
void main() {
vs_positionCameraSpace = modelViewTransform * in_position;
@@ -48,6 +48,6 @@ void main() {
vs_st = in_st;
vs_screenSpaceDepth = positionScreenSpace.w;
// The normal transform should be the transposed inverse of the model transform?
vs_normalViewSpace = normalize(mat3(modelViewTransform) * in_normal);
//vs_normalViewSpace = normalize(transpose(inverse(mat3(crippedModelViewTransform))) * in_normal);
vs_normalViewSpace = normalize(mat3(crippedModelViewTransform) * in_normal);
}
modules/base/shaders/renderabletrail_fs.glsl
+4 -1
View File
@@ -67,13 +67,16 @@ Fragment getFragment() {
if (distanceCenter > dLW) {
frag.color.a = 0.0;
//discard;
}
else {
frag.color.a *= pow(float((dLW - distanceCenter) / dLW), blendFactor);
// if (frag.color.a < 0.4)
// discard;
}
frag.gPosition = vs_gPosition;
// There is no normal here
frag.gNormal = vec4(0.0, 0.0, -1.0, 1.0);
modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+1 -1
View File
@@ -699,7 +699,7 @@ void RenderableBillboardsCloud::initialize() {
_colorOption.setValue(static_cast<int>(_colorRangeData.size() - 1));
}
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
}
void RenderableBillboardsCloud::initializeGL() {
modules/digitaluniverse/rendering/renderableplanescloud.cpp
+1 -1
View File
@@ -435,7 +435,7 @@ RenderablePlanesCloud::RenderablePlanesCloud(const ghoul::Dictionary& dictionary
setRenderBin(Renderable::RenderBin::Opaque);
break;
case BlendModeAdditive:
setRenderBin(Renderable::RenderBin::Transparent);
setRenderBin(Renderable::RenderBin::PreDeferredTransparent);
break;
default:
throw ghoul::MissingCaseException();
modules/fitsfilereader/ext/cfitsio
+1 -1
Submodule modules/fitsfilereader/ext/cfitsio updated: cc814c7ebe...3b6730fd43
modules/globebrowsing/shaders/renderer_fs.glsl
+1 -1
View File
@@ -114,7 +114,7 @@ vec4 calcShadow(const ShadowRenderingStruct shadowInfoArray[numberOfShadows],
return vec4(0.2, 0.2, 0.2, 1.0);
#else
// butterworthFunc
return vec4(vec3(sqrt(r_u_pi / (r_u_pi + pow(length_d, 8.0)))), 1.0);
return vec4(vec3(sqrt(r_u_pi / (r_u_pi + pow(length_d, 2.0)))), 1.0);
#endif
}
else {
modules/globebrowsing/src/renderableglobe.cpp
+46 -24
View File
@@ -24,19 +24,21 @@
#include <modules/globebrowsing/src/renderableglobe.h>
#include <modules/debugging/rendering/debugrenderer.h>
#include <modules/globebrowsing/src/basictypes.h>
#include <modules/globebrowsing/src/gpulayergroup.h>
#include <modules/globebrowsing/src/layer.h>
#include <modules/globebrowsing/src/layergroup.h>
#include <modules/globebrowsing/src/renderableglobe.h>
#include <modules/globebrowsing/src/tileprovider.h>
#include <modules/debugging/rendering/debugrenderer.h>
#include <openspace/documentation/documentation.h>
#include <openspace/documentation/verifier.h>
#include <openspace/engine/globals.h>
#include <openspace/performance/performancemanager.h>
#include <openspace/performance/performancemeasurement.h>
#include <openspace/rendering/renderengine.h>
#include <openspace/scene/scenegraphnode.h>
#include <openspace/scene/scene.h>
#include <openspace/util/spicemanager.h>
#include <openspace/util/time.h>
#include <openspace/util/updatestructures.h>
@@ -518,8 +520,8 @@ RenderableGlobe::RenderableGlobe(const ghoul::Dictionary& dictionary)
FloatProperty(OrenNayarRoughnessInfo, 0.f, 0.f, 1.f),
IntProperty(NActiveLayersInfo, 0, 0, OpenGLCap.maxTextureUnits() / 3)
})
, _shadowMappingPropertyOwner({ "ShadowMapping" })
, _debugPropertyOwner({ "Debug" })
, _shadowMappingPropertyOwner({ "ShadowMapping" })
, _grid(DefaultSkirtedGridSegments, DefaultSkirtedGridSegments)
, _leftRoot(Chunk(LeftHemisphereIndex))
, _rightRoot(Chunk(RightHemisphereIndex))
@@ -774,7 +776,6 @@ void RenderableGlobe::render(const RenderData& data, RendererTasks& rendererTask
if (distanceToCamera < distance) {
try {
// Before Shadows
//renderChunks(data, rendererTask);
_globeLabelsComponent.draw(data);
if (_hasShadows && _shadowComponent.isEnabled()) {
@@ -2058,25 +2059,45 @@ void RenderableGlobe::calculateEclipseShadows(ghoul::opengl::ProgramObject& prog
lt
);
casterPos *= KM_TO_M; // converting to meters
// psc caster_pos = PowerScaledCoordinate::CreatePowerScaledCoordinate(
// casterPos.x,
// casterPos.y,
// casterPos.z
// );
const std::string source = shadowConf.source.first;
SceneGraphNode* sourceNode = global::renderEngine.scene()->sceneGraphNode(source);
const std::string caster = shadowConf.caster.first;
SceneGraphNode* casterNode = global::renderEngine.scene()->sceneGraphNode(caster);
const double sourceRadiusScale = std::max(
glm::compMax(sourceNode->scale()),
1.0
);
const double casterRadiusScale = std::max(
glm::compMax(casterNode->scale()),
1.0
);
if ((sourceNode == nullptr) || (casterNode == nullptr)) {
LERRORC(
"Renderableglobe",
"Invalid scenegraph node for the shadow's caster or shadow's receiver."
);
return;
}
// First we determine if the caster is shadowing the current planet (all
// calculations in World Coordinates):
const glm::dvec3 planetCasterVec = casterPos - data.modelTransform.translation;
const glm::dvec3 sourceCasterVec = casterPos - sourcePos;
const double sc_length = glm::length(sourceCasterVec);
const glm::dvec3 planetCaster_proj =
(glm::dot(planetCasterVec, sourceCasterVec) / (sc_length*sc_length)) *
sourceCasterVec;
const double d_test = glm::length(planetCasterVec - planetCaster_proj);
const double xp_test = shadowConf.caster.second * sc_length /
(shadowConf.source.second + shadowConf.caster.second);
const double rp_test = shadowConf.caster.second *
const double d_test = glm::length(planetCasterVec - planetCaster_proj);
const double xp_test = shadowConf.caster.second * casterRadiusScale *
sc_length / (shadowConf.source.second * sourceRadiusScale +
shadowConf.caster.second * casterRadiusScale);
const double rp_test = shadowConf.caster.second * casterRadiusScale *
(glm::length(planetCaster_proj) + xp_test) / xp_test;
const glm::dvec3 sunPos = SpiceManager::ref().targetPosition(
@@ -2099,13 +2120,13 @@ void RenderableGlobe::calculateEclipseShadows(ghoul::opengl::ProgramObject& prog
(casterDistSun < planetDistSun))
{
// The current caster is shadowing the current planet
shadowData.isShadowing = true;
shadowData.rs = shadowConf.source.second;
shadowData.rc = shadowConf.caster.second;
shadowData.sourceCasterVec = glm::normalize(sourceCasterVec);
shadowData.xp = xp_test;
shadowData.xu = shadowData.rc * sc_length /
(shadowData.rs - shadowData.rc);
shadowData.isShadowing = true;
shadowData.rs = shadowConf.source.second * sourceRadiusScale;
shadowData.rc = shadowConf.caster.second * casterRadiusScale;
shadowData.sourceCasterVec = glm::normalize(sourceCasterVec);
shadowData.xp = xp_test;
shadowData.xu = shadowData.rc * sc_length /
(shadowData.rs - shadowData.rc);
shadowData.casterPositionVec = casterPos;
}
shadowDataArray.push_back(shadowData);
@@ -2115,15 +2136,16 @@ void RenderableGlobe::calculateEclipseShadows(ghoul::opengl::ProgramObject& prog
unsigned int counter = 0;
for (const ShadowRenderingStruct& sd : shadowDataArray) {
constexpr const char* NameIsShadowing = "shadowDataArray[{}].isShadowing";
constexpr const char* NameXp = "shadowDataArray[{}].xp";
constexpr const char* NameXu = "shadowDataArray[{}].xu";
constexpr const char* NameRc = "shadowDataArray[{}].rc";
constexpr const char* NameSource = "shadowDataArray[{}].sourceCasterVec";
constexpr const char* NamePos = "shadowDataArray[{}].casterPositionVec";
constexpr const char* NameXp = "shadowDataArray[{}].xp";
constexpr const char* NameXu = "shadowDataArray[{}].xu";
constexpr const char* NameRc = "shadowDataArray[{}].rc";
constexpr const char* NameSource = "shadowDataArray[{}].sourceCasterVec";
constexpr const char* NamePos = "shadowDataArray[{}].casterPositionVec";
programObject.setUniform(
fmt::format(NameIsShadowing, counter), sd.isShadowing
);
if (sd.isShadowing) {
programObject.setUniform(fmt::format(NameXp, counter), sd.xp);
programObject.setUniform(fmt::format(NameXu, counter), sd.xu);
modules/imgui/src/gui.cpp
+3 -6
View File
@@ -190,16 +190,13 @@ GUI::GUI()
GUI::~GUI() {} // NOLINT
void GUI::initialize() {
}
void GUI::initialize() {}
void GUI::deinitialize() {
ImGui::Shutdown();
int nWindows = global::windowDelegate.nWindows();
for (int i = 0; i < nWindows; ++i) {
ImGui::DestroyContext(_contexts[i]);
for (ImGuiContext* ctx : _contexts) {
ImGui::DestroyContext(ctx);
}
for (GuiComponent* comp : _components) {
modules/space/rendering/renderableorbitalkepler.cpp
+24 -2
View File
@@ -50,6 +50,14 @@ namespace {
constexpr const char* KeyFile = "Path";
constexpr const char* KeyLineNum = "LineNumber";
// Fragile! Keep in sync with documentation
const std::map<std::string, openspace::Renderable::RenderBin> RenderBinModeConversion = {
{ "Background", openspace::Renderable::RenderBin::Background },
{ "Opaque", openspace::Renderable::RenderBin::Opaque },
{ "PreDeferredTransparent", openspace::Renderable::RenderBin::PreDeferredTransparent},
{ "PostDeferredTransparent", openspace::Renderable::RenderBin::PostDeferredTransparent}
};
constexpr const std::array<int, 36> LeapYears = {
1956, 1960, 1964, 1968, 1972, 1976, 1980, 1984, 1988, 1992, 1996,
2000, 2004, 2008, 2012, 2016, 2020, 2024, 2028, 2032, 2036, 2040,
@@ -152,6 +160,13 @@ namespace {
"Number of objects to render sequentially from StartRenderIdx"
};
constexpr openspace::properties::Property::PropertyInfo RenderBinModeInfo = {
"RenderBinMode",
"RenderBin Mode",
"Determines if the trails will be rendered after all other elements, including"
"atmospheres if needed."
};
// Count the number of full days since the beginning of 2000 to the beginning of
// the parameter 'year'
int countDays(int year) {
@@ -345,8 +360,8 @@ double RenderableOrbitalKepler::epochFromYMDdSubstring(const std::string& epochS
RenderableOrbitalKepler::RenderableOrbitalKepler(const ghoul::Dictionary& dict)
: Renderable(dict)
, _path(PathInfo)
, _segmentQuality(SegmentQualityInfo, 2, 1, 10)
, _path(PathInfo)
, _upperLimit(UpperLimitInfo, 1000, 1, 1000000)
, _startRenderIdx(StartRenderIdxInfo, 0, 0, 1)
, _sizeRender(RenderSizeInfo, 1, 1, 2)
@@ -400,7 +415,14 @@ RenderableOrbitalKepler::RenderableOrbitalKepler(const ghoul::Dictionary& dict)
_startRenderIdxCallbackHandle = _startRenderIdx.onChange(_updateStartRenderIdxSelect);
_sizeRenderCallbackHandle = _sizeRender.onChange(_updateRenderSizeSelect);
setRenderBin(Renderable::RenderBin::Overlay);
if (dict.hasKeyAndValue<std::string>(RenderBinModeInfo.identifier)) {
openspace::Renderable::RenderBin cfgRenderBin = RenderBinModeConversion.at(
dict.value<std::string>(RenderBinModeInfo.identifier)
);
setRenderBin(cfgRenderBin);
} else {
setRenderBin(Renderable::RenderBin::PostDeferredTransparent);
}
}
void RenderableOrbitalKepler::initializeGL() {