[REMIX-4116] make animated water with translucent materials work without a texture transform.

This is done by animating the primary texcoord and secondary normal sample using the Remix animation time.

Also makes animated water in translucent materials compatible with animated spritesheets.

Author: MarkEHenderson

RtxOptions.md

@@ -739,6 +739,10 @@ Tables below enumerate all the options and their defaults set by RTX Remix. Note
 |rtx.tonemappingMode|int|1|The tonemapping type to use, 0 for Global, 1 for Local \(Default\)\.<br>Global tonemapping tonemaps the image with respect to global parameters, usually based on statistics about the rendered image as a whole\.<br>Local tonemapping on the other hand uses more spatially\-local parameters determined by regions of the rendered image rather than the whole image\.<br>Local tonemapping can result in better preservation of highlights and shadows in scenes with high amounts of dynamic range whereas global tonemapping may have to comprimise between over or underexposure\.|
 |rtx.trackParticleObjects|bool|True|Track last frame's corresponding particle object\.|
 |rtx.translucentDecalAlbedoFactor|float|10|A global scale factor applied to the albedo of decals that are applied to a translucent base material, to make the decals more visible\.<br>This is generally needed as albedo values for decals may be fairly low when dealing with opaque surfaces, but the translucent diffuse layer requires a fairly high albedo value to result in an expected look\.<br>The need for this option could be avoided by simply authoring decals applied to translucent materials with a higher albedo to begin with, but sometimes applications may share decals between different material types\.|
+|rtx.translucentMaterial.animatedWaterEnable|bool|True|If enabled, draw calls in the AnimatedWater category and a translucent material will have their primary texcoordinates animated, and will also take a second sample from the normal map\.<br>Note that objects must be properly categorized as animated water to be rendered with this mode\.|
+|rtx.translucentMaterial.animatedWaterPrimaryNormalMotion|float2|0.05, 0.05|Velocity in UV space for the primary texture coordinate\.<br>This relies on Remix animation time, which will not respect any time warping performed by the game \(so pause, slow mo, etc will not change animation speed\)\.|
+|rtx.translucentMaterial.animatedWaterSecondaryNormalLodBias|float|1|LoD bias to use when taking the second normal map sample\.<br>Values greater than 0 will cause the secondary normal map to be blurred, resulting in lower frequency waves\.|
+|rtx.translucentMaterial.animatedWaterSecondaryNormalMotion|float2|-0.03, -0.06|Velocity in UV space for the secondary texture coordinate\.<br>This relies on Remix animation time, which will not respect any time warping performed by the game \(so pause, slow mo, etc will not change animation speed\)\.|
 |rtx.translucentMaterial.enableDiffuseLayerOverride|bool|False|A flag to force the diffuse layer on the translucent material to be enabled\. Should only be used for debugging or development\.|
 |rtx.translucentMaterial.normalIntensity|float|1|An arbitrary strength scale factor to apply when decoding normals in the translucent material\. Should only be used for debugging or development\.|
 |rtx.translucentMaterial.transmittanceColorBias|float|0|A bias factor to add to all transmittance color values in the opaque material\. Should only be used for debugging or development\.|

src/dxvk/imgui/dxvk_imgui.cpp

@@ -680,9 +680,10 @@ namespace dxvk {
           ImGui::SliderFloat("Roughness Bias", &opaqueMaterialOptions.roughnessBiasObject(), -1.0f, 1.f, "%.3f", sliderFlags);
           ImGui::SliderFloat("Normal Strength##1", &opaqueMaterialOptions.normalIntensityObject(), -10.0f, 10.f, "%.3f", sliderFlags);
 
-          ImGui::Checkbox("Enable dual-layer animated water normal", &opaqueMaterialOptions.layeredWaterNormalEnableObject());
+          ImGui::Checkbox("Enable dual-layer animated water normal for Opaque", &opaqueMaterialOptions.layeredWaterNormalEnableObject());
 
           if (opaqueMaterialOptions.layeredWaterNormalEnable()) {
+            ImGui::TextWrapped("Animated water with Opaque material is dependent on the original draw call animating using a texture transform.");
             ImGui::SliderFloat2("Layered Motion Direction", &opaqueMaterialOptions.layeredWaterNormalMotionObject(), -1.0f, 1.0f, "%.3f", sliderFlags);
             ImGui::SliderFloat("Layered Motion Scale", &opaqueMaterialOptions.layeredWaterNormalMotionScaleObject(), -10.0f, 10.0f, "%.3f", sliderFlags);
             ImGui::SliderFloat("LOD bias", &opaqueMaterialOptions.layeredWaterNormalLodBiasObject(), 0.0f, 16.0f, "%.3f", sliderFlags);
@@ -699,6 +700,14 @@ namespace dxvk {
           ImGui::SliderFloat("Transmit. Color Bias", &translucentMaterialOptions.transmittanceColorBiasObject(), -1.0f, 1.f, "%.3f", sliderFlags);
           ImGui::SliderFloat("Normal Strength##2", &translucentMaterialOptions.normalIntensityObject(), -10.0f, 10.f, "%.3f", sliderFlags);
 
+          ImGui::Checkbox("Enable dual-layer animated water normal for Translucent", &translucentMaterialOptions.animatedWaterEnableObject());
+          if (translucentMaterialOptions.animatedWaterEnable()) {
+            ImGui::TextWrapped("Animated water with Translucent materials will animate using Remix animation time.");
+
+            ImGui::SliderFloat2("Primary Texcoord Velocity", &translucentMaterialOptions.animatedWaterPrimaryNormalMotionObject(), -0.5f, 0.5f, "%.3f", sliderFlags);
+            ImGui::SliderFloat2("Secondary Normal Texcoord Velocity", &translucentMaterialOptions.animatedWaterSecondaryNormalMotionObject(), -0.5f, 0.5f, "%.3f", sliderFlags);
+            ImGui::SliderFloat("Secondary Normal LOD bias", &translucentMaterialOptions.animatedWaterSecondaryNormalLodBiasObject(), 0.0f, 16.0f, "%.3f", sliderFlags);
+          }
           ImGui::Unindent();
         }
 

src/dxvk/rtx_render/rtx_context.cpp

@@ -1193,7 +1193,7 @@ namespace dxvk {
     // at the 24 bit boundary (as we use a 8 bit scalar on top of this time which we want to fit into 32 bits without issues,
     // plus we also convert this value to a floating point value at some point as well which has 23 bits of precision).
     // Bitwise and used rather than modulus as well for slightly better performance.
-    constants.timeSinceStartMS = static_cast<uint32_t>(getSceneManager().getGameTimeSinceStartMS()) & ((1U << 24U) - 1U);
+    constants.timeSinceStartSeconds = (static_cast<uint32_t>(getSceneManager().getGameTimeSinceStartMS()) & ((1U << 24U) - 1U)) / 1000.f;
 
     m_common->metaRtxdiRayQuery().setRaytraceArgs(rtOutput);
     getSceneManager().getLightManager().setRaytraceArgs(

src/dxvk/rtx_render/rtx_materials.h

@@ -219,8 +219,9 @@ struct RtSurface {
 
     std::uint32_t textureSpritesheetData = 0;
 
-    textureSpritesheetData |= (static_cast<uint32_t>(spriteSheetRows) << 0);
-    textureSpritesheetData |= (static_cast<uint32_t>(spriteSheetCols) << 8);
+    // Clamp rows and cols to at least 1, to avoid divide by 0 errors.
+    textureSpritesheetData |= (static_cast<uint32_t>(std::max<uint8_t>(1, spriteSheetRows)) << 0);
+    textureSpritesheetData |= (static_cast<uint32_t>(std::max<uint8_t>(1, spriteSheetCols)) << 8);
     textureSpritesheetData |= (static_cast<uint32_t>(spriteSheetFPS) << 16);
     // pack decalSortOrder into data13.x's last 8 bits.
     textureSpritesheetData |= (static_cast<uint32_t>(decalSortOrder) << 24);

src/dxvk/shaders/rtx/algorithm/geometry_resolver.slangh

@@ -732,7 +732,7 @@ void geometryResolverVertexOutputDebugView(
   case DEBUG_VIEW_VALUE_NOISE:
     // Some test values to produce validation view
     float3 pos = surfaceInteraction.position * 0.1f;
-    float time = cb.timeSinceStartMS * 0.001f;
+    float time = cb.timeSinceStartSeconds;
     if(cb.debugKnob.x <= 1.f)
     {
       const float noise = valueNoise4D(float4(pos, time));

src/dxvk/shaders/rtx/concept/surface/surface_interaction.slangh

@@ -152,7 +152,7 @@ void calcSpriteSheetAdjustment(
   inout vec2 textureCoordinates,
   inout vec2 textureGradientX,
   inout vec2 textureGradientY,
-  uint32_t timeSinceStartMS,
+  float timeSinceStartSeconds,
   uint8_t spriteSheetRows,
   uint8_t spriteSheetCols,
   uint8_t spriteSheetFPS)
@@ -162,19 +162,37 @@ void calcSpriteSheetAdjustment(
   {
     return;
   }
-
-  const uint numSprites = spriteSheetCols * spriteSheetRows;
-  // Note: timeSinceStartMS is clamped to 2^24 - 1 on the CPU side so this multiplication shouldn't overflow.
-  const uint frame = ((timeSinceStartMS * spriteSheetFPS) / 1000) % numSprites;
-
-  const vec2 uvSize = vec2(1.0f / spriteSheetCols, 1.0f / spriteSheetRows);
-  const vec2 uvBias = vec2(frame % spriteSheetCols, frame / spriteSheetCols) * uvSize;
+  vec2 uvSize, uvBias;
+  calcSpritesheetValues(
+    timeSinceStartSeconds,
+    spriteSheetRows,
+    spriteSheetCols,
+    spriteSheetFPS,
+    uvSize,
+    uvBias);
 
   textureCoordinates = uvBias + frac(textureCoordinates) * uvSize;
   textureGradientX *= uvSize;
   textureGradientY *= uvSize;
 }
 
+void calcSpritesheetValues(
+  float timeSinceStartSeconds,
+  uint8_t spriteSheetRows,
+  uint8_t spriteSheetCols,
+  uint8_t spriteSheetFPS,
+  inout vec2 uvSize,
+  inout vec2 uvBias
+)
+{
+  const uint numSprites = spriteSheetCols * spriteSheetRows;
+  // Note: timeSinceStartSeconds is clamped to (2^24 - 1) / 1000 on the CPU side so this multiplication shouldn't overflow.
+  const uint frame = (uint(timeSinceStartSeconds * spriteSheetFPS)) % numSprites;
+
+  uvSize = vec2(1.0f / spriteSheetCols, 1.0f / spriteSheetRows);
+  uvBias = vec2(frame % spriteSheetCols, frame / spriteSheetCols) * uvSize;
+}
+
 SurfaceInteraction surfaceInteractionCreate<let GenerateTangents : bool>(
   Surface surface, RayInteraction rayInteraction, Ray ray,
   bool usePreviousPositions = false, uint footprintMode = kFootprintFromRayDirection)
@@ -581,7 +599,7 @@ SurfaceInteraction surfaceInteractionCreate<let GenerateTangents : bool>(
       surfaceInteraction.textureCoordinates,
       surfaceInteraction.textureGradientX,
       surfaceInteraction.textureGradientY,
-      cb.timeSinceStartMS,
+      cb.timeSinceStartSeconds,
       surface.spriteSheetRows,
       surface.spriteSheetCols,
       surface.spriteSheetFPS);

src/dxvk/shaders/rtx/concept/surface_material/ray_portal_surface_material_interaction.slangh

@@ -30,7 +30,7 @@ bool rayPortalSurfaceMaterialInteractionSpriteSheetReadHelper(
   uint16_t samplerIndex,
   bool textureGammaCorrect,
   SurfaceInteraction surfaceInteraction,
-  uint32_t timeSinceStartMS,
+  float timeSinceStartSeconds,
   uint8_t spriteSheetRows,
   uint8_t spriteSheetCols,
   uint8_t spriteSheetFPS,
@@ -45,10 +45,8 @@ bool rayPortalSurfaceMaterialInteractionSpriteSheetReadHelper(
 
   // Note: No early out for spriteSheetFPS == 0 case because Ray Portals will commonly use animated textures.
 
-  const float timeSinceStartSecs = timeSinceStartMS * 0.001f;
-
   // Some constant to slow down, and a unique direction for opposing Portals
-  const float t = float(rotationSpeed) * timeSinceStartSecs;
+  const float t = float(rotationSpeed) * timeSinceStartSeconds;
   const float2x2 rot = float2x2(cos(t), -sin(t), sin(t), cos(t));
 
   vec2 originalCoord = surfaceInteraction.textureCoordinates;
@@ -60,7 +58,7 @@ bool rayPortalSurfaceMaterialInteractionSpriteSheetReadHelper(
   originalCoord = saturate(originalCoord);
 
   const uint numSprites = (spriteSheetCols * spriteSheetRows);
-  const float frameWithFraction = (timeSinceStartSecs * spriteSheetFPS) % numSprites;
+  const float frameWithFraction = (timeSinceStartSeconds * spriteSheetFPS) % numSprites;
   uint frame = floor(frameWithFraction);
   const float frameFraction = frac(frameWithFraction);
   const vec2 uvSize = vec2(1.0f / spriteSheetCols, 1.0f / spriteSheetRows);
@@ -113,7 +111,7 @@ RayPortalSurfaceMaterialInteraction rayPortalSurfaceMaterialInteractionCreate(
     rayPortalSurfaceMaterial.samplerIndex,
     true,
     surfaceInteraction,
-    cb.timeSinceStartMS,
+    cb.timeSinceStartSeconds,
     surface.spriteSheetRows,
     surface.spriteSheetCols,
     surface.spriteSheetFPS,

src/dxvk/shaders/rtx/concept/surface_material/translucent_surface_material_interaction.slangh

@@ -40,7 +40,7 @@ float16_t translucentSurfaceMaterialInteractionGetThinWallThickness(
 TranslucentSurfaceMaterialInteraction translucentSurfaceMaterialInteractionCreate(
   TranslucentSurfaceMaterial translucentSurfaceMaterial,
   Surface surface,
-  SurfaceInteraction surfaceInteraction,
+  inout SurfaceInteraction surfaceInteraction,
   MinimalRayInteraction minimalRayInteraction)
 {
   TranslucentSurfaceMaterialInteraction translucentSurfaceMaterialInteraction;
@@ -52,31 +52,41 @@ TranslucentSurfaceMaterialInteraction translucentSurfaceMaterialInteractionCreat
   f16vec4 transmittanceOrDiffuseSample;
   f16vec4 emissiveColorSample;
 
+  bool secondNormalLoaded = false;
+  if (cb.translucentMaterialArgs.animatedWaterEnable && surface.isAnimatedWater)
+  {
+    vec2 uvSize, uvBias;
+    calcSpritesheetValues(
+      cb.timeSinceStartSeconds,
+      surface.spriteSheetRows,
+      surface.spriteSheetCols,
+      surface.spriteSheetFPS,
+      uvSize,
+      uvBias);
+
+    // The UV as it was before applying a spritesheet (in 0-1 space).
+    const vec2 uvPreSpritesheet = frac(surfaceInteraction.textureCoordinates * vec2(surface.spriteSheetCols, surface.spriteSheetRows));
+
+    // The texcoords with primary motion applied, put back into spritesheet space.
+    const vec2 primaryUV = uvBias + uvSize *(frac(uvPreSpritesheet + cb.timeSinceStartSeconds * cb.translucentMaterialArgs.animatedWaterPrimaryNormalMotion));
+
+    // Take a second sample before taking the primary, so that we don't have to keep the secondary UV around.
+    // Use a lod bias now and a different texcoord velocity to make it a second 'layer' of normals.
+    const vec2 secondaryUV = uvBias + uvSize *(frac(uvPreSpritesheet + cb.timeSinceStartSeconds * cb.translucentMaterialArgs.animatedWaterSecondaryNormalMotion));
+    const float lodBias = cb.translucentMaterialArgs.animatedWaterSecondaryNormalLodBias;
+
+    surfaceInteraction.textureCoordinates = secondaryUV;;
+    secondNormalLoaded = surfaceMaterialInteractionTextureReadHelper(translucentSurfaceMaterial.normalTextureIndex, translucentSurfaceMaterial.samplerIndex, surfaceInteraction, secondNormalSample, lodBias);
+    surfaceInteraction.textureCoordinates = primaryUV;
+  }
+
   const bool normalLoaded = surfaceMaterialInteractionTextureReadHelper(translucentSurfaceMaterial.normalTextureIndex, translucentSurfaceMaterial.samplerIndex, surfaceInteraction, normalSample);
   // Note: Premultiplied alpha should really be used here for the transmittance or diffuse color as without it "transparent" regions of the texture in the diffuse color case for
   // example may cause incorrect coloration on the edges of more opaque regions due to texture filtering. This is hard to ensure on the art pipeline side of things however.
   const bool transmittanceOrDiffuseLoaded = surfaceMaterialInteractionTextureReadHelper(translucentSurfaceMaterial.transmittanceOrDiffuseTextureIndex, translucentSurfaceMaterial.samplerIndex, surfaceInteraction, transmittanceOrDiffuseSample);
   const bool emissiveColorLoaded = surfaceMaterialInteractionTextureReadHelper(translucentSurfaceMaterial.emissiveColorTextureIndex, translucentSurfaceMaterial.samplerIndex, surfaceInteraction, emissiveColorSample);
 
-  bool secondNormalLoaded = false;
-  if (cb.opaqueMaterialArgs.layeredWaterNormalEnable && surface.isAnimatedWater)
-  {
-    // take a second sample from a higher LOD using a modified texture xform
-    const vec2 motionScale = vec2(cb.opaqueMaterialArgs.layeredWaterNormalMotionX, cb.opaqueMaterialArgs.layeredWaterNormalMotionY) * cb.opaqueMaterialArgs.layeredWaterNormalMotionScale;
-    const float lodBias = cb.opaqueMaterialArgs.layeredWaterNormalLodBias;
-
-    mat4x2 xform = surface.textureTransform;
-    xform[0][2] *= motionScale.x;
-    xform[1][2] *= motionScale.y;
-
-    vec2 savedCoordinates = surfaceInteraction.textureCoordinates;
-    surfaceInteraction.textureCoordinates = mul(xform, float4(surfaceInteraction.textureCoordinates, 0.f, 1.f)).xy;
-    secondNormalLoaded = surfaceMaterialInteractionTextureReadHelper(translucentSurfaceMaterial.normalTextureIndex, translucentSurfaceMaterial.samplerIndex, surfaceInteraction, secondNormalSample, lodBias);
-    surfaceInteraction.textureCoordinates = savedCoordinates;
-  }
-
   // Create a tangent to world space matrix for future calculations
-
   const f16mat3 tangentToWorld = transpose(f16mat3(surfaceInteraction.interpolatedTangent, surfaceInteraction.interpolatedBitangent, surfaceInteraction.interpolatedNormal));
 
   // Load Normal

src/dxvk/shaders/rtx/pass/material_args.h

@@ -51,6 +51,12 @@ struct TranslucentMaterialArgs {
   float transmittanceColorBias = 0.f;
   float normalIntensity = 1.f;
   uint enableDiffuseLayerOverride = 0;
+  vec2 animatedWaterPrimaryNormalMotion = vec2(0.f, 0.f);
+  vec2 animatedWaterSecondaryNormalMotion = vec2(0.f, 0.f);
+  float animatedWaterSecondaryNormalLodBias = 0.f;
+  uint animatedWaterEnable = 0;
+  uint pad0 = 0;
+  uint pad1 = 0;
 };
 
 #ifdef __cplusplus
@@ -130,6 +136,19 @@ struct TranslucentMaterialOptions {
   RTX_OPTION("rtx.translucentMaterial", float, transmittanceColorBias, 0.0f, "A bias factor to add to all transmittance color values in the opaque material. Should only be used for debugging or development.");
   RTX_OPTION("rtx.translucentMaterial", float, normalIntensity, 1.0f, "An arbitrary strength scale factor to apply when decoding normals in the translucent material. Should only be used for debugging or development.");
 
+  // Animated Water
+  RTX_OPTION("rtx.translucentMaterial", Vector2, animatedWaterPrimaryNormalMotion, Vector2(0.05f, 0.05f),
+             "Velocity in UV space for the primary texture coordinate.\n"
+             "This relies on Remix animation time, which will not respect any time warping performed by the game (so pause, slow mo, etc will not change animation speed).");
+  RTX_OPTION("rtx.translucentMaterial", Vector2, animatedWaterSecondaryNormalMotion, Vector2(-0.03f, -0.06f),
+             "Velocity in UV space for the secondary texture coordinate.\n"
+             "This relies on Remix animation time, which will not respect any time warping performed by the game (so pause, slow mo, etc will not change animation speed).");
+  RTX_OPTION("rtx.translucentMaterial", float, animatedWaterSecondaryNormalLodBias, 1.0f,
+             "LoD bias to use when taking the second normal map sample.\n"
+             "Values greater than 0 will cause the secondary normal map to be blurred, resulting in lower frequency waves.");
+  RTX_OPTION("rtx.translucentMaterial", bool, animatedWaterEnable, true,
+             "If enabled, draw calls in the AnimatedWater category and a translucent material will have their primary texcoordinates animated, and will also take a second sample from the normal map.\n"
+             "Note that objects must be properly categorized as animated water to be rendered with this mode.");
   // Overrides
 
   RTX_OPTION("rtx.translucentMaterial", bool, enableDiffuseLayerOverride, false, "A flag to force the diffuse layer on the translucent material to be enabled. Should only be used for debugging or development.");
@@ -139,6 +158,10 @@ struct TranslucentMaterialOptions {
     args.transmittanceColorScale = transmittanceColorScale();
     args.transmittanceColorBias = transmittanceColorBias();
     args.normalIntensity = normalIntensity();
+    args.animatedWaterPrimaryNormalMotion = animatedWaterPrimaryNormalMotion();
+    args.animatedWaterSecondaryNormalMotion = animatedWaterSecondaryNormalMotion();
+    args.animatedWaterSecondaryNormalLodBias = animatedWaterSecondaryNormalLodBias();
+    args.animatedWaterEnable = animatedWaterEnable();
     args.enableDiffuseLayerOverride = enableDiffuseLayerOverride();
   }
 };

src/dxvk/shaders/rtx/pass/raytrace_args.h

@@ -227,7 +227,7 @@ struct RaytraceArgs {
   uint16_t translucentTransmissionLobeSamplingProbabilityZeroThreshold;
   uint16_t minTranslucentTransmissionLobeSamplingProbability;
   float roughnessDemodulationOffset;
-  uint timeSinceStartMS;
+  float timeSinceStartSeconds;
 
   uint enableCalculateVirtualShadingNormals;
   uint enableDirectLighting;