From c5986236f7813dd5c80dc4405d7082d6d3fbbdf5 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Wed, 13 Nov 2024 19:43:29 +0000 Subject: [PATCH 01/27] feat: better rain fx --- .../WetnessEffects/WetnessEffects.hlsli | 2 + package/Shaders/Common/SharedData.hlsli | 12 +++--- package/Shaders/Lighting.hlsl | 19 +++++--- src/Features/WetnessEffects.cpp | 43 +++++++++++++++++-- src/Features/WetnessEffects.h | 6 ++- 5 files changed, 65 insertions(+), 17 deletions(-) diff --git a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli index 5358ad0264..acfd029910 100644 --- a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli +++ b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli @@ -2,6 +2,8 @@ namespace WetnessEffects { + Texture2D TexPrecipOcclusion : register(t31); + // https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile float2 EnvBRDFApproxWater(float3 F0, float Roughness, float NoV) { diff --git a/package/Shaders/Common/SharedData.hlsli b/package/Shaders/Common/SharedData.hlsli index 7852b293cb..349d67209e 100644 --- a/package/Shaders/Common/SharedData.hlsli +++ b/package/Shaders/Common/SharedData.hlsli @@ -70,6 +70,8 @@ struct LightLimitFixSettings struct WetnessEffectsSettings { + row_major float4x4 OcclusionViewProj; + float Time; float Raining; float Wetness; @@ -93,25 +95,25 @@ struct WetnessEffectsSettings bool EnableSplashes; bool EnableRipples; bool EnableChaoticRipples; - float RaindropFxRange; - float RaindropGridSizeRcp; + float RaindropIntervalRcp; float RaindropChance; float SplashesLifetime; - float SplashesStrength; + float SplashesMinRadius; float SplashesMaxRadius; float RippleStrength; - float RippleRadius; + float RippleBreadth; float RippleLifetimeRcp; float ChaoticRippleStrength; - float ChaoticRippleScaleRcp; + float ChaoticRippleSpeed; + float pad0[3]; }; struct SkylightingSettings diff --git a/package/Shaders/Lighting.hlsl b/package/Shaders/Lighting.hlsl index ba5fe5ed46..247e1191d1 100644 --- a/package/Shaders/Lighting.hlsl +++ b/package/Shaders/Lighting.hlsl @@ -1783,16 +1783,23 @@ PS_OUTPUT main(PS_INPUT input, bool frontFace # endif float4 raindropInfo = float4(0, 0, 1, 0); - if (worldSpaceNormal.z > 0 && wetnessEffectsSettings.Raining > 0.0f && wetnessEffectsSettings.EnableRaindropFx && - (dot(input.WorldPosition, input.WorldPosition) < wetnessEffectsSettings.RaindropFxRange * wetnessEffectsSettings.RaindropFxRange)) { - if (wetnessOcclusion > 0.0) + if (worldSpaceNormal.z > 0 && wetnessEffectsSettings.Raining > 0.0f && wetnessEffectsSettings.EnableRaindropFx) { + float4 precipOcclusionTexCoord = mul(wetnessEffectsSettings.OcclusionViewProj, float4(input.WorldPosition.xyz, 1)); + precipOcclusionTexCoord.y = -precipOcclusionTexCoord.y; + float2 precipOcclusionUV = precipOcclusionTexCoord.xy * 0.5 + 0.5; + + if (saturate(precipOcclusionUV.x) == precipOcclusionUV.x && saturate(precipOcclusionUV.y) == precipOcclusionUV.y){ + float precipOcclusionZ = WetnessEffects::TexPrecipOcclusion.SampleLevel(SampColorSampler, precipOcclusionUV, 0).x; + + if (precipOcclusionTexCoord.z < precipOcclusionZ + 0.1) # if defined(SKINNED) - raindropInfo = WetnessEffects::GetRainDrops(input.ModelPosition.xyz, wetnessEffectsSettings.Time, worldSpaceNormal); + raindropInfo = WetnessEffects::GetRainDrops(input.ModelPosition.xyz, wetnessEffectsSettings.Time, worldSpaceNormal); # elif defined(DEFERRED) - raindropInfo = WetnessEffects::GetRainDrops(input.WorldPosition.xyz + CameraPosAdjust[eyeIndex].xyz, wetnessEffectsSettings.Time, worldSpaceNormal); + raindropInfo = WetnessEffects::GetRainDrops(input.WorldPosition.xyz + CameraPosAdjust[eyeIndex].xyz, wetnessEffectsSettings.Time, worldSpaceNormal); # else - raindropInfo = WetnessEffects::GetRainDrops(!FrameParams.y ? input.ModelPosition.xyz : input.WorldPosition.xyz + CameraPosAdjust[eyeIndex].xyz, wetnessEffectsSettings.Time, worldSpaceNormal); + raindropInfo = WetnessEffects::GetRainDrops(!FrameParams.y ? input.ModelPosition.xyz : input.WorldPosition.xyz + CameraPosAdjust[eyeIndex].xyz, wetnessEffectsSettings.Time, worldSpaceNormal); # endif + } } float rainWetness = wetnessEffectsSettings.Wetness * minWetnessAngle * wetnessEffectsSettings.MaxRainWetness; diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 3ade71f411..5abaeb4613 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -42,7 +42,6 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( EnableSplashes, EnableRipples, EnableChaoticRipples, - RaindropFxRange, RaindropGridSize, RaindropInterval, RaindropChance, @@ -90,8 +89,6 @@ void WetnessEffects::DrawSettings() if (auto _tt = Util::HoverTooltipWrapper()) ImGui::Text("Enables an additional layer of disturbance to wet surfaces."); - ImGui::SliderFloat("Effect Range", &settings.RaindropFxRange, 1e2f, 2e3f, "%.0f game unit(s)"); - if (ImGui::TreeNodeEx("Raindrops")) { ImGui::BulletText( "At every interval, a raindrop is placed within each grid cell.\n" @@ -248,6 +245,34 @@ void WetnessEffects::CalculateWetness(RE::TESWeather* weather, RE::Sky* sky, flo WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() { PerFrame data{}; + + data.Raining = false; + + if (auto sky = RE::Sky::GetSingleton()) { + if (auto precip = sky->precip) { + auto precipObject = precip->currentPrecip; + if (!precipObject) { + precipObject = precip->lastPrecip; + } + if (precipObject) { + auto effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + data.OcclusionViewProj = rain->occlusionProjection; + data.Raining = rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->alpha > 0.0; + } + if (precip->currentPrecip && precip->lastPrecip) { + precipObject = precip->lastPrecip; + auto effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + data.Raining = data.Raining || (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->alpha > 0.0); + } + } + } + data.Wetness = DRY_WETNESS; data.PuddleWetness = DRY_WETNESS; currentWeatherID = 0; @@ -317,7 +342,6 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() // Calculate the wetness value from the water depth data.Wetness = std::min(wetnessDepth, MAX_WETNESS); data.PuddleWetness = std::min(puddleDepth, MAX_PUDDLE_WETNESS); - data.Raining = std::lerp(lastWeatherRaining, currentWeatherRaining, weatherTransitionPercentage); previousWeatherTransitionPercentage = weatherTransitionPercentage; } } @@ -344,6 +368,17 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() return data; } +void WetnessEffects::Prepass() +{ + static auto renderer = RE::BSGraphics::Renderer::GetSingleton(); + static auto& precipOcclusionTexture = renderer->GetDepthStencilData().depthStencils[RE::RENDER_TARGETS_DEPTHSTENCIL::kPRECIPITATION_OCCLUSION_MAP]; + + auto state = State::GetSingleton(); + auto& context = state->context; + + context->PSSetShaderResources(31, 1, &precipOcclusionTexture.depthSRV); +} + void WetnessEffects::Reset() { requiresUpdate = true; diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 51eccc0a89..3cb77c3949 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -38,7 +38,6 @@ struct WetnessEffects : Feature uint EnableSplashes = true; uint EnableRipples = true; uint EnableChaoticRipples = true; - float RaindropFxRange = 1000.f; float RaindropGridSize = 4.f; float RaindropInterval = .5f; float RaindropChance = .3f; @@ -57,12 +56,13 @@ struct WetnessEffects : Feature struct alignas(16) PerFrame { + REX::W32::XMFLOAT4X4 OcclusionViewProj; float Time; float Raining; float Wetness; float PuddleWetness; Settings settings; - uint pad0[2]; + uint pad0[3]; }; Settings settings; @@ -77,6 +77,8 @@ struct WetnessEffects : Feature uint32_t lastWeatherID = 0; float previousWeatherTransitionPercentage = 0.0f; + virtual void Prepass() override; + virtual void Reset() override; virtual void DrawSettings() override; From 73588beebeadb9a0834a22e4dfd433dd259916ec Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Wed, 13 Nov 2024 19:43:45 +0000 Subject: [PATCH 02/27] fix: rain occlusion --- package/Shaders/Particle.hlsl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/package/Shaders/Particle.hlsl b/package/Shaders/Particle.hlsl index 43830083a0..90ef7c930c 100644 --- a/package/Shaders/Particle.hlsl +++ b/package/Shaders/Particle.hlsl @@ -248,11 +248,11 @@ PS_OUTPUT main(PS_INPUT input) # endif // !VR # if defined(ENVCUBE) - float2 precipitationOcclusionUv = (input.PrecipitationOcclusionTexCoord.xy * 0.5 + 0.5) * TextureSize.x; + float2 precipitationOcclusionUV = (input.PrecipitationOcclusionTexCoord.xy * 0.5 + 0.5) * TextureSize.x; # ifdef VR - precipitationOcclusionUv *= DynamicResolutionParams1.x; // only difference in VR + precipitationOcclusionUV *= DynamicResolutionParams1.x; // only difference in VR # endif - float precipitationOcclusion = -input.PrecipitationOcclusionTexCoord.z + TexPrecipitationOcclusionTexture.SampleLevel(SampSourceTexture, precipitationOcclusionUv, 0).x; + float precipitationOcclusion = -input.PrecipitationOcclusionTexCoord.z + TexPrecipitationOcclusionTexture.Load(float3(precipitationOcclusionUV, 0)).x; float2 underwaterMaskUv = TextureSize.yz * input.Position.xy; float underwaterMask = TexUnderwaterMask.Sample(SampUnderwaterMask, underwaterMaskUv).x; if (precipitationOcclusion - underwaterMask < 0) { From 7c4782d76fb15c37337c256ae3a5aaf73fb87376 Mon Sep 17 00:00:00 2001 From: doodlum Date: Wed, 13 Nov 2024 19:44:39 +0000 Subject: [PATCH 03/27] =?UTF-8?q?style:=20=F0=9F=8E=A8=20apply=20clang-for?= =?UTF-8?q?mat=20changes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- package/Shaders/Lighting.hlsl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/package/Shaders/Lighting.hlsl b/package/Shaders/Lighting.hlsl index 247e1191d1..072399a5ba 100644 --- a/package/Shaders/Lighting.hlsl +++ b/package/Shaders/Lighting.hlsl @@ -1787,8 +1787,8 @@ PS_OUTPUT main(PS_INPUT input, bool frontFace float4 precipOcclusionTexCoord = mul(wetnessEffectsSettings.OcclusionViewProj, float4(input.WorldPosition.xyz, 1)); precipOcclusionTexCoord.y = -precipOcclusionTexCoord.y; float2 precipOcclusionUV = precipOcclusionTexCoord.xy * 0.5 + 0.5; - - if (saturate(precipOcclusionUV.x) == precipOcclusionUV.x && saturate(precipOcclusionUV.y) == precipOcclusionUV.y){ + + if (saturate(precipOcclusionUV.x) == precipOcclusionUV.x && saturate(precipOcclusionUV.y) == precipOcclusionUV.y) { float precipOcclusionZ = WetnessEffects::TexPrecipOcclusion.SampleLevel(SampColorSampler, precipOcclusionUV, 0).x; if (precipOcclusionTexCoord.z < precipOcclusionZ + 0.1) From 09e195c8180350ff3246ca0a4d52c7d991168c4c Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Wed, 13 Nov 2024 22:17:34 +0000 Subject: [PATCH 04/27] fix: use rain density instead of alpha --- src/Features/WetnessEffects.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 5abaeb4613..1b081f6d3f 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -260,7 +260,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); data.OcclusionViewProj = rain->occlusionProjection; - data.Raining = rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->alpha > 0.0; + data.Raining = rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->density > 0.0; } if (precip->currentPrecip && precip->lastPrecip) { precipObject = precip->lastPrecip; @@ -268,7 +268,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto shaderProp = netimmerse_cast(effect.get()); auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - data.Raining = data.Raining || (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->alpha > 0.0); + data.Raining = data.Raining || (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->density > 0.0); } } } From f9cd4f5ac650f49a8d2831d8e859183cb26fd59a Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Wed, 13 Nov 2024 23:46:03 +0000 Subject: [PATCH 05/27] chore: remove chaotic ripples --- .../WetnessEffects/WetnessEffects.hlsli | 13 ++++------- package/Shaders/Common/SharedData.hlsli | 11 +++------- src/Features/WetnessEffects.cpp | 22 +++---------------- src/Features/WetnessEffects.h | 4 ---- 4 files changed, 10 insertions(+), 40 deletions(-) diff --git a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli index acfd029910..f8d504fa15 100644 --- a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli +++ b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli @@ -60,15 +60,15 @@ namespace WetnessEffects const float rippleBreadthRcp = rcp(wetnessEffectsSettings.RippleBreadth); float2 gridUV = worldPos.xy * wetnessEffectsSettings.RaindropGridSizeRcp; - gridUV += normal.xy * 0.5; + gridUV += normal.xy; int2 grid = floor(gridUV); gridUV -= grid; float3 rippleNormal = float3(0, 0, 1); float wetness = 0; - if (wetnessEffectsSettings.EnableSplashes || wetnessEffectsSettings.EnableRipples) - for (int i = -1; i <= 1; i++) + if (wetnessEffectsSettings.EnableSplashes || wetnessEffectsSettings.EnableRipples){ + for (int i = -1; i <= 1; i++){ for (int j = -1; j <= 1; j++) { int2 gridCurr = grid + int2(i, j); float tOffset = float(Random::iqint3(gridCurr)) * uintToFloat; @@ -124,12 +124,7 @@ namespace WetnessEffects } } } - - if (wetnessEffectsSettings.EnableChaoticRipples) { - float3 turbulenceNormal = Random::perlinNoise(float3(worldPos.xy * wetnessEffectsSettings.ChaoticRippleScaleRcp, t * wetnessEffectsSettings.ChaoticRippleSpeed)); - turbulenceNormal.z = turbulenceNormal.z * .5 + 5; - turbulenceNormal = normalize(turbulenceNormal); - rippleNormal = normalize(rippleNormal + float3(turbulenceNormal.xy * wetnessEffectsSettings.ChaoticRippleStrength, 0)); + } } wetness *= wetnessEffectsSettings.SplashesStrength; diff --git a/package/Shaders/Common/SharedData.hlsli b/package/Shaders/Common/SharedData.hlsli index 349d67209e..cafaea4f81 100644 --- a/package/Shaders/Common/SharedData.hlsli +++ b/package/Shaders/Common/SharedData.hlsli @@ -94,25 +94,20 @@ struct WetnessEffectsSettings bool EnableSplashes; bool EnableRipples; - bool EnableChaoticRipples; float RaindropGridSizeRcp; - float RaindropIntervalRcp; + float RaindropChance; float SplashesLifetime; float SplashesStrength; - float SplashesMinRadius; + float SplashesMaxRadius; float RippleStrength; float RippleRadius; - float RippleBreadth; - float RippleLifetimeRcp; - float ChaoticRippleStrength; - float ChaoticRippleScaleRcp; - float ChaoticRippleSpeed; + float RippleLifetimeRcp; float pad0[3]; }; diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 1b081f6d3f..3a86ca6121 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -41,7 +41,6 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( EnableRaindropFx, EnableSplashes, EnableRipples, - EnableChaoticRipples, RaindropGridSize, RaindropInterval, RaindropChance, @@ -52,10 +51,8 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( RippleStrength, RippleRadius, RippleBreadth, - RippleLifetime, - ChaoticRippleStrength, - ChaoticRippleScale, - ChaoticRippleSpeed) + RippleLifetime +) void WetnessEffects::DrawSettings() { @@ -85,15 +82,11 @@ void WetnessEffects::DrawSettings() ImGui::Checkbox("Enable Ripples", (bool*)&settings.EnableRipples); if (auto _tt = Util::HoverTooltipWrapper()) ImGui::Text("Enables circular ripples on puddles, and to a less extent other wet surfaces"); - ImGui::Checkbox("Enable Chaotic Ripples", (bool*)&settings.EnableChaoticRipples); - if (auto _tt = Util::HoverTooltipWrapper()) - ImGui::Text("Enables an additional layer of disturbance to wet surfaces."); if (ImGui::TreeNodeEx("Raindrops")) { ImGui::BulletText( "At every interval, a raindrop is placed within each grid cell.\n" - "Only a set portion of raindrops will actually trigger splashes and ripples.\n" - "Chaotic ripples are not affected by raindrop settings."); + "Only a set portion of raindrops will actually trigger splashes and ripples.\n"); ImGui::SliderFloat("Grid Size", &settings.RaindropGridSize, 1.f, 10.f, "%.1f game unit(s)"); ImGui::SliderFloat("Interval", &settings.RaindropInterval, 0.1f, 2.f, "%.1f sec"); @@ -125,13 +118,6 @@ void WetnessEffects::DrawSettings() ImGui::TreePop(); } - if (ImGui::TreeNodeEx("Chaotic Ripples")) { - ImGui::SliderFloat("Strength", &settings.ChaoticRippleStrength, 0.f, .5f, "%.2f"); - ImGui::SliderFloat("Scale", &settings.ChaoticRippleScale, 0.1f, 5.f, "%.2f", ImGuiSliderFlags_AlwaysClamp); - ImGui::SliderFloat("Speed", &settings.ChaoticRippleSpeed, 0.f, 50.f, "%.1f"); - ImGui::TreePop(); - } - ImGui::EndDisabled(); ImGui::TreePop(); @@ -362,8 +348,6 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() data.settings.RaindropGridSize = 1.f / settings.RaindropGridSize; data.settings.RaindropInterval = 1.f / settings.RaindropInterval; data.settings.RippleLifetime = settings.RaindropInterval / settings.RippleLifetime; - data.settings.ChaoticRippleStrength *= std::clamp(data.Raining, 0.f, 1.f); - data.settings.ChaoticRippleScale = 1.f / settings.ChaoticRippleScale; return data; } diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 3cb77c3949..3ef2cf00c8 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -37,7 +37,6 @@ struct WetnessEffects : Feature uint EnableRaindropFx = true; uint EnableSplashes = true; uint EnableRipples = true; - uint EnableChaoticRipples = true; float RaindropGridSize = 4.f; float RaindropInterval = .5f; float RaindropChance = .3f; @@ -49,9 +48,6 @@ struct WetnessEffects : Feature float RippleRadius = 1.f; float RippleBreadth = .5f; float RippleLifetime = .15f; - float ChaoticRippleStrength = .1f; - float ChaoticRippleScale = 1.f; - float ChaoticRippleSpeed = 20.f; }; struct alignas(16) PerFrame From 3bc00d4687ab286603f846663c40902801794b5a Mon Sep 17 00:00:00 2001 From: doodlum Date: Wed, 13 Nov 2024 23:46:53 +0000 Subject: [PATCH 06/27] =?UTF-8?q?style:=20=F0=9F=8E=A8=20apply=20clang-for?= =?UTF-8?q?mat=20changes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Shaders/WetnessEffects/WetnessEffects.hlsli | 4 ++-- src/Features/WetnessEffects.cpp | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli index f8d504fa15..bc8347e8e7 100644 --- a/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli +++ b/features/Wetness Effects/Shaders/WetnessEffects/WetnessEffects.hlsli @@ -67,8 +67,8 @@ namespace WetnessEffects float3 rippleNormal = float3(0, 0, 1); float wetness = 0; - if (wetnessEffectsSettings.EnableSplashes || wetnessEffectsSettings.EnableRipples){ - for (int i = -1; i <= 1; i++){ + if (wetnessEffectsSettings.EnableSplashes || wetnessEffectsSettings.EnableRipples) { + for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { int2 gridCurr = grid + int2(i, j); float tOffset = float(Random::iqint3(gridCurr)) * uintToFloat; diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 3a86ca6121..970b2ad32d 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -51,8 +51,7 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( RippleStrength, RippleRadius, RippleBreadth, - RippleLifetime -) + RippleLifetime) void WetnessEffects::DrawSettings() { From 5264340b68c40ca1822077f8e47dfe24f667e83b Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 00:17:13 +0000 Subject: [PATCH 07/27] feat: rain fade in and out --- src/Features/WetnessEffects.cpp | 52 +++++++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 12 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 3a86ca6121..6d70cc9a38 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -232,30 +232,58 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() { PerFrame data{}; - data.Raining = false; + data.Raining = 0.0f; if (auto sky = RE::Sky::GetSingleton()) { if (auto precip = sky->precip) { - auto precipObject = precip->currentPrecip; - if (!precipObject) { - precipObject = precip->lastPrecip; + float currentRaining = 0.0f; + float lastRaining = 0.0f; + + { + auto precipObject = precip->currentPrecip; + if (!precipObject) { + precipObject = precip->lastPrecip; + } + if (precipObject) { + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + data.OcclusionViewProj = rain->occlusionProjection; + } } - if (precipObject) { - auto effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + + if (precip->currentPrecip && sky->currentWeather->precipitationData) { + auto& precipObject = precip->currentPrecip; + auto weather = sky->currentWeather; + + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; auto shaderProp = netimmerse_cast(effect.get()); auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - data.OcclusionViewProj = rain->occlusionProjection; - data.Raining = rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->density > 0.0; + if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + currentRaining = rain->density / maxDensity; + } } - if (precip->currentPrecip && precip->lastPrecip) { - precipObject = precip->lastPrecip; - auto effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + + if (precip->lastPrecip && sky->lastWeather->precipitationData) { + auto& precipObject = precip->lastPrecip; + auto weather = sky->lastWeather; + + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; auto shaderProp = netimmerse_cast(effect.get()); auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - data.Raining = data.Raining || (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain) && rain->density > 0.0); + if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + lastRaining = rain->density / maxDensity; + } } + + data.Raining = std::lerp(lastRaining, currentRaining, sky->currentWeatherPct); } } From 524fc7816ca567bc9892c1c510e5c0a9862e787c Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 01:46:27 +0000 Subject: [PATCH 08/27] feat: redone wetness and puddle cpu code --- src/Features/WetnessEffects.cpp | 253 +++++++++----------------------- src/Features/WetnessEffects.h | 2 - 2 files changed, 67 insertions(+), 188 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 4ef6db818e..f0475c9baa 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -3,27 +3,7 @@ #include "Util.h" const float MIN_START_PERCENTAGE = 0.05f; -const float DEFAULT_TRANSITION_PERCENTAGE = 1.0f; -const float TRANSITION_CURVE_MULTIPLIER = 2.0f; const float TRANSITION_DENOMINATOR = 256.0f; -const float DRY_WETNESS = 0.0f; -const float RAIN_DELTA_PER_SECOND = 2.0f / 3600.0f; -const float SNOWY_DAY_DELTA_PER_SECOND = -0.489f / 3600.0f; // Only doing evaporation until snow wetness feature is added -const float CLOUDY_DAY_DELTA_PER_SECOND = -0.735f / 3600.0f; -const float CLEAR_DAY_DELTA_PER_SECOND = -1.518f / 3600.0f; -const float WETNESS_SCALE = 2.0; // Speed at which wetness builds up and drys. -const float PUDDLE_SCALE = 1.0; // Speed at which puddles build up and dry -const float MAX_PUDDLE_DEPTH = 3.0f; -const float MAX_WETNESS_DEPTH = 2.0f; -const float MAX_PUDDLE_WETNESS = 1.0f; -const float MAX_WETNESS = 1.0f; -const float SECONDS_IN_A_DAY = 86400; -const float MAX_TIME_DELTA = SECONDS_IN_A_DAY - 30; -const float MIN_WEATHER_TRANSITION_SPEED = 0.0f; -const float MAX_WEATHER_TRANSITION_SPEED = 500.0f; -const float AVERAGE_RAIN_VOLUME = 4000.0f; -const float MIN_RAINDROP_CHANCE_MULTIPLIER = 0.1f; -const float MAX_RAINDROP_CHANCE_MULTIPLIER = 2.0f; NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( WetnessEffects::Settings, @@ -174,57 +154,11 @@ void WetnessEffects::DrawSettings() ImGui::Spacing(); ImGui::Spacing(); - - if (ImGui::TreeNodeEx("Statistics", ImGuiTreeNodeFlags_DefaultOpen)) { - ImGui::Text(std::format("Wetness depth : {:.2f}", wetnessDepth / WETNESS_SCALE).c_str()); - ImGui::Text(std::format("Puddle depth : {:.2f}", puddleDepth / PUDDLE_SCALE).c_str()); - ImGui::Spacing(); - ImGui::Spacing(); - ImGui::Text(std::format("Current weather : {0:X}", currentWeatherID).c_str()); - ImGui::Text(std::format("Previous weather : {0:X}", lastWeatherID).c_str()); - ImGui::TreePop(); - } -} - -float WetnessEffects::CalculateWeatherTransitionPercentage(float skyCurrentWeatherPct, float beginFade, bool fadeIn) -{ - float weatherTransitionPercentage = DEFAULT_TRANSITION_PERCENTAGE; - // Correct if beginFade is zero or negative - beginFade = beginFade > 0 ? beginFade : beginFade + TRANSITION_DENOMINATOR; - // Wait to start transition until precipitation begins/ends - float startPercentage = 1 - ((TRANSITION_DENOMINATOR - beginFade) * (1.0f / TRANSITION_DENOMINATOR)); - - if (fadeIn) { - float currentPercentage = (skyCurrentWeatherPct - startPercentage) / (1 - startPercentage); - weatherTransitionPercentage = std::clamp(currentPercentage, 0.0f, 1.0f); - } else { - float currentPercentage = (startPercentage - skyCurrentWeatherPct) / (startPercentage); - weatherTransitionPercentage = 1 - std::clamp(currentPercentage, 0.0f, 1.0f); - } - return weatherTransitionPercentage; } -void WetnessEffects::CalculateWetness(RE::TESWeather* weather, RE::Sky* sky, float seconds, float& weatherWetnessDepth, float& weatherPuddleDepth) +static float linearstep(float edge0, float edge1, float x) { - float wetnessDepthDelta = CLEAR_DAY_DELTA_PER_SECOND * WETNESS_SCALE * seconds; - float puddleDepthDelta = CLEAR_DAY_DELTA_PER_SECOND * PUDDLE_SCALE * seconds; - if (weather && sky) { - // Figure out the weather type and set the wetness - if (weather->precipitationData && weather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - // Raining - wetnessDepthDelta = RAIN_DELTA_PER_SECOND * WETNESS_SCALE * seconds; - puddleDepthDelta = RAIN_DELTA_PER_SECOND * PUDDLE_SCALE * seconds; - } else if (weather->precipitationData && weather->data.flags.any(RE::TESWeather::WeatherDataFlag::kSnow)) { - wetnessDepthDelta = SNOWY_DAY_DELTA_PER_SECOND * WETNESS_SCALE * seconds; - puddleDepthDelta = SNOWY_DAY_DELTA_PER_SECOND * PUDDLE_SCALE * seconds; - } else if (weather->data.flags.any(RE::TESWeather::WeatherDataFlag::kCloudy)) { - wetnessDepthDelta = CLOUDY_DAY_DELTA_PER_SECOND * WETNESS_SCALE * seconds; - puddleDepthDelta = CLOUDY_DAY_DELTA_PER_SECOND * PUDDLE_SCALE * seconds; - } - } - - weatherWetnessDepth = wetnessDepthDelta > 0 ? std::min(weatherWetnessDepth + wetnessDepthDelta, MAX_WETNESS_DEPTH) : std::max(weatherWetnessDepth + wetnessDepthDelta, 0.0f); - weatherPuddleDepth = puddleDepthDelta > 0 ? std::min(weatherPuddleDepth + puddleDepthDelta, MAX_PUDDLE_DEPTH) : std::max(weatherPuddleDepth + puddleDepthDelta, 0.0f); + return std::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f); } WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() @@ -232,145 +166,92 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() PerFrame data{}; data.Raining = 0.0f; - - if (auto sky = RE::Sky::GetSingleton()) { - if (auto precip = sky->precip) { - float currentRaining = 0.0f; - float lastRaining = 0.0f; - - { - auto precipObject = precip->currentPrecip; - if (!precipObject) { - precipObject = precip->lastPrecip; - } - if (precipObject) { - auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; - auto shaderProp = netimmerse_cast(effect.get()); - auto particleShaderProperty = netimmerse_cast(shaderProp); - auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - data.OcclusionViewProj = rain->occlusionProjection; - } - } - - if (precip->currentPrecip && sky->currentWeather->precipitationData) { - auto& precipObject = precip->currentPrecip; - auto weather = sky->currentWeather; - - auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; - auto shaderProp = netimmerse_cast(effect.get()); - auto particleShaderProperty = netimmerse_cast(shaderProp); - auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - currentRaining = rain->density / maxDensity; - } - } - - if (precip->lastPrecip && sky->lastWeather->precipitationData) { - auto& precipObject = precip->lastPrecip; - auto weather = sky->lastWeather; - - auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; - auto shaderProp = netimmerse_cast(effect.get()); - auto particleShaderProperty = netimmerse_cast(shaderProp); - auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); - if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - lastRaining = rain->density / maxDensity; - } - } - - data.Raining = std::lerp(lastRaining, currentRaining, sky->currentWeatherPct); - } - } - - data.Wetness = DRY_WETNESS; - data.PuddleWetness = DRY_WETNESS; - currentWeatherID = 0; - uint32_t previousLastWeatherID = lastWeatherID; - lastWeatherID = 0; - float currentWeatherRaining = 0.0f; - float lastWeatherRaining = 0.0f; - float weatherTransitionPercentage = previousWeatherTransitionPercentage; + data.Wetness = 0.0f; + data.PuddleWetness = 0.0f; if (settings.EnableWetnessEffects) { if (auto sky = RE::Sky::GetSingleton()) { if (sky->mode.get() == RE::Sky::Mode::kFull) { - if (auto currentWeather = sky->currentWeather) { - if (currentWeather->precipitationData && currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - float rainDensity = currentWeather->precipitationData->data[static_cast(RE::BGSShaderParticleGeometryData::DataID::kParticleDensity)].f; - float rainGravity = currentWeather->precipitationData->data[static_cast(RE::BGSShaderParticleGeometryData::DataID::kGravityVelocity)].f; - currentWeatherRaining = std::clamp(((rainDensity * rainGravity) / AVERAGE_RAIN_VOLUME), MIN_RAINDROP_CHANCE_MULTIPLIER, MAX_RAINDROP_CHANCE_MULTIPLIER); - } - currentWeatherID = currentWeather->GetFormID(); - if (auto calendar = RE::Calendar::GetSingleton()) { - float currentWeatherWetnessDepth = wetnessDepth; - float currentWeatherPuddleDepth = puddleDepth; - float currentGameTime = calendar->GetCurrentGameTime() * SECONDS_IN_A_DAY; - lastGameTimeValue = lastGameTimeValue == 0 ? currentGameTime : lastGameTimeValue; - float seconds = currentGameTime - lastGameTimeValue; - lastGameTimeValue = currentGameTime; - - if (seconds >= MAX_TIME_DELTA || seconds < 0) { - // If too much time has passed, snap wetness depths to the current weather. - seconds = 0.0f; - currentWeatherWetnessDepth = 0.0f; - currentWeatherPuddleDepth = 0.0f; - weatherTransitionPercentage = DEFAULT_TRANSITION_PERCENTAGE; - CalculateWetness(currentWeather, sky, 1.0f, currentWeatherWetnessDepth, currentWeatherPuddleDepth); - wetnessDepth = currentWeatherWetnessDepth > 0 ? MAX_WETNESS_DEPTH : 0.0f; - puddleDepth = currentWeatherPuddleDepth > 0 ? MAX_PUDDLE_DEPTH : 0.0f; + if (auto precip = sky->precip) { + float currentRaining = 0.0f; + float lastRaining = 0.0f; + + { + auto precipObject = precip->currentPrecip; + if (!precipObject) { + precipObject = precip->lastPrecip; + } + if (precipObject) { + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + data.OcclusionViewProj = rain->occlusionProjection; } + } - if (seconds > 0) { - weatherTransitionPercentage = DEFAULT_TRANSITION_PERCENTAGE; - float lastWeatherWetnessDepth = wetnessDepth; - float lastWeatherPuddleDepth = puddleDepth; - seconds *= std::clamp(settings.WeatherTransitionSpeed, MIN_WEATHER_TRANSITION_SPEED, MAX_WEATHER_TRANSITION_SPEED); - CalculateWetness(currentWeather, sky, seconds, currentWeatherWetnessDepth, currentWeatherPuddleDepth); - // If there is a lastWeather, figure out what type it is and set the wetness - if (auto lastWeather = sky->lastWeather) { - lastWeatherID = lastWeather->GetFormID(); - CalculateWetness(lastWeather, sky, seconds, lastWeatherWetnessDepth, lastWeatherPuddleDepth); - // If it was raining, wait to transition until precipitation ends, otherwise use the current weather's fade in - if (lastWeather->precipitationData && lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - float rainDensity = lastWeather->precipitationData->data[static_cast(RE::BGSShaderParticleGeometryData::DataID::kParticleDensity)].f; - float rainGravity = lastWeather->precipitationData->data[static_cast(RE::BGSShaderParticleGeometryData::DataID::kGravityVelocity)].f; - lastWeatherRaining = std::clamp(((rainDensity * rainGravity) / AVERAGE_RAIN_VOLUME), MIN_RAINDROP_CHANCE_MULTIPLIER, MAX_RAINDROP_CHANCE_MULTIPLIER); - weatherTransitionPercentage = CalculateWeatherTransitionPercentage(sky->currentWeatherPct, lastWeather->data.precipitationEndFadeOut, false); - } else { - weatherTransitionPercentage = CalculateWeatherTransitionPercentage(sky->currentWeatherPct, currentWeather->data.precipitationBeginFadeIn, true); - } - } - - // Transition between CurrentWeather and LastWeather depth values - wetnessDepth = std::lerp(lastWeatherWetnessDepth, currentWeatherWetnessDepth, weatherTransitionPercentage); - puddleDepth = std::lerp(lastWeatherPuddleDepth, currentWeatherPuddleDepth, weatherTransitionPercentage); - } else { - lastWeatherID = previousLastWeatherID; + if (precip->currentPrecip && sky->currentWeather->precipitationData) { + auto& precipObject = precip->currentPrecip; + auto weather = sky->currentWeather; + + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + currentRaining = rain->density / maxDensity; } + } - // Calculate the wetness value from the water depth - data.Wetness = std::min(wetnessDepth, MAX_WETNESS); - data.PuddleWetness = std::min(puddleDepth, MAX_PUDDLE_WETNESS); - previousWeatherTransitionPercentage = weatherTransitionPercentage; + if (precip->lastPrecip && sky->lastWeather->precipitationData) { + auto& precipObject = precip->lastPrecip; + auto weather = sky->lastWeather; + + auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; + auto shaderProp = netimmerse_cast(effect.get()); + auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); + if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + lastRaining = rain->density / maxDensity; + } } + + data.Raining = currentRaining + lastRaining; } + + float wetnessCurrentWeather = 0.0f; + if (sky->currentWeather && sky->currentWeather->precipitationData && sky->currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { + wetnessCurrentWeather = linearstep(abs((float)sky->currentWeather->data.precipitationBeginFadeIn), 255, sky->currentWeatherPct * 255); + } + + float wetnessLastWeather = 0.0f; + float puddleLastWeather = 0.0f; + + if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { + wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); + puddleLastWeather = 1.0f - sky->currentWeatherPct; + } + + data.Wetness = wetnessCurrentWeather + wetnessLastWeather; + data.PuddleWetness = std::max(data.Wetness, puddleLastWeather) * settings.MaxPuddleWetness * 0.5f; } } } static size_t rainTimer = 0; // size_t for precision - if (!RE::UI::GetSingleton()->GameIsPaused()) // from lightlimitfix + if (!RE::UI::GetSingleton()->GameIsPaused()) rainTimer += (size_t)(RE::GetSecondsSinceLastFrame() * 1000); // BSTimer::delta is always 0 for some reason data.Time = rainTimer / 1000.f; data.settings = settings; // Disable Shore Wetness if Wetness Effects are Disabled data.settings.MaxShoreWetness = settings.EnableWetnessEffects ? settings.MaxShoreWetness : 0.0f; - // calculating some parameters on cpu + + // Calculating some parameters on cpu data.settings.RaindropChance *= data.Raining; data.settings.RaindropGridSize = 1.f / settings.RaindropGridSize; data.settings.RaindropInterval = 1.f / settings.RaindropInterval; diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 3ef2cf00c8..199e05dbc6 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -83,8 +83,6 @@ struct WetnessEffects : Feature virtual void SaveSettings(json& o_json) override; virtual void RestoreDefaultSettings() override; - float CalculateWeatherTransitionPercentage(float skyCurrentWeatherPct, float beginFade, bool fadeIn); - void CalculateWetness(RE::TESWeather* weather, RE::Sky* sky, float seconds, float& wetness, float& puddleWetness); virtual bool SupportsVR() override { return true; }; }; From 9980cb8db947c2306eb8b35fe0e2d1667c909ddc Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 01:47:02 +0000 Subject: [PATCH 09/27] chore: tweak default wetness settings --- src/Features/WetnessEffects.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 199e05dbc6..01608eb369 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -22,8 +22,8 @@ struct WetnessEffects : Feature struct Settings { uint EnableWetnessEffects = true; - float MaxRainWetness = 1.0f; - float MaxPuddleWetness = 2.667f; + float MaxRainWetness = 0.75f; + float MaxPuddleWetness = 2.5f; float MaxShoreWetness = 0.5f; uint ShoreRange = 32; float PuddleRadius = 1.0f; From cc2fe9ecd0d96b8b0f839859bfd1822efee9bb42 Mon Sep 17 00:00:00 2001 From: doodlum Date: Thu, 14 Nov 2024 01:47:12 +0000 Subject: [PATCH 10/27] =?UTF-8?q?style:=20=F0=9F=8E=A8=20apply=20clang-for?= =?UTF-8?q?mat=20changes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Features/WetnessEffects.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index f0475c9baa..141d9a4ccd 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -223,7 +223,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() data.Raining = currentRaining + lastRaining; } - float wetnessCurrentWeather = 0.0f; + float wetnessCurrentWeather = 0.0f; if (sky->currentWeather && sky->currentWeather->precipitationData && sky->currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessCurrentWeather = linearstep(abs((float)sky->currentWeather->data.precipitationBeginFadeIn), 255, sky->currentWeatherPct * 255); } @@ -242,8 +242,8 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() } } - static size_t rainTimer = 0; // size_t for precision - if (!RE::UI::GetSingleton()->GameIsPaused()) + static size_t rainTimer = 0; // size_t for precision + if (!RE::UI::GetSingleton()->GameIsPaused()) rainTimer += (size_t)(RE::GetSecondsSinceLastFrame() * 1000); // BSTimer::delta is always 0 for some reason data.Time = rainTimer / 1000.f; From 7a67a09bd224ee93269bec8eafb83df6ee3add7b Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 01:48:49 +0000 Subject: [PATCH 11/27] chore: remove unused constants --- src/Features/WetnessEffects.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 141d9a4ccd..60494cf859 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -2,9 +2,6 @@ #include "Util.h" -const float MIN_START_PERCENTAGE = 0.05f; -const float TRANSITION_DENOMINATOR = 256.0f; - NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT( WetnessEffects::Settings, EnableWetnessEffects, From 0aa6aaea14b1e6d3a0d741d69fb1f81fac8637fb Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 01:51:10 +0000 Subject: [PATCH 12/27] chore: bias towards puddles --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 60494cf859..1fcc732ea3 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -230,7 +230,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); - puddleLastWeather = 1.0f - sky->currentWeatherPct; + puddleLastWeather = sqrt(1.0f - sky->currentWeatherPct); } data.Wetness = wetnessCurrentWeather + wetnessLastWeather; From dae1cc224ae84e7d80b3d92d13f22f40f25f8623 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 01:56:01 +0000 Subject: [PATCH 13/27] chore: chore further cleanup --- src/Features/WetnessEffects.cpp | 14 ++++---------- src/Features/WetnessEffects.h | 10 ---------- 2 files changed, 4 insertions(+), 20 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 1fcc732ea3..7ade10063c 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -153,11 +153,6 @@ void WetnessEffects::DrawSettings() ImGui::Spacing(); } -static float linearstep(float edge0, float edge1, float x) -{ - return std::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f); -} - WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() { PerFrame data{}; @@ -220,6 +215,10 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() data.Raining = currentRaining + lastRaining; } + auto linearstep = [](float edge0, float edge1, float x) { + return std::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f); + }; + float wetnessCurrentWeather = 0.0f; if (sky->currentWeather && sky->currentWeather->precipitationData && sky->currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessCurrentWeather = linearstep(abs((float)sky->currentWeather->data.precipitationBeginFadeIn), 255, sky->currentWeatherPct * 255); @@ -268,11 +267,6 @@ void WetnessEffects::Prepass() context->PSSetShaderResources(31, 1, &precipOcclusionTexture.depthSRV); } -void WetnessEffects::Reset() -{ - requiresUpdate = true; -} - void WetnessEffects::LoadSettings(json& o_json) { settings = o_json; diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 01608eb369..9865142e63 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -65,18 +65,8 @@ struct WetnessEffects : Feature PerFrame GetCommonBufferData(); - bool requiresUpdate = true; - float wetnessDepth = 0.0f; - float puddleDepth = 0.0f; - float lastGameTimeValue = 0.0f; - uint32_t currentWeatherID = 0; - uint32_t lastWeatherID = 0; - float previousWeatherTransitionPercentage = 0.0f; - virtual void Prepass() override; - virtual void Reset() override; - virtual void DrawSettings() override; virtual void LoadSettings(json& o_json) override; From 9b8f813d5c2a27fc94367241f0cfc5bc1803409f Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 02:01:10 +0000 Subject: [PATCH 14/27] chore: further bias puddles --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 7ade10063c..d99ea5c28f 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -229,7 +229,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); - puddleLastWeather = sqrt(1.0f - sky->currentWeatherPct); + puddleLastWeather = pow(1.0f - sky->currentWeatherPct, 0.25f); } data.Wetness = wetnessCurrentWeather + wetnessLastWeather; From 96f6a631ae82d73822e12ad1a903817e53b75689 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 02:12:23 +0000 Subject: [PATCH 15/27] fix: correct conversion --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index d99ea5c28f..10dedf8526 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -221,7 +221,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() float wetnessCurrentWeather = 0.0f; if (sky->currentWeather && sky->currentWeather->precipitationData && sky->currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - wetnessCurrentWeather = linearstep(abs((float)sky->currentWeather->data.precipitationBeginFadeIn), 255, sky->currentWeatherPct * 255); + wetnessCurrentWeather = linearstep(255.0f + (float)sky->currentWeather->data.precipitationBeginFadeIn, 255, sky->currentWeatherPct * 255); } float wetnessLastWeather = 0.0f; From bf5d585dc4149419fd62b8351a18f2d23475391c Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 02:21:21 +0000 Subject: [PATCH 16/27] chore: more fixes --- src/Features/WetnessEffects.cpp | 8 +++++--- src/Features/WetnessEffects.h | 4 ++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 10dedf8526..096cd702a9 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -228,12 +228,14 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() float puddleLastWeather = 0.0f; if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); + wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255)); puddleLastWeather = pow(1.0f - sky->currentWeatherPct, 0.25f); } - data.Wetness = wetnessCurrentWeather + wetnessLastWeather; - data.PuddleWetness = std::max(data.Wetness, puddleLastWeather) * settings.MaxPuddleWetness * 0.5f; + float wetness = std::min(1.0f, wetnessCurrentWeather + wetnessLastWeather); + + data.Wetness = wetness * settings.MaxRainWetness; + data.PuddleWetness = std::max(wetness, puddleLastWeather) * settings.MaxPuddleWetness; } } } diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index 9865142e63..f6117b4a16 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -22,8 +22,8 @@ struct WetnessEffects : Feature struct Settings { uint EnableWetnessEffects = true; - float MaxRainWetness = 0.75f; - float MaxPuddleWetness = 2.5f; + float MaxRainWetness = 1.0f; + float MaxPuddleWetness = 1.5f; float MaxShoreWetness = 0.5f; uint ShoreRange = 32; float PuddleRadius = 1.0f; From 85bdad5e8f271ad5958a446a2f7399fbd69f7d30 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 02:21:48 +0000 Subject: [PATCH 17/27] fix: bad bracket --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 096cd702a9..a475f54cfd 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -228,7 +228,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() float puddleLastWeather = 0.0f; if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { - wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255)); + wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); puddleLastWeather = pow(1.0f - sky->currentWeatherPct, 0.25f); } From 3241be8291f1ee15cb31c3a23e003d344f5d67e1 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 02:22:29 +0000 Subject: [PATCH 18/27] chore: clamp raining amount --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index a475f54cfd..d3a1e005e9 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -212,7 +212,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() } } - data.Raining = currentRaining + lastRaining; + data.Raining = std::min(1.0f, currentRaining + lastRaining); } auto linearstep = [](float edge0, float edge1, float x) { From 05f5eec73fec9dd7b7094ea820cea3c2a9e788ab Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 10:46:36 +0000 Subject: [PATCH 19/27] fix: wetness crash --- src/Features/WetnessEffects.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index d3a1e005e9..51582f28f8 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -182,7 +182,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() } } - if (precip->currentPrecip && sky->currentWeather->precipitationData) { + if (precip->currentPrecip && sky->currentWeather && sky->currentWeather->precipitationData) { auto& precipObject = precip->currentPrecip; auto weather = sky->currentWeather; @@ -197,7 +197,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() } } - if (precip->lastPrecip && sky->lastWeather->precipitationData) { + if (precip->lastPrecip && sky->lastWeather && sky->lastWeather->precipitationData) { auto& precipObject = precip->lastPrecip; auto weather = sky->lastWeather; From 78ef50ed21d4b4fd6b37d3244ec373ffb3e198af Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 10:51:17 +0000 Subject: [PATCH 20/27] fix: padding --- package/Shaders/Common/SharedData.hlsli | 1 - 1 file changed, 1 deletion(-) diff --git a/package/Shaders/Common/SharedData.hlsli b/package/Shaders/Common/SharedData.hlsli index cafaea4f81..0acabc24a4 100644 --- a/package/Shaders/Common/SharedData.hlsli +++ b/package/Shaders/Common/SharedData.hlsli @@ -108,7 +108,6 @@ struct WetnessEffectsSettings float RippleBreadth; float RippleLifetimeRcp; - float pad0[3]; }; struct SkylightingSettings From f94b8a72082811e422368ce6e427e9af22e3efb2 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Thu, 14 Nov 2024 11:26:23 +0000 Subject: [PATCH 21/27] fix: bad settings --- src/Features/WetnessEffects.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 51582f28f8..ed422318f8 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -234,8 +234,8 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() float wetness = std::min(1.0f, wetnessCurrentWeather + wetnessLastWeather); - data.Wetness = wetness * settings.MaxRainWetness; - data.PuddleWetness = std::max(wetness, puddleLastWeather) * settings.MaxPuddleWetness; + data.Wetness = wetness; + data.PuddleWetness = std::max(wetness, puddleLastWeather); } } } @@ -251,8 +251,8 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() // Calculating some parameters on cpu data.settings.RaindropChance *= data.Raining; - data.settings.RaindropGridSize = 1.f / settings.RaindropGridSize; - data.settings.RaindropInterval = 1.f / settings.RaindropInterval; + data.settings.RaindropGridSize = 1.0f / settings.RaindropGridSize; + data.settings.RaindropInterval = 1.0f / settings.RaindropInterval; data.settings.RippleLifetime = settings.RaindropInterval / settings.RippleLifetime; return data; From f07277a41324fd317119e59cded26af64b8fbd7a Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Sat, 16 Nov 2024 04:43:17 +0000 Subject: [PATCH 22/27] chore: tweaked puddles buildup --- src/Features/WetnessEffects.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index ed422318f8..cf0fdfd54a 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -220,8 +220,11 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() }; float wetnessCurrentWeather = 0.0f; + float puddleCurrentWeather = 0.0f; + if (sky->currentWeather && sky->currentWeather->precipitationData && sky->currentWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessCurrentWeather = linearstep(255.0f + (float)sky->currentWeather->data.precipitationBeginFadeIn, 255, sky->currentWeatherPct * 255); + puddleCurrentWeather = pow(wetnessCurrentWeather, 2.0f); } float wetnessLastWeather = 0.0f; @@ -229,13 +232,14 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() if (sky->lastWeather && sky->lastWeather->precipitationData && sky->lastWeather->data.flags.any(RE::TESWeather::WeatherDataFlag::kRainy)) { wetnessLastWeather = 1.0f - linearstep((float)sky->lastWeather->data.precipitationEndFadeOut, 255, sky->currentWeatherPct * 255); - puddleLastWeather = pow(1.0f - sky->currentWeatherPct, 0.25f); + puddleLastWeather = pow(std::max(wetnessLastWeather, 1.0f - sky->currentWeatherPct), 0.25f); } float wetness = std::min(1.0f, wetnessCurrentWeather + wetnessLastWeather); + float puddleWetness = std::min(1.0f, puddleCurrentWeather + puddleLastWeather); data.Wetness = wetness; - data.PuddleWetness = std::max(wetness, puddleLastWeather); + data.PuddleWetness = puddleWetness; } } } From 0b14a6379b7dbb0123946f0607f78baa02e78ab3 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Sat, 16 Nov 2024 04:43:33 +0000 Subject: [PATCH 23/27] fix: puddle wetness default --- src/Features/WetnessEffects.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.h b/src/Features/WetnessEffects.h index f6117b4a16..34a5b25728 100644 --- a/src/Features/WetnessEffects.h +++ b/src/Features/WetnessEffects.h @@ -23,7 +23,7 @@ struct WetnessEffects : Feature { uint EnableWetnessEffects = true; float MaxRainWetness = 1.0f; - float MaxPuddleWetness = 1.5f; + float MaxPuddleWetness = 2.5f; float MaxShoreWetness = 0.5f; uint ShoreRange = 32; float PuddleRadius = 1.0f; From e877776ab6fae24ade2d98b1786db4033a2c3a33 Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Mon, 18 Nov 2024 19:10:23 +0000 Subject: [PATCH 24/27] fix: vr raindrops --- src/Features/WetnessEffects.cpp | 42 ++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 6 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index cf0fdfd54a..766363e838 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -153,6 +153,20 @@ void WetnessEffects::DrawSettings() ImGui::Spacing(); } +class BGSShaderParticleGeometryDataVR : public RE::TESForm +{ +public: + + struct SETTING_VALUE + { + RE::SETTING_VALUE value; + float pad0; + }; + + RE::BSTArray data; + RE::TESTexture particleTexture; +}; + WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() { PerFrame data{}; @@ -189,12 +203,21 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto& effect = precipObject->GetGeometryRuntimeData().properties[RE::BSGeometry::States::kEffect]; auto shaderProp = netimmerse_cast(effect.get()); auto particleShaderProperty = netimmerse_cast(shaderProp); + auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - currentRaining = rain->density / maxDensity; + if (REL::Module::IsVR()) { + auto precipitionData = (BGSShaderParticleGeometryDataVR*)weather->precipitationData; + auto maxDensity = precipitionData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].value.f; + if (maxDensity > 0.0f) + currentRaining = rain->density / maxDensity; + } else { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + currentRaining = rain->density / maxDensity; + } } + } if (precip->lastPrecip && sky->lastWeather && sky->lastWeather->precipitationData) { @@ -206,9 +229,16 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - lastRaining = rain->density / maxDensity; + if (REL::Module::IsVR()) { + auto precipitionData = (BGSShaderParticleGeometryDataVR*)weather->precipitationData; + auto maxDensity = precipitionData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].value.f; + if (maxDensity > 0.0f) + lastRaining = rain->density / maxDensity; + } else { + auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; + if (maxDensity > 0.0f) + lastRaining = rain->density / maxDensity; + } } } From a1f40d32a16b70f6717ff881a126c4f7c50e5ff7 Mon Sep 17 00:00:00 2001 From: doodlum Date: Mon, 18 Nov 2024 19:10:51 +0000 Subject: [PATCH 25/27] =?UTF-8?q?style:=20=F0=9F=8E=A8=20apply=20clang-for?= =?UTF-8?q?mat=20changes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Features/WetnessEffects.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 766363e838..4830c85298 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -156,7 +156,6 @@ void WetnessEffects::DrawSettings() class BGSShaderParticleGeometryDataVR : public RE::TESForm { public: - struct SETTING_VALUE { RE::SETTING_VALUE value; @@ -217,7 +216,6 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() currentRaining = rain->density / maxDensity; } } - } if (precip->lastPrecip && sky->lastWeather && sky->lastWeather->precipitationData) { From f423f57c29d91f459870ed2e4be99c0b1b26543a Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Mon, 18 Nov 2024 19:18:01 +0000 Subject: [PATCH 26/27] chore: fade out rain fx quicker --- src/Features/WetnessEffects.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 4830c85298..57b6ad5816 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -282,7 +282,7 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() data.settings.MaxShoreWetness = settings.EnableWetnessEffects ? settings.MaxShoreWetness : 0.0f; // Calculating some parameters on cpu - data.settings.RaindropChance *= data.Raining; + data.settings.RaindropChance *= data.Raining * data.Raining; data.settings.RaindropGridSize = 1.0f / settings.RaindropGridSize; data.settings.RaindropInterval = 1.0f / settings.RaindropInterval; data.settings.RippleLifetime = settings.RaindropInterval / settings.RippleLifetime; From 8a0b57b119eeea6a3181768e853196771611568b Mon Sep 17 00:00:00 2001 From: Tim <15017472+doodlum@users.noreply.github.com> Date: Mon, 18 Nov 2024 21:29:14 +0000 Subject: [PATCH 27/27] chore: update precipitationData access --- src/Features/WetnessEffects.cpp | 39 +++++---------------------------- 1 file changed, 6 insertions(+), 33 deletions(-) diff --git a/src/Features/WetnessEffects.cpp b/src/Features/WetnessEffects.cpp index 57b6ad5816..3b6944a004 100644 --- a/src/Features/WetnessEffects.cpp +++ b/src/Features/WetnessEffects.cpp @@ -153,19 +153,6 @@ void WetnessEffects::DrawSettings() ImGui::Spacing(); } -class BGSShaderParticleGeometryDataVR : public RE::TESForm -{ -public: - struct SETTING_VALUE - { - RE::SETTING_VALUE value; - float pad0; - }; - - RE::BSTArray data; - RE::TESTexture particleTexture; -}; - WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() { PerFrame data{}; @@ -205,16 +192,9 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - if (REL::Module::IsVR()) { - auto precipitionData = (BGSShaderParticleGeometryDataVR*)weather->precipitationData; - auto maxDensity = precipitionData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].value.f; - if (maxDensity > 0.0f) - currentRaining = rain->density / maxDensity; - } else { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - currentRaining = rain->density / maxDensity; - } + auto maxDensity = weather->precipitationData->GetSettingValue(RE::BGSShaderParticleGeometryData::DataID::kParticleDensity).f; + if (maxDensity > 0.0f) + currentRaining = rain->density / maxDensity; } } @@ -227,16 +207,9 @@ WetnessEffects::PerFrame WetnessEffects::GetCommonBufferData() auto particleShaderProperty = netimmerse_cast(shaderProp); auto rain = (RE::BSParticleShaderRainEmitter*)(particleShaderProperty->particleEmitter); if (rain->emitterType.any(RE::BSParticleShaderEmitter::EMITTER_TYPE::kRain)) { - if (REL::Module::IsVR()) { - auto precipitionData = (BGSShaderParticleGeometryDataVR*)weather->precipitationData; - auto maxDensity = precipitionData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].value.f; - if (maxDensity > 0.0f) - lastRaining = rain->density / maxDensity; - } else { - auto maxDensity = weather->precipitationData->data[(uint)RE::BGSShaderParticleGeometryData::DataID::kParticleDensity].f; - if (maxDensity > 0.0f) - lastRaining = rain->density / maxDensity; - } + auto maxDensity = weather->precipitationData->GetSettingValue(RE::BGSShaderParticleGeometryData::DataID::kParticleDensity).f; + if (maxDensity > 0.0f) + lastRaining = rain->density / maxDensity; } }