Merge branch 'REMIX-4725-bug-fixes' into 'main'

[REMIX-4725] Fix several component related issues

Closes REMIX-4725

See merge request lightspeedrtx/dxvk-remix-nv!1777

Author: MarkEHenderson

documentation/components/BoxProximity.md

@@ -1,6 +1,6 @@
 # Box Proximity
 
-Calculates the signed distance from a world position to a mesh's bounding box\. Positive values indicate the point is inside the bounding box\.  Note that the output is in object space\.
+Calculates the signed distance from a world position to a mesh's bounding box\. Positive values indicate the point is outside the bounding box\.  Note that the output is in object space\.
 
 ## Component Information
 
@@ -67,7 +67,7 @@ Underlying Type: `Uint32`
 
 ### Signed Distance
 
-Distance in object space to the nearest bounding box plane\. Positive when inside, negative when outside\.  Outputs \-FLT\_MAX when no valid bounding box is found\.
+Distance in object space to the nearest bounding box plane\. Positive when outside, negative when inside\.  Outputs FLT\_MAX when no valid bounding box is found\.
 
 
 ### Activation Strength

documentation/components/InterpolateFloat.md

@@ -1,6 +1,6 @@
 # Interpolate Float
 
-Interpolates a value from an input range to an output range with optional easing\. <br/>Combines normalization \(reverse LERP\), easing, and mapping \(LERP\) into a single component\. <br/><br/>Note input values outside of input range are valid, and that easing can lead to the output value being outside of the output range even when input is inside the input range\.<br/> Inverted ranges \(max < min\) are supported, but the results are undefined and may change without warning\.
+Interpolates a value from an input range to an output range with optional easing\. <br/>Combines normalization \(reverse LERP\), easing, and mapping \(LERP\) into a single component\. <br/><br/>Note input values outside of input range are valid, and that easing can lead to the output value being outside of the output range even when input is inside the input range\.<br/>Inverted input ranges \(Input Max < Input Min\) are supported \- the min/max will be swapped and the normalized value inverted\.
 
 ## Component Information
 

documentation/components/RtxOptionLayerAction.md

@@ -17,7 +17,7 @@ Controls an RtxOptionLayer by name, allowing dynamic enable/disable, strength ad
 | enabled | Enabled | Bool | Input | true | Yes | 
 | blendStrength | Blend Strength | Float | Input | 1\.0 | Yes | 
 | blendThreshold | Blend Threshold | Float | Input | 0\.1 | Yes | 
-| priority | Priority | Uint32 | Input | 100 | Yes | 
+| priority | Priority | Uint32 | Input | 10000 | Yes | 
 
 ### Config Path
 
@@ -56,8 +56,8 @@ The priority for the option layer\. Higher values are blended onto lower values\
 
 **Value Constraints:**
 
-- **Minimum Value:** 0
-- **Maximum Value:** 4294967195
+- **Minimum Value:** 101
+- **Maximum Value:** 4294967294
 
 ## State Properties
 

documentation/components/TextureHashChecker.md

@@ -1,6 +1,6 @@
 # Texture Hash Checker
 
-Checks if a specific hash was used for material replacement in the current frame\.
+Checks if a specific texture hash was used for material replacement in the current frame\.  This includes textures in all categories, including ignored textures\.
 
 ## Component Information
 

documentation/components/index.md

@@ -29,7 +29,7 @@ This documentation provides detailed information about all available components
 | [Camera](Camera.md) | Outputs current camera properties including position, orientation vectors, and projection parameters\.\.\. | 1 |
 | [Keyboard Input](KeyboardInput.md) | Checks the state of a keyboard key or key combination using the same format as RTX options\. | 1 |
 | [Mesh Hash Checker](MeshHashChecker.md) | Checks if a specific mesh hash was processed in the current frame\. | 1 |
-| [Texture Hash Checker](TextureHashChecker.md) | Checks if a specific hash was used for material replacement in the current frame\. | 1 |
+| [Texture Hash Checker](TextureHashChecker.md) | Checks if a specific texture hash was used for material replacement in the current frame\.  This incl\.\.\. | 1 |
 | [Time](Time.md) | Outputs the time in seconds since the component was created\. Can be paused and speed\-adjusted\. | 1 |
 
 ## Statistics

src/d3d9/d3d9_rtx.cpp

@@ -1062,6 +1062,15 @@ namespace dxvk {
     if (d3d9State().textures[firstStage]) {
       m_activeDrawCallState.setupCategoriesForTexture();
 
+      // Track the texture hash before checking if it should be ignored
+      // This ensures we track all textures sent by the game, not just the ones that are actually rendered.
+      const XXH64_hash_t textureHash = m_activeDrawCallState.materialData.getColorTexture().getImageHash();
+      if (textureHash != kEmptyHash) {
+        m_parent->EmitCs([textureHash](DxvkContext* ctx) {
+          static_cast<RtxContext*>(ctx)->getSceneManager().trackReplacementMaterialHash(textureHash);
+        });
+      }
+      
       // Check if an ignore texture is bound
       if (m_activeDrawCallState.getCategoryFlags().test(InstanceCategories::Ignore)) {
         return false;

src/dxvk/rtx_render/graph/components/box_proximity.h

@@ -48,14 +48,14 @@ namespace components {
 #define LIST_STATES(X)
 
 #define LIST_OUTPUTS(X) \
-  X(RtComponentPropertyType::Float, 0.0f, signedDistance, "Signed Distance", "Distance in object space to the nearest bounding box plane. Positive when inside, negative when outside.  Outputs -FLT_MAX when no valid bounding box is found.") \
+  X(RtComponentPropertyType::Float, 0.0f, signedDistance, "Signed Distance", "Distance in object space to the nearest bounding box plane. Positive when outside, negative when inside.  Outputs FLT_MAX when no valid bounding box is found.") \
   X(RtComponentPropertyType::Float, 0.0f, activationStrength, "Activation Strength", "Normalized 0-1 value: 0 when on bounding box surface, 1 when at max distance inside (with easing applied).")
 
 REMIX_COMPONENT( \
   /* the Component name */ BoxProximity, \
   /* the UI name */        "Box Proximity", \
   /* the UI categories */  "Sense", \
-  /* the doc string */     "Calculates the signed distance from a world position to a mesh's bounding box. Positive values indicate the point is inside the bounding box.  Note that the output is in object space.", \
+  /* the doc string */     "Calculates the signed distance from a world position to a mesh's bounding box. Positive values indicate the point is outside the bounding box.  Note that the output is in object space.", \
   /* the version number */ 1, \
   LIST_INPUTS, LIST_STATES, LIST_OUTPUTS);
 
@@ -64,7 +64,7 @@ REMIX_COMPONENT( \
 #undef LIST_OUTPUTS
 
 // Calculate signed distance from point to axis-aligned bounding box
-// Returns positive distance when inside the box, negative when outside
+// Returns positive distance when outside the box, negative when inside
 static float calculateSignedDistanceToAABB(const Vector3& point, const AxisAlignedBoundingBox& aabb) {
   // bounding box already validated in updateRange function
 
@@ -78,14 +78,14 @@ static float calculateSignedDistanceToAABB(const Vector3& point, const AxisAlign
   // If the point is inside the box, all distances are negative
   // The signed distance is the maximum (least negative) distance to any face
   if (distToFaces.x <= 0.0f && distToFaces.y <= 0.0f && distToFaces.z <= 0.0f) {
-    // Inside the box - return the distance to the nearest face (positive)
-    return -std::max(distToFaces.x, std::max(distToFaces.y, distToFaces.z));
+    // Inside the box - return the distance to the nearest face (negative)
+    return std::max(distToFaces.x, std::max(distToFaces.y, distToFaces.z));
   } else {
-    // Outside the box - return the distance to the nearest corner/edge/face (negative)
+    // Outside the box - return the distance to the nearest corner/edge/face (positive)
     // For points outside, we need the Euclidean distance to the nearest point on the box
     Vector3 clampedPoint = clamp(point, aabb.minPos, aabb.maxPos);
     Vector3 diff = point - clampedPoint;
-    return -length(diff);
+    return length(diff);
   }
 }
 
@@ -142,7 +142,7 @@ void BoxProximity::updateRange(const Rc<DxvkContext>& context, const size_t star
 
     if (unlikely(signedDistance == FLT_MAX)) {
       ONCE(Logger::err(str::format("BoxProximity: No valid bounding box found.")));
-      m_signedDistance[i] = -FLT_MAX;
+      m_signedDistance[i] = FLT_MAX;
       m_activationStrength[i] = 0.0f;
       continue;
     }

src/dxvk/rtx_render/graph/components/interpolate_float.h

@@ -53,7 +53,7 @@ REMIX_COMPONENT( \
     "\nCombines normalization (reverse LERP), easing, and mapping (LERP) into a single component. " \
     "\n\nNote input values outside of input range are valid, and that easing can lead to the output value being " \
     "outside of the output range even when input is inside the input range." \
-    "\n Inverted ranges (max < min) are supported, but the results are undefined and may change without warning.", \
+    "\nInverted input ranges (Input Max < Input Min) are supported - the min/max will be swapped and the normalized value inverted.", \
   /* the version number */ 1, \
   LIST_INPUTS, LIST_STATES, LIST_OUTPUTS);
 
@@ -65,14 +65,30 @@ void InterpolateFloat::updateRange(const Rc<DxvkContext>& context, const size_t
   for (size_t i = start; i < end; i++) {
     // Step 1: Normalize input value to 0-1 range (reverse LERP / float_to_strength)
     float normalizedValue = m_value[i];
-    if (m_inputMax[i] == m_inputMin[i]) {
+    bool shouldInvert = false;
+    
+    // Check if the range is inverted
+    float minVal = m_inputMin[i];
+    float maxVal = m_inputMax[i];
+    if (minVal > maxVal) {
+      // Swap min and max
+      std::swap(minVal, maxVal);
+      shouldInvert = true;
+    }
+    
+    if (maxVal == minVal) {
       ONCE(Logger::err(str::format("InterpolateFloat: Input Min and Input Max are the same. Setting normalized value to 0.0f. Input Min: ", m_inputMin[i], " Input Max: ", m_inputMax[i])));
       normalizedValue = 0.0f; // Avoid division by zero
     } else {
       if (m_clampInput[i]) {
-        normalizedValue = clamp(normalizedValue, m_inputMin[i], m_inputMax[i]);
+        normalizedValue = clamp(normalizedValue, minVal, maxVal);
+      }
+      normalizedValue = (normalizedValue - minVal) / (maxVal - minVal);
+      
+      // Invert normalized value if the range was inverted
+      if (shouldInvert) {
+        normalizedValue = 1.0f - normalizedValue;
       }
-      normalizedValue = (normalizedValue - m_inputMin[i]) / (m_inputMax[i] - m_inputMin[i]);
     }
 
     // cache in a const value to avoid double branch
@@ -99,4 +115,3 @@ void InterpolateFloat::updateRange(const Rc<DxvkContext>& context, const size_t
 
 }  // namespace components
 }  // namespace dxvk
-

src/dxvk/rtx_render/graph/components/rtx_option_layer_action.h

@@ -28,7 +28,9 @@
 namespace dxvk {
 namespace components {
 
-static constexpr uint32_t kMaxComponentRtxOptionLayerPriority = ::dxvk::RtxOptionLayer::s_runtimeOptionLayerPriority - ::dxvk::RtxOptionLayer::s_userOptionLayerOffset;
+static constexpr uint32_t kMaxComponentRtxOptionLayerPriority = dxvk::RtxOptionLayer::s_runtimeOptionLayerPriority - 1;
+static constexpr uint32_t kMinComponentRtxOptionLayerPriority = RtxOptionLayer::s_userOptionLayerOffset + 1;
+static constexpr uint32_t kDefaultComponentRtxOptionLayerPriority = 10000;
 
 
 #define LIST_INPUTS(X) \
@@ -38,7 +40,7 @@ static constexpr uint32_t kMaxComponentRtxOptionLayerPriority = ::dxvk::RtxOptio
       "\n\nLowest priority layer uses LERP to blend with default value, then each higher priority layer uses LERP to blend with the previous layer's result." \
       "\n\nIf multiple components control the same layer, the MAX blend strength will be used.", property.minValue = 0.0f, property.maxValue = 1.0f, property.optional = true) \
   X(RtComponentPropertyType::Float, 0.1f, blendThreshold, "Blend Threshold", "The blend threshold for non-float options (0.0 to 1.0). Non-float options are only applied when blend strength exceeds this threshold. If multiple components control the same layer, the MINIMUM blend threshold will be used.", property.minValue = 0.0f, property.maxValue = 1.0f, property.optional = true) \
-  X(RtComponentPropertyType::Uint32, 100, priority, "Priority", "The priority for the option layer. Higher values are blended onto lower values. Must be unique across all layers.", property.minValue = 0, property.maxValue = kMaxComponentRtxOptionLayerPriority, property.optional = true)
+  X(RtComponentPropertyType::Uint32, kDefaultComponentRtxOptionLayerPriority, priority, "Priority", "The priority for the option layer. Higher values are blended onto lower values. Must be unique across all layers.", property.minValue = RtxOptionLayer::s_userOptionLayerOffset + 1, property.maxValue = kMaxComponentRtxOptionLayerPriority, property.optional = true)
 
 #define LIST_STATES(X) \
   X(RtComponentPropertyType::Uint64, 0, cachedLayerPtr, "", "Cached pointer to the RtxOptionLayer (internal use).")
@@ -85,10 +87,15 @@ class RtxOptionLayerAction : public RtRegisteredComponentBatch<RtxOptionLayerAct
 #undef LIST_OUTPUTS
 
 void RtxOptionLayerAction::initializeInstance(const Rc<DxvkContext>& context, const size_t index) {
+  uint32_t priority = m_priority[index];
+  clamp(priority, kMinComponentRtxOptionLayerPriority, kMaxComponentRtxOptionLayerPriority);
+
+  // TODO if the priority is left unset, we need to automatically assign a priority.
+
   // Acquire layer through the manager
   const ::dxvk::RtxOptionLayer* layer = dxvk::RtxOptionLayerManager::acquireLayer(
     m_configPath[index],
-    m_priority[index],
+    priority,
     1.0f,  // Default blend strength (will be updated in updateRange)
     0.1f   // Default blend threshold (will be updated in updateRange)
   );
@@ -123,21 +130,20 @@ void RtxOptionLayerAction::updateRange(const Rc<DxvkContext>& context, const siz
     // Request enabled state for this frame
     // If multiple components control this layer, it will be enabled if ANY of them request it
     cachedLayer->requestEnabled(m_enabled[i]);
-    
-    // Request blend strength for this frame
-    // If multiple components control this layer, the MAX blend strength will be used
-    const float targetStrength = std::clamp(m_blendStrength[i], 0.0f, 1.0f);
-    cachedLayer->requestBlendStrength(targetStrength);
-    
-    // Request blend threshold for this frame
-    // If multiple components control this layer, the MIN blend threshold will be used
-    const float targetThreshold = std::clamp(m_blendThreshold[i], 0.0f, 1.0f);
-    cachedLayer->requestBlendThreshold(targetThreshold);
+
+    if (m_enabled[i]) {
+      // Request blend strength for this frame
+      // If multiple components control this layer, the MAX blend strength will be used
+      const float targetStrength = std::clamp(m_blendStrength[i], 0.0f, 1.0f);
+      cachedLayer->requestBlendStrength(targetStrength);
+      
+      // Request blend threshold for this frame
+      // If multiple components control this layer, the MIN blend threshold will be used
+      const float targetThreshold = std::clamp(m_blendThreshold[i], 0.0f, 1.0f);
+      cachedLayer->requestBlendThreshold(targetThreshold);
+    }
   }
 }
 
 }  // namespace components
 }  // namespace dxvk
-
-
-

src/dxvk/rtx_render/graph/components/texture_hash_checker.h

@@ -41,7 +41,7 @@ REMIX_COMPONENT( \
   /* the Component name */ TextureHashChecker, \
   /* the UI name */        "Texture Hash Checker", \
   /* the UI categories */  "Sense", \
-  /* the doc string */     "Checks if a specific hash was used for material replacement in the current frame.", \
+  /* the doc string */     "Checks if a specific texture hash was used for material replacement in the current frame.  This includes textures in all categories, including ignored textures.", \
   /* the version number */ 1, \
   LIST_INPUTS, LIST_STATES, LIST_OUTPUTS);
 
@@ -58,7 +58,7 @@ void TextureHashChecker::updateRange(const Rc<DxvkContext>& context, const size_
     const uint64_t targetHash = m_textureHash[i];
 
     // Check if the texture hash was used for material replacement this frame
-    uint32_t count = sceneManager.getMaterialHashUsageCount(targetHash);
+    uint32_t count = sceneManager.getReplacementMaterialHashUsageCount(targetHash);
     bool isUsed = count > 0;
 
     m_isUsed[i] = isUsed;