diff --git a/modules/atmosphere/rendering/atmospheredeferredcaster.cpp b/modules/atmosphere/rendering/atmospheredeferredcaster.cpp index 6b07c2f1ee..d917e3e5d2 100644 --- a/modules/atmosphere/rendering/atmospheredeferredcaster.cpp +++ b/modules/atmosphere/rendering/atmospheredeferredcaster.cpp @@ -85,6 +85,8 @@ #endif // WIN32 #include +//#define __EXTRACT_CIE_CURVES__ + namespace { constexpr const char* _loggerCat = "AtmosphereDeferredcaster"; @@ -102,8 +104,9 @@ namespace { "inscatterTexture", "inscatterRayleighTexture", "inscatterMieTexture" }; - constexpr const std::array UniformCacheAdvMode = { - "useOnlyAdvancedMie", "deltaPolarizability", "n_real_rayleigh", "n_complex_rayleigh", + constexpr const std::array UniformCacheAdvMode = { + "useOnlyAdvancedMie", "useCornettePhaseFunction", "usePenndorfPhaseFunction", + "deltaPolarizability", "n_real_rayleigh", "n_complex_rayleigh", "n_real_mie", "n_complex_mie", "lambdaArray", "N_rayleigh, N_mie", "N_rayleigh_abs_molecule", "radius_abs_molecule_rayleigh", "mean_radius_particle_mie", "turbidity", "jungeExponent", "Kappa", "g1", "g2", "alpha" @@ -214,6 +217,8 @@ void AtmosphereDeferredcaster::preRaycast(const RenderData& renderData, // Advanced Mode Parameters program.setUniform(_uniformCacheAdvMode.deltaPolarizability, _advModeData.deltaPolarizability); program.setUniform(_uniformCacheAdvMode.useOnlyAdvancedMie, _advModeData.useOnlyAdvancedMie); + program.setUniform(_uniformCacheAdvMode.useCornettePhaseFunction, _advModeData.useCornettePhaseFunction); + program.setUniform(_uniformCacheAdvMode.usePenndorfPhaseFunction, _advModeData.usePenndorfPhaseFunction); program.setUniform(_uniformCacheAdvMode.jungeExponent, _advModeData.jungeExponent); program.setUniform(_uniformCacheAdvMode.Kappa, _advModeData.Kappa); program.setUniform(_uniformCacheAdvMode.lambdaArray, _advModeData.lambdaArray); @@ -1460,6 +1465,8 @@ void AtmosphereDeferredcaster::saveSkyLuminance() const { // Advance Mode Data cieCurveExtractionProgramObject->setUniform("advancedModeEnabled", _advancedMode); cieCurveExtractionProgramObject->setUniform("useOnlyAdvancedMie", _advModeData.useOnlyAdvancedMie); + cieCurveExtractionProgramObject->setUniform("useCornettePhaseFunction", _advModeData.useCornettePhaseFunction); + cieCurveExtractionProgramObject->setUniform("usePenndorfPhaseFunction", _advModeData.usePenndorfPhaseFunction); cieCurveExtractionProgramObject->setUniform("deltaPolarizability", _advModeData.deltaPolarizability); cieCurveExtractionProgramObject->setUniform("jungeExponent", _advModeData.jungeExponent); cieCurveExtractionProgramObject->setUniform("Kappa", _advModeData.Kappa); @@ -1601,8 +1608,10 @@ void AtmosphereDeferredcaster::preCalculateAtmosphereParam() { LDEBUG("Ended precalculations for Atmosphere effects..."); +#ifdef __EXTRACT_CIE_CURVES__ // Just for the paper: saveSkyLuminance(); +#endif } void AtmosphereDeferredcaster::createRenderQuad(GLuint* vao, GLuint* vbo, GLfloat size) const { @@ -1667,6 +1676,8 @@ void AtmosphereDeferredcaster::loadAtmosphereDataIntoShaderProgram( // Advance Mode Data shaderProg->setUniform("advancedModeEnabled", _advancedMode); shaderProg->setUniform("useOnlyAdvancedMie", _advModeData.useOnlyAdvancedMie); + shaderProg->setUniform("useCornettePhaseFunction", _advModeData.useCornettePhaseFunction); + shaderProg->setUniform("usePenndorfPhaseFunction", _advModeData.usePenndorfPhaseFunction); shaderProg->setUniform("deltaPolarizability", _advModeData.deltaPolarizability); shaderProg->setUniform("jungeExponent", _advModeData.jungeExponent); shaderProg->setUniform("Kappa", _advModeData.Kappa); diff --git a/modules/atmosphere/rendering/atmospheredeferredcaster.h b/modules/atmosphere/rendering/atmospheredeferredcaster.h index 404437c57b..a3b29e1576 100644 --- a/modules/atmosphere/rendering/atmospheredeferredcaster.h +++ b/modules/atmosphere/rendering/atmospheredeferredcaster.h @@ -66,6 +66,8 @@ public: float turbidity; float jungeExponent; bool useOnlyAdvancedMie; + bool useCornettePhaseFunction; + bool usePenndorfPhaseFunction; }; public: @@ -171,7 +173,8 @@ private: dSGCTViewToWorldMatrix, dCamPosObj, sunDirectionObj, hardShadows, transmittanceTexture, irradianceTexture, inscatterTexture, inscatterRayleighTexture, inscatterMieTexture) _uniformCache2; - UniformCache(useOnlyAdvancedMie, deltaPolarizability, n_real_rayleigh, n_complex_rayleigh, + UniformCache(useOnlyAdvancedMie, useCornettePhaseFunction, usePenndorfPhaseFunction, + deltaPolarizability, n_real_rayleigh, n_complex_rayleigh, n_real_mie, n_complex_mie, lambdaArray, N_rayleigh, N_mie, N_rayleigh_abs_molecule, radius_abs_molecule_rayleigh, mean_radius_particle_mie, turbidity, jungeExponent, Kappa, g1, g2, alpha) _uniformCacheAdvMode; diff --git a/modules/atmosphere/rendering/renderableatmosphere.cpp b/modules/atmosphere/rendering/renderableatmosphere.cpp index c1d947e062..f82bc9d6c9 100644 --- a/modules/atmosphere/rendering/renderableatmosphere.cpp +++ b/modules/atmosphere/rendering/renderableatmosphere.cpp @@ -213,6 +213,18 @@ namespace { "" }; + constexpr openspace::properties::Property::PropertyInfo UseCornettePhaseFunctionInfo = { + "UseCornettePhaseFunction", + "Use Cornette's phase function instead of DHG phase function", + "" + }; + + constexpr openspace::properties::Property::PropertyInfo UsePenndorfPhaseFunctionInfo = { + "UsePenndorfPhaseFunction", + "Use Penndorf's phase function approximation for Rayleigh's scattering", + "" + }; + openspace::properties::PropertyOwner::PropertyOwnerInfo AdvancedModeOwnerInfo = { "Advanced Mode Parameters", "Advanced Mode Parameters", @@ -397,6 +409,8 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary) , _hardShadowsEnabledP(EclipseHardShadowsInfo, false) , _enableAdvancedModeP(AdvancedModeInfo, false) , _useOnlyAdvancedMieP(UseOnlyAdvancedMieInfo, false) + , _useCornettePhaseFunctionP(UseCornettePhaseFunctionInfo , false) + , _usePenndorfPhaseFunctionP(UsePenndorfPhaseFunctionInfo , false) , _nRealRayleighP( RayleighRealRefractIndexInfo, glm::vec3(1.00027598f, 1.00027783f, 1.00028276f), @@ -699,6 +713,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary) if (rayleighDictionary.hasKey(RayleighRadiusAbsParticleInfo.identifier)) { _radiusAbsMoleculeRayleighP = rayleighDictionary.value(RayleighRadiusAbsParticleInfo.identifier); } + + if (rayleighDictionary.hasKey(UsePenndorfPhaseFunctionInfo.identifier)) { + _usePenndorfPhaseFunctionP = rayleighDictionary.value(UsePenndorfPhaseFunctionInfo.identifier); + } } else { errorReadingAtmosphereData = true; @@ -842,6 +860,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary) if (mieDictionary.hasKey(AlphaInfo.identifier)) { _alphaP = mieDictionary.value(AlphaInfo.identifier); } + + if (mieDictionary.hasKey(UseCornettePhaseFunctionInfo.identifier)) { + _useCornettePhaseFunctionP = mieDictionary.value(UseCornettePhaseFunctionInfo.identifier); + } } else { errorReadingAtmosphereData = true; @@ -968,6 +990,8 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary) addProperty(_enableAdvancedModeP); _useOnlyAdvancedMieP.onChange(updateAtmosphere); + _usePenndorfPhaseFunctionP.onChange(updateAtmosphere); + _useCornettePhaseFunctionP.onChange(updateAtmosphere); _nRealRayleighP.onChange(updateAtmosphere); _nComplexRayleighP.onChange(updateAtmosphere); _nRealMieP.onChange(updateAtmosphere); @@ -987,6 +1011,8 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary) _alphaP.onChange(updateAtmosphere); _advancedModeOwner.addProperty(_useOnlyAdvancedMieP); + _advancedModeOwner.addProperty(_usePenndorfPhaseFunctionP); + _advancedModeOwner.addProperty(_useCornettePhaseFunctionP); _advancedModeOwner.addProperty(_nRealRayleighP); _advancedModeOwner.addProperty(_nComplexRayleighP); _advancedModeOwner.addProperty(_nRealMieP); @@ -1139,6 +1165,8 @@ void RenderableAtmosphere::setDeferredCasterParameters(const bool executePreCalc AtmosphereDeferredcaster::AdvancedATMModeData advModeData; advModeData.useOnlyAdvancedMie = _useOnlyAdvancedMieP; + advModeData.usePenndorfPhaseFunction = _usePenndorfPhaseFunctionP; + advModeData.useCornettePhaseFunction = _useCornettePhaseFunctionP; advModeData.deltaPolarizability = _deltaPolarizabilityP; advModeData.jungeExponent = _jungeExponentP; advModeData.Kappa = _KappaP; diff --git a/modules/atmosphere/rendering/renderableatmosphere.h b/modules/atmosphere/rendering/renderableatmosphere.h index 72b752584f..0f0b0b12d0 100644 --- a/modules/atmosphere/rendering/renderableatmosphere.h +++ b/modules/atmosphere/rendering/renderableatmosphere.h @@ -115,6 +115,8 @@ private: // Advanced Mode Parameters properties::BoolProperty _useOnlyAdvancedMieP; + properties::BoolProperty _useCornettePhaseFunctionP; + properties::BoolProperty _usePenndorfPhaseFunctionP; properties::Vec3Property _nRealRayleighP; properties::Vec3Property _nComplexRayleighP; properties::Vec3Property _nRealMieP; diff --git a/modules/atmosphere/shaders/atmosphere_common.glsl b/modules/atmosphere/shaders/atmosphere_common.glsl index a800c368b9..36a79336d2 100644 --- a/modules/atmosphere/shaders/atmosphere_common.glsl +++ b/modules/atmosphere/shaders/atmosphere_common.glsl @@ -114,6 +114,8 @@ float invRtMinusRg = 1.0f / RtMinusRg; uniform bool advancedModeEnabled; uniform bool useOnlyAdvancedMie; +uniform bool useCornettePhaseFunction; +uniform bool usePenndorfPhaseFunction; uniform float deltaPolarizability; uniform vec3 n_real_rayleigh; uniform vec3 n_complex_rayleigh; @@ -561,13 +563,13 @@ vec3 transmittance(const float r, const float mu, const float d) { // scattering cosine angle mu -- // mu := cosine of the zeith angle of vec(v). Or mu = (vec(x) * vec(v))/r float rayleighPhaseFunction(const float mu) { - // if (advancedModeEnabled && !useOnlyAdvancedMie) { - // // Penndorf - // return 0.7629f * (1.f + 0.932f * mu * mu) * INV_M_PI * 0.25f; - // } else { + if ((advancedModeEnabled && !useOnlyAdvancedMie) || usePenndorfPhaseFunction) { + // Penndorf + return 0.7629f * (1.f + 0.932f * mu * mu) * INV_M_PI * 0.25f; + } else { //return (3.0f / (16.0f * M_PI)) * (1.0f + mu * mu); return 0.0596831036 * (1.0f + mu * mu); - //} + } } // -- Calculates DHG Mie phase function given thescattering cosine angle mu -- @@ -576,34 +578,34 @@ float rayleighPhaseFunction(const float mu) { // g2 := backward scattering // alpha: = ratio between g1 and g2 vec3 DHG_MiePhaseFunction(const float mu) { - // vec3 g1SQRD = g1 * g1; - // vec3 g2SQRD = g2 * g2; - // float exponent = 3.f/2f; + vec3 g1SQRD = g1 * g1; + vec3 g2SQRD = g2 * g2; + float exponent = 3.f/2f; - // vec3 denom1 = vec3(1.f) + g1SQRD - 2.f * g1 * mu; - // vec3 denom2 = vec3(1.f) + g2SQRD - 2.f * g2 * mu; - // vec3 d1Powered = vec3(pow(denom1.r, exponent), pow(denom1.g, exponent), pow(denom1.b, exponent)); - // vec3 d2Powered = vec3(pow(denom2.r, exponent), pow(denom2.g, exponent), pow(denom2.b, exponent)); + vec3 denom1 = vec3(1.f) + g1SQRD - 2.f * g1 * mu; + vec3 denom2 = vec3(1.f) + g2SQRD - 2.f * g2 * mu; + vec3 d1Powered = vec3(pow(denom1.r, exponent), pow(denom1.g, exponent), pow(denom1.b, exponent)); + vec3 d2Powered = vec3(pow(denom2.r, exponent), pow(denom2.g, exponent), pow(denom2.b, exponent)); - // return (alpha * ((vec3(1.f) - g1SQRD)/d1Powered) + (vec3(1.f) - alpha) * ((vec3(1.f) - g2SQRD)/d2Powered)) - // * INV_M_PI * 0.25f; + return (alpha * ((vec3(1.f) - g1SQRD)/d1Powered) + (vec3(1.f) - alpha) * ((vec3(1.f) - g2SQRD)/d2Powered)) + * INV_M_PI * 0.25f; - vec3 mieG2 = g1 * g1; - float powerRed = pow(1.0f + mieG2.r - 2.0f * g1.r * mu, -1.5f); - float powerGreen = pow(1.0f + mieG2.g - 2.0f * g1.g * mu, -1.5f); - float powerBlue = pow(1.0f + mieG2.b - 2.0f * g1.b * mu, -1.5f); + // vec3 mieG2 = g1 * g1; + // float powerRed = pow(1.0f + mieG2.r - 2.0f * g1.r * mu, -1.5f); + // float powerGreen = pow(1.0f + mieG2.g - 2.0f * g1.g * mu, -1.5f); + // float powerBlue = pow(1.0f + mieG2.b - 2.0f * g1.b * mu, -1.5f); - vec3 cornette = 0.1193662072 * (vec3(1.0f) - mieG2) * - vec3(powerRed, powerGreen, powerBlue) * (1.0f + mu * mu) / (vec3(2.0f) + mieG2); + // vec3 cornette = 0.1193662072 * (vec3(1.0f) - mieG2) * + // vec3(powerRed, powerGreen, powerBlue) * (1.0f + mu * mu) / (vec3(2.0f) + mieG2); - return vec3(cornette); + // return vec3(cornette); } // -- Calculates Mie phase function given the // scattering cosine angle mu -- // mu := cosine of the zeith angle of vec(v). Or mu = (vec(x) * vec(v))/r vec3 miePhaseFunction(const float mu) { - if (advancedModeEnabled) { + if (advancedModeEnabled && !useCornettePhaseFunction) { return DHG_MiePhaseFunction(mu); } else { // return (3.0f / (8.0f * M_PI)) * diff --git a/modules/base/dashboard/dashboarditemframerate.cpp b/modules/base/dashboard/dashboarditemframerate.cpp index c7075e9b24..413673b3f3 100644 --- a/modules/base/dashboard/dashboarditemframerate.cpp +++ b/modules/base/dashboard/dashboarditemframerate.cpp @@ -185,6 +185,7 @@ documentation::Documentation DashboardItemFramerate::Documentation() { } //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ DashboardItemFramerate::~DashboardItemFramerate() { _runThread = false; // bad, but is just for collecting the data @@ -217,6 +218,7 @@ DashboardItemFramerate::~DashboardItemFramerate() } } } +#endif DashboardItemFramerate::DashboardItemFramerate(const ghoul::Dictionary& dictionary) : DashboardItem(dictionary) @@ -224,9 +226,10 @@ DashboardItemFramerate::DashboardItemFramerate(const ghoul::Dictionary& dictiona , _fontSize(FontSizeInfo, DefaultFontSize, 6.f, 144.f, 1.f) , _frametimeType(FrametimeInfo, properties::OptionProperty::DisplayType::Dropdown) , _clearCache(ClearCacheInfo) - //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ , _enableFPSRecording({"EnableFPSRecording", "Enable FPS Recording", ""}, false) , _markTimeRecording({"MarkPointInterest", "Mark Point of Interest", ""}, false) +#endif { documentation::testSpecificationAndThrow( Documentation(), @@ -305,16 +308,19 @@ DashboardItemFramerate::DashboardItemFramerate(const ghoul::Dictionary& dictiona addProperty(_clearCache); //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ addProperty(_enableFPSRecording); addProperty(_markTimeRecording); _runThread = true; _dataCollectingThread = std::thread([this] { this->threadFunction(); }); _dataCollectingThread.detach(); +#endif _font = global::fontManager.font(_fontName, _fontSize); } //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ void DashboardItemFramerate::threadFunction() { while (_runThread) { @@ -330,6 +336,7 @@ void DashboardItemFramerate::threadFunction() { } } } +#endif void DashboardItemFramerate::render(glm::vec2& penPosition) { if (_shouldClearCache) { diff --git a/modules/base/dashboard/dashboarditemframerate.h b/modules/base/dashboard/dashboarditemframerate.h index e6b538b9fb..890eb888a8 100644 --- a/modules/base/dashboard/dashboarditemframerate.h +++ b/modules/base/dashboard/dashboarditemframerate.h @@ -33,8 +33,12 @@ #include #include +//#define __PERFORMANCE_MEASUREMENTS__ + +#ifdef __PERFORMANCE_MEASUREMENTS__ //JCC: Temp property to save the fps to a file #include +#endif namespace ghoul { class Dictionary; } namespace ghoul::fontrendering { class Font; } @@ -62,10 +66,10 @@ public: static documentation::Documentation Documentation(); //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ ~DashboardItemFramerate(); - - //JCC: Temp property to save the fps to a file void threadFunction(); +#endif private: properties::StringProperty _fontName; @@ -74,6 +78,7 @@ private: properties::TriggerProperty _clearCache; //JCC: Temp property to save the fps to a file +#ifdef __PERFORMANCE_MEASUREMENTS__ properties::BoolProperty _enableFPSRecording; properties::BoolProperty _markTimeRecording; int _markRecordings[100] = { -1 }; @@ -83,6 +88,7 @@ private: int _numberMarkedItems = 0; std::thread _dataCollectingThread; bool _runThread = false; +#endif std::shared_ptr _font;