Merge branch 'flexibleTypes' into 'main'

[REMIX-4384] Supporting Flexible types in components

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

Author: MarkEHenderson

documentation/components/Interpolate.md

@@ -0,0 +1,108 @@
+# Interpolate
+
+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\.
+
+## Component Information
+
+- **Name:** `Interpolate`
+- **UI Name:** Interpolate
+- **Version:** 1
+- **Categories:** Transform
+
+## Input Properties
+
+| Property | Display Name | Type | IO Type | Default Value | Optional |
+|----------|--------------|------|---------|---------------|----------|
+| value | Value | Float | Input | 0\.0 | No | 
+| inputMin | Input Min | Float | Input | 0\.0 | No | 
+| inputMax | Input Max | Float | Input | 1\.0 | No | 
+| clampInput | Clamp Input | Bool | Input | false | Yes | 
+| easingType | Easing Type | Uint32 | Input | Linear | No | 
+| shouldReverse | Should Reverse | Bool | Input | false | Yes | 
+| outputMin | Output Min | NumberOrVector | Input | 0 | No | 
+| outputMax | Output Max | NumberOrVector | Input | 0 | No | 
+
+### Value
+
+The input value to interpolate\.
+
+
+### Input Min
+
+If \`Value\` equals \`Input Min\`, the output will be \`Output Min\`\.
+
+
+### Input Max
+
+If \`Value\` equals \`Input Max\`, the output will be \`Output Max\`\.
+
+
+### Clamp Input
+
+If true, \`value\` will be clamped to the input range\.
+
+
+### Easing Type
+
+The type of easing to apply\.
+
+Underlying Type: `Uint32`
+
+
+**Allowed Values:**
+
+- Linear (`Linear`): The float will have a constant velocity\. *(default)*
+- Cubic (`Cubic`): The float will change in a cubic curve over time\.
+- EaseIn (`EaseIn`): The float will start slow, then accelerate\.
+- EaseOut (`EaseOut`): The float will start fast, then decelerate\.
+- EaseInOut (`EaseInOut`): The float will start slow, accelerate, then decelerate\.
+- Sine (`Sine`): Smooth, natural motion using a sine wave\.
+- Exponential (`Exponential`): Dramatic acceleration effect\.
+- Bounce (`Bounce`): Bouncy, playful motion\.
+- Elastic (`Elastic`): Spring\-like motion\.
+
+### Should Reverse
+
+If true, the easing is applied backwards\. If \`Value\` is coming from a loopFloat component that is using \`pingpong\`, hook this up to \`isReversing\` from that component\.
+
+
+### Output Min
+
+What a \`Value\` of \`Input Min\` maps to\.
+
+
+### Output Max
+
+What a \`Value\` of \`Input Max\` maps to\.
+
+
+## Output Properties
+
+| Property | Display Name | Type | IO Type | Default Value | Optional |
+|----------|--------------|------|---------|---------------|----------|
+| interpolatedValue | Interpolated Value | NumberOrVector | Output | 0 | No | 
+
+### Interpolated Value
+
+The final interpolated value after applying input normalization, easing, and output mapping\.
+
+
+## Valid Type Combinations
+
+This component supports flexible types. The following type combinations are valid:
+
+| # | clampInput | easingType | inputMax | inputMin | interpolatedValue | outputMax | outputMin | shouldReverse | value |
+|---|---|---|---|---|---|---|---|---|---|
+| 1 | Bool | Uint32 | Float | Float | Float | Float | Float | Bool | Float |
+| 2 | Bool | Uint32 | Float | Float | Float2 | Float2 | Float2 | Bool | Float |
+| 3 | Bool | Uint32 | Float | Float | Float3 | Float3 | Float3 | Bool | Float |
+| 4 | Bool | Uint32 | Float | Float | Color4 | Color4 | Color4 | Bool | Float |
+
+**Note:** Float3 and Color3 both use the same underlying type (3-component vector). Color4 uses a 4-component vector.
+
+## Usage Notes
+
+This component is part of the RTX Remix graph system. It is intended for use in the Remix Toolkit and Runtime only.
+
+---
+[← Back to Component Index](index.md)

documentation/components/SphereLightOverride.md

@@ -1,40 +1,40 @@
-# Sphere Light
-
-Override the sphere light properties\.
-
-## Component Information
-
-- **Name:** `SphereLightOverride`
-- **UI Name:** Sphere Light
-- **Version:** 1
-- **Categories:** Act
-
-## Input Properties
-
-| Property | Display Name | Type | IO Type | Default Value | Optional |
-|----------|--------------|------|---------|---------------|----------|
-| enabled | Enabled | Bool | Input | true | Yes | 
-| radius | Radius | Float | Input | 0\.0 | Yes | 
-| target | Target | Prim | Input | None | No | 
-
-### Enabled
-
-If true, the overrides will be applied\.
-
-
-### Radius
-
-The radius of the sphere light\.
-
-
-### Target
-
-The sphere light to override\.
-
-
-## Usage Notes
-
-This component is part of the RTX Remix graph system. It is intended for use in the Remix Toolkit and Runtime only.
-
----
-[← Back to Component Index](index.md)
+# \[Non Functional\] Sphere Light
+
+Override the sphere light properties\.
+
+## Component Information
+
+- **Name:** `SphereLightOverride`
+- **UI Name:** \[Non Functional\] Sphere Light
+- **Version:** 1
+- **Categories:** Act
+
+## Input Properties
+
+| Property | Display Name | Type | IO Type | Default Value | Optional |
+|----------|--------------|------|---------|---------------|----------|
+| enabled | Enabled | Bool | Input | true | Yes | 
+| radius | Radius | Float | Input | 0\.0 | Yes | 
+| target | Target | Prim | Input | None | No | 
+
+### Enabled
+
+If true, the overrides will be applied\.
+
+
+### Radius
+
+The radius of the sphere light\.
+
+
+### Target
+
+The sphere light to override\.
+
+
+## Usage Notes
+
+This component is part of the RTX Remix graph system. It is intended for use in the Remix Toolkit and Runtime only.
+
+---
+[← Back to Component Index](index.md)

documentation/components/index.md

@@ -11,13 +11,14 @@ This documentation provides detailed information about all available components
 | Component | Description | Version |
 |-----------|-------------|---------|
 | [Rtx Option Layer Action](RtxOptionLayerAction.md) | Controls an RtxOptionLayer by name, allowing dynamic enable/disable, strength adjustment, and thresh\.\.\. | 1 |
-| [Sphere Light](SphereLightOverride.md) | Override the sphere light properties\. | 1 |
+| [\[Non Functional\] Sphere Light](SphereLightOverride.md) | Override the sphere light properties\. | 1 |
 
 ### Transform
 
 | Component | Description | Version |
 |-----------|-------------|---------|
 | [Animated Float](AnimatedFloat.md) | A single animated float value\. | 1 |
+| [Interpolate](Interpolate.md) | Interpolates a value from an input range to an output range with optional easing\. <br/>Combines normaliz\.\.\. | 1 |
 | [Interpolate Float](InterpolateFloat.md) | Interpolates a value from an input range to an output range with optional easing\. <br/>Combines normaliz\.\.\. | 1 |
 | [Loop Float](LoopFloat.md) | Applies looping behavior to a float value\.  Value is unchanged if it is inside the range\.<br/>Component \.\.\. | 1 |
 
@@ -34,8 +35,8 @@ This documentation provides detailed information about all available components
 
 ## Statistics
 
-- **Total Components:** 11
-- **Categorized Components:** 11
+- **Total Components:** 12
+- **Categorized Components:** 12
 - **Categories:** 3
 
 ---

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

@@ -73,7 +73,8 @@ inline const auto kInterpolationTypeEnumValues = RtComponentPropertySpec::EnumPr
 };
 
 // Apply interpolation/easing to a normalized time value (0-1)
-inline float applyInterpolation(InterpolationType interpolation, float time) {
+template<typename T>
+inline T applyInterpolation(InterpolationType interpolation, T time) {
   switch(interpolation) {
     case InterpolationType::Linear:
       return time;

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

@@ -0,0 +1,125 @@
+/*
+* Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+
+#pragma once
+
+#include "../rtx_graph_component_macros.h"
+#include "animation_utils.h"
+
+namespace dxvk {
+namespace components {
+
+#define LIST_INPUTS(X) \
+  X(RtComponentPropertyType::Float, 0.0f, value, "Value", "The input value to interpolate.") \
+  X(RtComponentPropertyType::Float, 0.0f, inputMin, "Input Min", "If `Value` equals `Input Min`, the output will be `Output Min`.") \
+  X(RtComponentPropertyType::Float, 1.0f, inputMax, "Input Max", "If `Value` equals `Input Max`, the output will be `Output Max`.") \
+  X(RtComponentPropertyType::Bool, false, clampInput, "Clamp Input", "If true, `value` will be clamped to the input range.", property.optional = true) \
+  X(RtComponentPropertyType::Uint32, static_cast<uint32_t>(InterpolationType::Linear), easingType, "Easing Type", \
+    "The type of easing to apply.", \
+    property.enumValues = kInterpolationTypeEnumValues) \
+  X(RtComponentPropertyType::Bool, false, shouldReverse, "Should Reverse", "If true, the easing is applied backwards. If `Value` is coming from a loopFloat component that is using `pingpong`, hook this up to `isReversing` from that component.", property.optional = true) \
+  X(RtComponentPropertyType::NumberOrVector, 0.0f, outputMin, "Output Min", "What a `Value` of `Input Min` maps to.") \
+  X(RtComponentPropertyType::NumberOrVector, 1.0f, outputMax, "Output Max", "What a `Value` of `Input Max` maps to.")
+
+#define LIST_STATES(X)
+
+#define LIST_OUTPUTS(X) \
+  X(RtComponentPropertyType::NumberOrVector, 0.0f, interpolatedValue, "Interpolated Value", "The final interpolated value after applying input normalization, easing, and output mapping.")
+
+// Manually declaring the class to allow for custom applySceneOverrides method
+template <RtComponentPropertyType rangePropertyType>
+class Interpolate : public RtRegisteredComponentBatch<Interpolate<rangePropertyType>> {
+private:
+  static constexpr RtComponentPropertyType valuePropertyType = RtComponentPropertyType::Float;
+  static constexpr RtComponentPropertyType inputMinPropertyType = RtComponentPropertyType::Float;
+  static constexpr RtComponentPropertyType inputMaxPropertyType = RtComponentPropertyType::Float;
+  static constexpr RtComponentPropertyType clampInputPropertyType = RtComponentPropertyType::Bool;
+  static constexpr RtComponentPropertyType easingTypePropertyType = RtComponentPropertyType::Uint32;
+  static constexpr RtComponentPropertyType shouldReversePropertyType = RtComponentPropertyType::Bool;
+  static constexpr RtComponentPropertyType outputMinPropertyType = rangePropertyType;
+  static constexpr RtComponentPropertyType outputMaxPropertyType = rangePropertyType;
+  static constexpr RtComponentPropertyType interpolatedValuePropertyType = rangePropertyType;
+  REMIX_COMPONENT_BODY(
+    /* the Component class name */ Interpolate,
+    /* the UI name */        "Interpolate",
+    /* the UI categories */  "Transform",
+    /* the doc string */     "Interpolates a value from an input range to an output range with optional easing. " \
+      "\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.",
+    /* the version number */ 1,
+    LIST_INPUTS, LIST_STATES, LIST_OUTPUTS
+  )
+  void Interpolate::updateRange(const Rc<DxvkContext>& context, const size_t start, const size_t end) {
+    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]) {
+        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 = (normalizedValue - m_inputMin[i]) / (m_inputMax[i] - m_inputMin[i]);
+      }
+      
+      // cache in a const value to avoid double branch
+      const bool shouldReverse = m_shouldReverse[i];
+  
+      // Step 2: Apply easing (ease component logic)
+      // If should reverse, flip the input value
+      if (shouldReverse) {
+        normalizedValue = 1.0f - normalizedValue;
+      }
+      
+      // Apply the easing
+      float easedValue = applyInterpolation(static_cast<InterpolationType>(m_easingType[i]), normalizedValue);
+      
+      // If should reverse, flip the output back
+      if (shouldReverse) {
+        easedValue = 1.0f - easedValue;
+      }
+      
+      // Step 3: Map eased value to output range (LERP / strength_to_float)
+      m_interpolatedValue[i] = lerp(m_outputMin[i], m_outputMax[i], easedValue);
+    }
+  }
+};
+
+#undef LIST_INPUTS
+#undef LIST_STATES
+#undef LIST_OUTPUTS
+
+
+namespace {
+  // Instantiate all of the typed variants we want to support.
+  template class Interpolate<RtComponentPropertyType::Float>;
+  template class Interpolate<RtComponentPropertyType::Float2>;
+  template class Interpolate<RtComponentPropertyType::Float3>;
+  template class Interpolate<RtComponentPropertyType::Color4>;
+}  // namespace
+
+}  // namespace components
+}  // namespace dxvk
+