Merge branch 'LogicSchemaUpdate1.3' into 'release/v1.3'

[REMIX-4865] [REMIX-4839] Prevent component connections with invalid resolved types

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

Author: nsubtil

src/dxvk/rtx_render/graph/rtx_graph_ogn_writer.cpp

@@ -1,48 +1,23 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
 import omni.graph.core as og
 
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.AddDatabase import AddDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class Add:
-    @staticmethod
-    def compute(_db: AddDatabase):
-        return True
+    # fmt: off
+    VALID_COMBINATIONS = [
+        {"inputs:a": og.Type(og.BaseDataType.FLOAT), "inputs:b": og.Type(og.BaseDataType.FLOAT), "outputs:sum": og.Type(og.BaseDataType.FLOAT)},
+        {"inputs:a": og.Type(og.BaseDataType.FLOAT, 2), "inputs:b": og.Type(og.BaseDataType.FLOAT, 2), "outputs:sum": og.Type(og.BaseDataType.FLOAT, 2)},
+        {"inputs:a": og.Type(og.BaseDataType.FLOAT, 3), "inputs:b": og.Type(og.BaseDataType.FLOAT, 3), "outputs:sum": og.Type(og.BaseDataType.FLOAT, 3)},
+        {"inputs:a": og.Type(og.BaseDataType.FLOAT, 4), "inputs:b": og.Type(og.BaseDataType.FLOAT, 4), "outputs:sum": og.Type(og.BaseDataType.FLOAT, 4)},
+    ]
+    # fmt: on
+
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: a=float, b=float, sum=float
-        # Combination 2: a=float[2], b=float[2], sum=float[2]
-        # Combination 3: a=float[3], b=float[3], sum=float[3]
-        # Combination 4: a=float[4], b=float[4], sum=float[4]
-
-        # Get attributes
-        input_a = node.get_attribute("inputs:a")
-        input_b = node.get_attribute("inputs:b")
-        output_sum = node.get_attribute("outputs:sum")
-
-        # Get current types of connected attributes
-        type_a = input_a.get_resolved_type()
-        type_b = input_b.get_resolved_type()
-
-        # Check all valid type combinations and resolve output types
-        if (type_a == og.Type(og.BaseDataType.FLOAT) and 
-            type_b == og.Type(og.BaseDataType.FLOAT)):
-            output_sum.set_resolved_type(og.Type(og.BaseDataType.FLOAT))
-        elif (type_a == og.Type(og.BaseDataType.FLOAT, 2) and 
-            type_b == og.Type(og.BaseDataType.FLOAT, 2)):
-            output_sum.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 2))
-        elif (type_a == og.Type(og.BaseDataType.FLOAT, 3) and 
-            type_b == og.Type(og.BaseDataType.FLOAT, 3)):
-            output_sum.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 3))
-        elif (type_a == og.Type(og.BaseDataType.FLOAT, 4) and 
-            type_b == og.Type(og.BaseDataType.FLOAT, 4)):
-            output_sum.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 4))
+        resolve_types(node, Add.VALID_COMBINATIONS)

src/ogn/lightspeed.trex.logic/Add.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.AngleToMeshDatabase import AngleToMeshDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class AngleToMesh:
-    @staticmethod
-    def compute(_db: AngleToMeshDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: angleDegrees=float, angleRadians=float, direction=float[3], directionToCentroid=float[3], target=target, worldPosition=float[3]
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/AngleToMesh.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.BetweenDatabase import BetweenDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class Between:
-    @staticmethod
-    def compute(_db: BetweenDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: maxValue=float, minValue=float, result=bool, value=float
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/Between.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.BoolAndDatabase import BoolAndDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class BoolAnd:
-    @staticmethod
-    def compute(_db: BoolAndDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: a=bool, b=bool, result=bool
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/BoolAnd.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.BoolNotDatabase import BoolNotDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class BoolNot:
-    @staticmethod
-    def compute(_db: BoolNotDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: input=bool, result=bool
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/BoolNot.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.BoolOrDatabase import BoolOrDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class BoolOr:
-    @staticmethod
-    def compute(_db: BoolOrDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: a=bool, b=bool, result=bool
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/BoolOr.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.CameraDatabase import CameraDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class Camera:
-    @staticmethod
-    def compute(_db: CameraDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: aspectRatio=float, farPlane=float, forward=float[3], fovDegrees=float, fovRadians=float, nearPlane=float, position=float[3], right=float[3], up=float[3]
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/Camera.py

@@ -1,22 +1,12 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import omni.graph.core as og
-
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.CeilDatabase import CeilDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class Ceil:
-    @staticmethod
-    def compute(_db: CeilDatabase):
-        return True
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: input=float, result=float
+        resolve_types(node, [])

src/ogn/lightspeed.trex.logic/Ceil.py

@@ -1,42 +1,23 @@
 # GENERATED FILE - DO NOT EDIT
 # This file is a stub for OmniGraph editor compatibility, and is not used by the Remix Runtime.
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
 import omni.graph.core as og
 
-if TYPE_CHECKING:
-    from lightspeed.trex.logic.ogn.ogn.ClampDatabase import ClampDatabase
+from lightspeed.trex.logic.ogn._impl.type_resolution import resolve_types, standard_compute, standard_initialize
 
 
 class Clamp:
-    @staticmethod
-    def compute(_db: ClampDatabase):
-        return True
+    # fmt: off
+    VALID_COMBINATIONS = [
+        {"inputs:value": og.Type(og.BaseDataType.FLOAT), "outputs:result": og.Type(og.BaseDataType.FLOAT)},
+        {"inputs:value": og.Type(og.BaseDataType.FLOAT, 2), "outputs:result": og.Type(og.BaseDataType.FLOAT, 2)},
+        {"inputs:value": og.Type(og.BaseDataType.FLOAT, 3), "outputs:result": og.Type(og.BaseDataType.FLOAT, 3)},
+        {"inputs:value": og.Type(og.BaseDataType.FLOAT, 4), "outputs:result": og.Type(og.BaseDataType.FLOAT, 4)},
+    ]
+    # fmt: on
+
+    compute = standard_compute
+    initialize = standard_initialize
 
     @staticmethod
     def on_connection_type_resolve(node) -> None:
-        """Resolve flexible types based on connected attribute types."""
-        # Valid type combinations for this component:
-        # Combination 1: maxValue=float, minValue=float, result=float, value=float
-        # Combination 2: maxValue=float, minValue=float, result=float[2], value=float[2]
-        # Combination 3: maxValue=float, minValue=float, result=float[3], value=float[3]
-        # Combination 4: maxValue=float, minValue=float, result=float[4], value=float[4]
-
-        # Get attributes
-        input_value = node.get_attribute("inputs:value")
-        output_result = node.get_attribute("outputs:result")
-
-        # Get current types of connected attributes
-        type_value = input_value.get_resolved_type()
-
-        # Check all valid type combinations and resolve output types
-        if (type_value == og.Type(og.BaseDataType.FLOAT)):
-            output_result.set_resolved_type(og.Type(og.BaseDataType.FLOAT))
-        elif (type_value == og.Type(og.BaseDataType.FLOAT, 2)):
-            output_result.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 2))
-        elif (type_value == og.Type(og.BaseDataType.FLOAT, 3)):
-            output_result.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 3))
-        elif (type_value == og.Type(og.BaseDataType.FLOAT, 4)):
-            output_result.set_resolved_type(og.Type(og.BaseDataType.FLOAT, 4))
+        resolve_types(node, Clamp.VALID_COMBINATIONS)