mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-08 20:50:19 -06:00
774 lines
36 KiB
C++
774 lines
36 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2017 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
|
|
#include <modules/atmosphere/rendering/renderableatmosphere.h>
|
|
|
|
#include <openspace/documentation/documentation.h>
|
|
#include <openspace/documentation/verifier.h>
|
|
|
|
#include <modules/space/rendering/planetgeometry.h>
|
|
#include <openspace/util/time.h>
|
|
#include <openspace/util/spicemanager.h>
|
|
#include <openspace/scene/scenegraphnode.h>
|
|
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/misc/assert.h>
|
|
#include <ghoul/io/texture/texturereader.h>
|
|
#include <ghoul/opengl/programobject.h>
|
|
#include <ghoul/opengl/texture.h>
|
|
#include <ghoul/opengl/textureunit.h>
|
|
#include <ghoul/misc/invariants.h>
|
|
|
|
#include <openspace/rendering/deferredcastermanager.h>
|
|
#include <modules/atmosphere/rendering/atmospheredeferredcaster.h>
|
|
#include <openspace/engine/configurationmanager.h>
|
|
#include <openspace/engine/openspaceengine.h>
|
|
#include <openspace/rendering/renderengine.h>
|
|
#include <openspace/rendering/renderer.h>
|
|
|
|
#include <glm/gtx/string_cast.hpp>
|
|
|
|
#include <memory>
|
|
#include <fstream>
|
|
|
|
#define _USE_MATH_DEFINES
|
|
#include <math.h>
|
|
|
|
|
|
namespace {
|
|
const char* KeyGeometry = "Geometry";
|
|
const char* KeyRadius = "Radius";
|
|
|
|
static const char* _loggerCat = "RenderableAtmosphere";
|
|
|
|
const char* keyFrame = "Frame";
|
|
const char* keyShadowGroup = "Shadow_Group";
|
|
const char* keyShadowSource = "Source";
|
|
const char* keyShadowCaster = "Caster";
|
|
const char* keyBody = "Body";
|
|
|
|
const char* keyAtmosphere = "Atmosphere";
|
|
const char* keyAtmosphereType = "Type";
|
|
const char* keyAtmosphereRadius = "AtmosphereRadius";
|
|
const char* keyPlanetRadius = "PlanetRadius";
|
|
const char* keyAverageGroundReflectance = "PlanetAverageGroundReflectance";
|
|
const char* keyRayleigh = "Rayleigh";
|
|
const char* keyRayleighHeightScale = "H_R";
|
|
const char* keyOzone = "Ozone";
|
|
const char* keyOzoneHeightScale = "H_O";
|
|
const char* keyMie = "Mie";
|
|
const char* keyMieHeightScale = "H_M";
|
|
const char* keyMiePhaseConstant = "G";
|
|
const char* keyImage = "Image";
|
|
const char* keyToneMappingOp = "ToneMapping";
|
|
const char* keyExposure = "Exposure";
|
|
const char* keyBackground = "Background";
|
|
const char* keyGamma = "Gamma";
|
|
const char* keyATMDebug = "Debug";
|
|
const char* keyTextureScale = "PreCalculatedTextureScale";
|
|
const char* keySaveTextures = "SaveCalculatedTextures";
|
|
|
|
static const openspace::properties::Property::PropertyInfo AtmosphereHeightInfo = {
|
|
"atmmosphereHeight",
|
|
"Atmosphere Height (KM)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo AverageGroundReflectanceInfo = {
|
|
"AverageGroundReflectance",
|
|
"Average Ground Reflectance (%)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo RayleighHeightScaleInfo = {
|
|
"RayleighHeightScale",
|
|
"Rayleigh Height Scale (KM)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo RayleighScatteringCoeffXInfo = {
|
|
"RayleighScatteringCoeffX",
|
|
"Rayleigh Scattering Coeff X (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo RayleighScatteringCoeffYInfo = {
|
|
"RayleighScatteringCoeffY",
|
|
"Rayleigh Scattering Coeff Y (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo RayleighScatteringCoeffZInfo = {
|
|
"RayleighScatteringCoeffZ",
|
|
"Rayleigh Scattering Coeff Z (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo OzoneLayerInfo = {
|
|
"Ozone",
|
|
"Ozone Layer Enabled",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo OzoneHeightScaleInfo = {
|
|
"OzoneLayerHeightScale",
|
|
"Ozone Height Scale (KM)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo OzoneLayerCoeffXInfo = {
|
|
"OzoneLayerCoeffX",
|
|
"Ozone Layer Extinction Coeff X (x10e-5)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo OzoneLayerCoeffYInfo = {
|
|
"OzoneLayerCoeffY",
|
|
"Ozone Layer Extinction Coeff Y (x10e-5)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo OzoneLayerCoeffZInfo = {
|
|
"OzoneLayerCoeffZ",
|
|
"Ozone Layer Extinction Coeff Z (x10e-5)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieHeightScaleInfo = {
|
|
"MieHeightScale",
|
|
"Mie Height Scale (KM)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieScatteringCoeffXInfo = {
|
|
"MieScatteringCoeffX",
|
|
"Mie Scattering Coeff X (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieScatteringCoeffYInfo = {
|
|
"MieScatteringCoeffY",
|
|
"Mie Scattering Coeff Y (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieScatteringCoeffZInfo = {
|
|
"MieScatteringCoeffZ",
|
|
"Mie Scattering Coeff Z (x10e-3)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieScatteringExtinctionPropCoeffInfo = {
|
|
"MieScatteringExtinctionPropCoefficient",
|
|
"Mie Scattering/Extinction Proportion Coefficient (%)",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo MieAsymmetricFactorGInfo = {
|
|
"MieAsymmetricFactorG",
|
|
"Mie Asymmetric Factor G",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo SunIntensityInfo = {
|
|
"SunIntensity",
|
|
"Sun Intensity",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo AtmosphereExposureInfo = {
|
|
"HdrExposure",
|
|
"Atmosphere Exposure",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo AtmosphereGammaInfo = {
|
|
"Gamma",
|
|
"Gamma Correction",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
|
|
static const openspace::properties::Property::PropertyInfo EnableSunOnCameraPositionInfo = {
|
|
"SunFollowingCamera",
|
|
"Enable Sun On Camera Position",
|
|
"" // @TODO Missing documentation
|
|
};
|
|
} // namespace
|
|
|
|
namespace openspace {
|
|
|
|
documentation::Documentation RenderableAtmosphere::Documentation() {
|
|
using namespace documentation;
|
|
return {
|
|
"RenderableAtmosphere",
|
|
"atmosphere_renderable_atmosphere",
|
|
{ /*
|
|
{
|
|
keyAtmosphereRadius,
|
|
new ReferencingVerifier("atmosphere"),
|
|
"Specifies the atmosphere's height in this RenderableAtmosphere.",
|
|
Optional::No
|
|
},
|
|
|
|
{
|
|
KeyShading,
|
|
new BoolVerifier,
|
|
"Specifies whether the atmosphere should be rendered shaded by the Sun. If "
|
|
"this value is 'false', any existing night texture will not be used. "
|
|
"This value defaults to 'true'.",
|
|
Optional::Yes
|
|
}
|
|
*/
|
|
}
|
|
};
|
|
}
|
|
|
|
RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
|
|
: Renderable(dictionary)
|
|
, _atmosphereHeightP(AtmosphereHeightInfo, 60.0f, 0.1f, 99.0f)
|
|
, _groundAverageReflectanceP(AverageGroundReflectanceInfo, 0.1f, 0.0f, 1.0f)
|
|
, _rayleighHeightScaleP(RayleighHeightScaleInfo, 8.0f, 0.1f, 20.0f)
|
|
, _rayleighScatteringCoeffXP(RayleighScatteringCoeffXInfo, 1.0f, 0.01f, 100.0f)
|
|
, _rayleighScatteringCoeffYP(RayleighScatteringCoeffYInfo, 1.0f, 0.01f, 100.0f)
|
|
, _rayleighScatteringCoeffZP(RayleighScatteringCoeffZInfo, 1.0f, 0.01f, 100.0f)
|
|
, _ozoneEnabledP(OzoneLayerInfo, true)
|
|
, _ozoneHeightScaleP(OzoneHeightScaleInfo, 8.0f, 0.1f, 20.0f)
|
|
, _ozoneCoeffXP(OzoneLayerCoeffXInfo, 3.426f, 0.01f, 100.0f)
|
|
, _ozoneCoeffYP(OzoneLayerCoeffYInfo, 8.298f, 0.01f, 100.0f)
|
|
, _ozoneCoeffZP(OzoneLayerCoeffZInfo, 0.356f, 0.01f, 100.0f)
|
|
, _mieHeightScaleP(MieHeightScaleInfo, 1.2f, 0.1f, 20.0f)
|
|
, _mieScatteringCoeffXP(MieScatteringCoeffXInfo, 4.0f, 0.01f, 1000.0f)
|
|
, _mieScatteringCoeffYP(MieScatteringCoeffYInfo, 4.0f, 0.01f, 1000.0f)
|
|
, _mieScatteringCoeffZP(MieScatteringCoeffZInfo, 4.0f, 0.01f, 1000.0f)
|
|
, _mieScatteringExtinctionPropCoefficientP(MieScatteringExtinctionPropCoeffInfo, 0.9f, 0.01f, 1.0f)
|
|
, _mieAsymmetricFactorGP(MieAsymmetricFactorGInfo, 0.85f, -1.0f, 1.0f)
|
|
, _sunIntensityP(SunIntensityInfo, 50.0f, 0.1f, 1000.0f)
|
|
, _hdrExpositionP(AtmosphereExposureInfo, 0.4f, 0.01f, 5.0f)
|
|
, _gammaConstantP(AtmosphereGammaInfo, 1.8f, 0.1f, 3.0f)
|
|
, _sunFollowingCameraEnabledP(EnableSunOnCameraPositionInfo, false)
|
|
, _atmosphereEnabled(false)
|
|
, _ozoneLayerEnabled(false)
|
|
, _sunFollowingCameraEnabled(false)
|
|
, _atmosphereRadius(0.f)
|
|
, _atmospherePlanetRadius(0.f)
|
|
, _planetAverageGroundReflectance(0.f)
|
|
, _rayleighHeightScale(0.f)
|
|
, _ozoneHeightScale(0.f)
|
|
, _mieHeightScale(0.f)
|
|
, _miePhaseConstant(0.f)
|
|
, _sunRadianceIntensity(50.f)
|
|
, _hdrConstant(0.f)
|
|
, _exposureBackgroundConstant(2.8f)
|
|
, _gammaConstant(1.8f)
|
|
, _mieExtinctionCoeff(glm::vec3(0.f))
|
|
, _rayleighScatteringCoeff(glm::vec3(0.f))
|
|
, _ozoneExtinctionCoeff(glm::vec3(0.f))
|
|
, _mieScatteringCoeff(glm::vec3(0.f))
|
|
, _saveCalculationsToTexture(false)
|
|
, _preCalculatedTexturesScale(1.0)
|
|
, _shadowEnabled(false)
|
|
, _time(0.f)
|
|
{
|
|
ghoul_precondition(
|
|
dictionary.hasKeyAndValue<std::string>(SceneGraphNode::KeyName),
|
|
"RenderableAtmosphere needs the name to be specified"
|
|
);
|
|
|
|
documentation::testSpecificationAndThrow(
|
|
Documentation(),
|
|
dictionary,
|
|
"RenderableAtmosphere"
|
|
);
|
|
|
|
const std::string name = dictionary.value<std::string>(SceneGraphNode::KeyName);
|
|
|
|
//================================================================
|
|
//======== Reads Shadow (Eclipses) Entries in mod file ===========
|
|
//================================================================
|
|
ghoul::Dictionary shadowDictionary;
|
|
bool success = dictionary.getValue(keyShadowGroup, shadowDictionary);
|
|
bool disableShadows = false;
|
|
if (success) {
|
|
std::vector<std::pair<std::string, float>> sourceArray;
|
|
unsigned int sourceCounter = 1;
|
|
while (success) {
|
|
std::string sourceName;
|
|
success = shadowDictionary.getValue(keyShadowSource +
|
|
std::to_string(sourceCounter) + ".Name", sourceName);
|
|
if (success) {
|
|
float sourceRadius;
|
|
success = shadowDictionary.getValue(keyShadowSource +
|
|
std::to_string(sourceCounter) + ".Radius", sourceRadius);
|
|
if (success) {
|
|
sourceArray.emplace_back(sourceName, sourceRadius);
|
|
}
|
|
else {
|
|
LWARNING("No Radius value expecified for Shadow Source Name "
|
|
<< sourceName << " from " << name
|
|
<< " planet.\nDisabling shadows for this planet.");
|
|
disableShadows = true;
|
|
break;
|
|
}
|
|
}
|
|
sourceCounter++;
|
|
}
|
|
|
|
if (!disableShadows && !sourceArray.empty()) {
|
|
success = true;
|
|
std::vector<std::pair<std::string, float>> casterArray;
|
|
unsigned int casterCounter = 1;
|
|
while (success) {
|
|
std::string casterName;
|
|
success = shadowDictionary.getValue(keyShadowCaster +
|
|
std::to_string(casterCounter) + ".Name", casterName);
|
|
if (success) {
|
|
float casterRadius;
|
|
success = shadowDictionary.getValue(keyShadowCaster +
|
|
std::to_string(casterCounter) + ".Radius", casterRadius);
|
|
if (success) {
|
|
casterArray.emplace_back(casterName, casterRadius);
|
|
}
|
|
else {
|
|
LWARNING("No Radius value expecified for Shadow Caster Name "
|
|
<< casterName << " from " << name
|
|
<< " planet.\nDisabling shadows for this planet.");
|
|
disableShadows = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
casterCounter++;
|
|
}
|
|
|
|
if (!disableShadows && (!sourceArray.empty() && !casterArray.empty())) {
|
|
for (const auto & source : sourceArray) {
|
|
for (const auto & caster : casterArray) {
|
|
ShadowConfiguration sc;
|
|
sc.source = source;
|
|
sc.caster = caster;
|
|
_shadowConfArray.push_back(sc);
|
|
}
|
|
}
|
|
_shadowEnabled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================
|
|
//========== Reads Atmosphere Entries from mod file ==============
|
|
//================================================================
|
|
bool errorReadingAtmosphereData = false;
|
|
ghoul::Dictionary atmosphereDictionary;
|
|
success = dictionary.getValue(keyAtmosphere, atmosphereDictionary);
|
|
if (success) {
|
|
std::string atmTypeString;
|
|
if (!atmosphereDictionary.getValue(keyAtmosphereType, atmTypeString)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Atmosphere Type value expecified for Atmosphere Effects " << name
|
|
<< " planet. Types allowed: RenderableGlobe or RenderablePlanet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
else {
|
|
if (atmTypeString.compare("RenderableGlobe") == 0) {
|
|
_atmosphereType = AtmosphereDeferredcaster::RenderableGlobe;
|
|
}
|
|
else if (atmTypeString.compare("RenderablePlanet") == 0)
|
|
{
|
|
_atmosphereType = AtmosphereDeferredcaster::RenderablePlanet;
|
|
}
|
|
else
|
|
{
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("Wrong atmosphere type specified for " << name
|
|
<< " planet. Types allowed: RenderableGlobe or RenderablePlanet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
}
|
|
|
|
if (!atmosphereDictionary.getValue(keyAtmosphereRadius, _atmosphereRadius)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Atmosphere Radius value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!atmosphereDictionary.getValue(keyPlanetRadius, _atmospherePlanetRadius)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Planet Radius value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!atmosphereDictionary.getValue(keyAverageGroundReflectance, _planetAverageGroundReflectance)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Average Atmosphere Ground Reflectance value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
ghoul::Dictionary rayleighDictionary;
|
|
success = atmosphereDictionary.getValue(keyRayleigh, rayleighDictionary);
|
|
|
|
if (success) {
|
|
// Not using right now.
|
|
glm::vec3 rayleighWavelengths;
|
|
success = rayleighDictionary.getValue("Coefficients.Wavelengths", rayleighWavelengths);
|
|
|
|
if (!rayleighDictionary.getValue("Coefficients.Scattering", _rayleighScatteringCoeff)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Rayleigh Scattering parameters expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!rayleighDictionary.getValue(keyRayleighHeightScale, _rayleighHeightScale)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Rayleigh Height Scale value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
}
|
|
else {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Rayleigh parameters expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
ghoul::Dictionary ozoneDictionary;
|
|
success = atmosphereDictionary.getValue(keyOzone, ozoneDictionary);
|
|
if (success) {
|
|
_ozoneLayerEnabled = true;
|
|
if (!ozoneDictionary.getValue(keyOzoneHeightScale, _ozoneHeightScale)) {
|
|
_ozoneLayerEnabled = false;
|
|
}
|
|
|
|
if (!ozoneDictionary.getValue("Coefficients.Extinction", _ozoneExtinctionCoeff)) {
|
|
_ozoneLayerEnabled = false;
|
|
}
|
|
}
|
|
else {
|
|
_ozoneLayerEnabled = false;
|
|
}
|
|
|
|
ghoul::Dictionary mieDictionary;
|
|
success = atmosphereDictionary.getValue(keyMie, mieDictionary);
|
|
if (success) {
|
|
if (!mieDictionary.getValue(keyMieHeightScale, _mieHeightScale)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Mie Height Scale value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!mieDictionary.getValue("Coefficients.Scattering", _mieScatteringCoeff)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Mie Scattering parameters expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!mieDictionary.getValue("Coefficients.Extinction", _mieExtinctionCoeff)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Mie Extinction parameters expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
if (!mieDictionary.getValue(keyMiePhaseConstant, _miePhaseConstant)) {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Mie Phase Constant value expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
}
|
|
else {
|
|
errorReadingAtmosphereData = true;
|
|
LWARNING("No Mie parameters expecified for Atmosphere Effects of "
|
|
<< name << " planet.\nDisabling atmosphere effects for this planet.");
|
|
}
|
|
|
|
ghoul::Dictionary ImageDictionary;
|
|
success = atmosphereDictionary.getValue(keyImage, ImageDictionary);
|
|
if (success) {
|
|
if (ImageDictionary.getValue(keyToneMappingOp, _preCalculatedTexturesScale)) {
|
|
LDEBUG("Atmosphere Texture Scaled to " << _preCalculatedTexturesScale);
|
|
}
|
|
|
|
if (ImageDictionary.getValue(keyExposure, _hdrConstant)) {
|
|
LDEBUG("Saving Precalculated Atmosphere Textures.");
|
|
}
|
|
|
|
if (ImageDictionary.getValue(keyGamma, _gammaConstant)) {
|
|
LDEBUG("Saving Precalculated Atmosphere Textures.");
|
|
}
|
|
}
|
|
|
|
ghoul::Dictionary debugDictionary;
|
|
success = atmosphereDictionary.getValue(keyATMDebug, debugDictionary);
|
|
if (success) {
|
|
if (debugDictionary.getValue(keyTextureScale, _preCalculatedTexturesScale)) {
|
|
LDEBUG("Atmosphere Texture Scaled to " << _preCalculatedTexturesScale);
|
|
}
|
|
|
|
if (debugDictionary.getValue(keySaveTextures, _saveCalculationsToTexture)) {
|
|
LDEBUG("Saving Precalculated Atmosphere Textures.");
|
|
}
|
|
|
|
}
|
|
|
|
if (!errorReadingAtmosphereData) {
|
|
_atmosphereEnabled = true;
|
|
|
|
//========================================================
|
|
//============== Atmosphere Properties ===================
|
|
//========================================================
|
|
|
|
_atmosphereHeightP =_atmosphereRadius - _atmospherePlanetRadius;
|
|
_atmosphereHeightP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_atmosphereHeightP);
|
|
|
|
_groundAverageReflectanceP = _planetAverageGroundReflectance;
|
|
_groundAverageReflectanceP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_groundAverageReflectanceP);
|
|
|
|
_rayleighHeightScaleP = _rayleighHeightScale;
|
|
_rayleighHeightScaleP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_rayleighHeightScaleP);
|
|
|
|
_rayleighScatteringCoeffXP = _rayleighScatteringCoeff.x * 1000.0f;
|
|
_rayleighScatteringCoeffXP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_rayleighScatteringCoeffXP);
|
|
|
|
_rayleighScatteringCoeffYP = _rayleighScatteringCoeff.y * 1000.0f;
|
|
_rayleighScatteringCoeffYP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_rayleighScatteringCoeffYP);
|
|
|
|
_rayleighScatteringCoeffZP = _rayleighScatteringCoeff.z * 1000.0f;
|
|
_rayleighScatteringCoeffZP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_rayleighScatteringCoeffZP);
|
|
|
|
_ozoneEnabledP = _ozoneLayerEnabled;
|
|
_ozoneEnabledP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_ozoneEnabledP);
|
|
|
|
_ozoneHeightScaleP = _ozoneHeightScale;
|
|
_ozoneHeightScaleP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_ozoneHeightScaleP);
|
|
|
|
_ozoneCoeffXP = _ozoneExtinctionCoeff.x * 100000.0f;
|
|
_ozoneCoeffXP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_ozoneCoeffXP);
|
|
|
|
_ozoneCoeffYP = _ozoneExtinctionCoeff.y * 100000.0f;
|
|
_ozoneCoeffYP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_ozoneCoeffYP);
|
|
|
|
|
|
_ozoneCoeffZP = _ozoneExtinctionCoeff.z * 100000.0f;
|
|
_ozoneCoeffZP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_ozoneCoeffZP);
|
|
|
|
_mieHeightScaleP = _mieHeightScale;
|
|
_mieHeightScaleP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieHeightScaleP);
|
|
|
|
_mieScatteringCoeffXP = _mieScatteringCoeff.x * 1000.0f;
|
|
_mieScatteringCoeffXP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieScatteringCoeffXP);
|
|
|
|
_mieScatteringCoeffYP = _mieScatteringCoeff.y * 1000.0f;
|
|
_mieScatteringCoeffYP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieScatteringCoeffYP);
|
|
|
|
_mieScatteringCoeffZP = _mieScatteringCoeff.z * 1000.0f;
|
|
_mieScatteringCoeffZP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieScatteringCoeffZP);
|
|
|
|
_mieScatteringExtinctionPropCoefficientP = _mieScatteringCoeff.x / _mieExtinctionCoeff.x;
|
|
_mieScatteringExtinctionPropCoefficientP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieScatteringExtinctionPropCoefficientP);
|
|
|
|
_mieAsymmetricFactorGP = _miePhaseConstant;
|
|
_mieAsymmetricFactorGP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_mieAsymmetricFactorGP);
|
|
|
|
_sunIntensityP = _sunRadianceIntensity;
|
|
_sunIntensityP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_sunIntensityP);
|
|
|
|
_hdrExpositionP = _hdrConstant;
|
|
_hdrExpositionP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_hdrExpositionP);
|
|
|
|
_gammaConstantP = _gammaConstant;
|
|
_gammaConstantP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_gammaConstantP);
|
|
|
|
_sunFollowingCameraEnabledP = _sunFollowingCameraEnabled;
|
|
_sunFollowingCameraEnabledP.onChange([this](){ updateAtmosphereParameters(); });
|
|
addProperty(_sunFollowingCameraEnabledP);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderableAtmosphere::initialize() {
|
|
RenderEngine& renderEngine = OsEng.renderEngine();
|
|
|
|
if (_atmosphereEnabled) {
|
|
_deferredcaster = std::make_unique<AtmosphereDeferredcaster>();
|
|
if (_deferredcaster) {
|
|
_deferredcaster->setAtmosphereRadius(_atmosphereRadius);
|
|
_deferredcaster->setPlanetRadius(_atmospherePlanetRadius);
|
|
_deferredcaster->setPlanetAverageGroundReflectance(_planetAverageGroundReflectance);
|
|
_deferredcaster->setRayleighHeightScale(_rayleighHeightScale);
|
|
_deferredcaster->enableOzone(_ozoneLayerEnabled);
|
|
_deferredcaster->setOzoneHeightScale(_ozoneHeightScale);
|
|
_deferredcaster->setMieHeightScale(_mieHeightScale);
|
|
_deferredcaster->setMiePhaseConstant(_miePhaseConstant);
|
|
_deferredcaster->setSunRadianceIntensity(_sunRadianceIntensity);
|
|
_deferredcaster->setHDRConstant(_hdrConstant);
|
|
_deferredcaster->setBackgroundConstant(_exposureBackgroundConstant);
|
|
_deferredcaster->setGammaConstant(_gammaConstant);
|
|
_deferredcaster->setRayleighScatteringCoefficients(_rayleighScatteringCoeff);
|
|
_deferredcaster->setOzoneExtinctionCoefficients(_ozoneExtinctionCoeff);
|
|
_deferredcaster->setMieScatteringCoefficients(_mieScatteringCoeff);
|
|
_deferredcaster->setMieExtinctionCoefficients(_mieExtinctionCoeff);
|
|
// TODO: Fix the ellipsoid nature of the renderable globe (JCC)
|
|
//_deferredcaster->setEllipsoidRadii(_ellipsoid.radii());
|
|
_deferredcaster->setRenderableClass(_atmosphereType);
|
|
_deferredcaster->enableSunFollowing(_sunFollowingCameraEnabled);
|
|
|
|
_deferredcaster->setPrecalculationTextureScale(_preCalculatedTexturesScale);
|
|
if (_saveCalculationsToTexture)
|
|
_deferredcaster->enablePrecalculationTexturesSaving();
|
|
|
|
_deferredcaster->initialize();
|
|
}
|
|
|
|
OsEng.renderEngine().deferredcasterManager().attachDeferredcaster(*_deferredcaster.get());
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void RenderableAtmosphere::deinitialize() {
|
|
if (_deferredcaster) {
|
|
OsEng.renderEngine().deferredcasterManager().detachDeferredcaster(*_deferredcaster.get());
|
|
_deferredcaster = nullptr;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool RenderableAtmosphere::isReady() const {
|
|
bool ready = true;
|
|
ready &= (_deferredcaster != nullptr);
|
|
return ready;
|
|
}
|
|
|
|
glm::dmat4 RenderableAtmosphere::computeModelTransformMatrix(const openspace::TransformData& transformData) {
|
|
// scale the planet to appropriate size since the planet is a unit sphere
|
|
return glm::translate(glm::dmat4(1.0), transformData.translation) * // Translation
|
|
glm::dmat4(transformData.rotation) * // Spice rotation
|
|
glm::dmat4(glm::scale(glm::dmat4(1.0), glm::dvec3(transformData.scale)));
|
|
}
|
|
|
|
void RenderableAtmosphere::render(const RenderData& data, RendererTasks& renderTask) {
|
|
|
|
if (_atmosphereEnabled) {
|
|
DeferredcasterTask task{ _deferredcaster.get(), data };
|
|
renderTask.deferredcasterTasks.push_back(task);
|
|
}
|
|
|
|
}
|
|
|
|
void RenderableAtmosphere::update(const UpdateData& data) {
|
|
_stateMatrix = data.modelTransform.rotation;
|
|
_time = data.time.j2000Seconds();
|
|
|
|
if (_deferredcaster) {
|
|
_deferredcaster->setTime(data.time.j2000Seconds());
|
|
glm::dmat4 modelTransform = computeModelTransformMatrix(data.modelTransform);
|
|
if (_atmosphereType == AtmosphereDeferredcaster::RenderablePlanet) {
|
|
//earth needs to be rotated
|
|
glm::dmat4 rot = glm::rotate(glm::dmat4(1.0), M_PI_2, glm::dvec3(1, 0, 0));
|
|
glm::dmat4 roty = glm::rotate(glm::dmat4(1.0), M_PI_2, glm::dvec3(0, -1, 0));
|
|
modelTransform = modelTransform * rot * roty;
|
|
}
|
|
_deferredcaster->setModelTransform(modelTransform);
|
|
|
|
if (_exposureBackgroundConstant != OsEng.renderEngine().renderer()->hdrBackground())
|
|
updateAtmosphereParameters();
|
|
}
|
|
}
|
|
|
|
void RenderableAtmosphere::updateAtmosphereParameters() {
|
|
bool executeComputation = true;
|
|
|
|
if (_sunRadianceIntensity != _sunIntensityP ||
|
|
_hdrConstant != _hdrExpositionP ||
|
|
_exposureBackgroundConstant != OsEng.renderEngine().renderer()->hdrBackground() ||
|
|
_gammaConstant != _gammaConstantP ||
|
|
_sunFollowingCameraEnabled != _sunFollowingCameraEnabledP) {
|
|
executeComputation = false;
|
|
}
|
|
|
|
|
|
_atmosphereRadius = _atmospherePlanetRadius + _atmosphereHeightP;
|
|
_planetAverageGroundReflectance = _groundAverageReflectanceP;
|
|
_rayleighHeightScale = _rayleighHeightScaleP;
|
|
_rayleighScatteringCoeff = glm::vec3(_rayleighScatteringCoeffXP * 0.001f, _rayleighScatteringCoeffYP * 0.001f,
|
|
_rayleighScatteringCoeffZP * 0.001f);
|
|
_ozoneLayerEnabled = _ozoneEnabledP;
|
|
_ozoneHeightScale = _ozoneHeightScaleP;
|
|
_ozoneExtinctionCoeff = glm::vec3(_ozoneCoeffXP.value() * 0.00001f,
|
|
_ozoneCoeffYP.value() * 0.00001f,
|
|
_ozoneCoeffZP.value() * 0.00001f);
|
|
_mieHeightScale = _mieHeightScaleP;
|
|
_mieScatteringCoeff = glm::vec3(_mieScatteringCoeffXP * 0.001f, _mieScatteringCoeffYP * 0.001f,
|
|
_mieScatteringCoeffZP * 0.001f);
|
|
_mieExtinctionCoeff = _mieScatteringCoeff * (1.0f / static_cast<float>(_mieScatteringExtinctionPropCoefficientP));
|
|
_miePhaseConstant = _mieAsymmetricFactorGP;
|
|
_sunRadianceIntensity = _sunIntensityP;
|
|
_hdrConstant = _hdrExpositionP;
|
|
_exposureBackgroundConstant = OsEng.renderEngine().renderer()->hdrBackground();
|
|
_gammaConstant = _gammaConstantP;
|
|
_sunFollowingCameraEnabled = _sunFollowingCameraEnabledP;
|
|
|
|
|
|
if (_deferredcaster) {
|
|
_deferredcaster->setAtmosphereRadius(_atmosphereRadius);
|
|
_deferredcaster->setPlanetRadius(_atmospherePlanetRadius);
|
|
_deferredcaster->setPlanetAverageGroundReflectance(_planetAverageGroundReflectance);
|
|
_deferredcaster->setRayleighHeightScale(_rayleighHeightScale);
|
|
_deferredcaster->enableOzone(_ozoneLayerEnabled);
|
|
_deferredcaster->setOzoneHeightScale(_ozoneHeightScale);
|
|
_deferredcaster->setMieHeightScale(_mieHeightScale);
|
|
_deferredcaster->setMiePhaseConstant(_miePhaseConstant);
|
|
_deferredcaster->setSunRadianceIntensity(_sunRadianceIntensity);
|
|
_deferredcaster->setHDRConstant(_hdrConstant);
|
|
_deferredcaster->setBackgroundConstant(_exposureBackgroundConstant);
|
|
_deferredcaster->setGammaConstant(_gammaConstant);
|
|
_deferredcaster->setRayleighScatteringCoefficients(_rayleighScatteringCoeff);
|
|
_deferredcaster->setOzoneExtinctionCoefficients(_ozoneExtinctionCoeff);
|
|
_deferredcaster->setMieScatteringCoefficients(_mieScatteringCoeff);
|
|
_deferredcaster->setMieExtinctionCoefficients(_mieExtinctionCoeff);
|
|
_deferredcaster->setRenderableClass(_atmosphereType);
|
|
_deferredcaster->enableSunFollowing(_sunFollowingCameraEnabled);
|
|
//_deferredcaster->setEllipsoidRadii(_ellipsoid.radii());
|
|
if (executeComputation)
|
|
_deferredcaster->preCalculateAtmosphereParam();
|
|
}
|
|
}
|
|
} // namespace openspace
|