Add SimReady package: standardbots_spark

.gitattributes

@@ -58,3 +58,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/configuration/spark_base.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/base_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/forearm_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/shoulder_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/upper_arm_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/wrist_1_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/wrist_2_link.usd filter=lfs diff=lfs merge=lfs -text
+standardbots_spark/spark/meshes/visual/wrist_3_link.usd filter=lfs diff=lfs merge=lfs -text

standardbots_spark/.metadata/com.nvidia.simready.conformance.Package@1.0.0.json

@@ -0,0 +1,35 @@
+{
+  "format_version": "1.0",
+  "profile": "Package",
+  "profile_version": "1.0.0",
+  "timestamp": "2026-10-09T16:40:18",
+  "assets": [
+    {
+      "asset": "com.nvidia.simready.packaging.json",
+      "features": [
+        {
+          "FET_030_STANDARD": {
+            "version": "0.1.0",
+            "passed": true,
+            "failing_requirements": [],
+            "dependencies": []
+          }
+        },
+        {
+          "FET_032_STANDARD": {
+            "version": "0.1.0",
+            "passed": true,
+            "failing_requirements": [],
+            "dependencies": [
+              {
+                "FET_030_STANDARD": {
+                  "version": "0.1.0"
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}

standardbots_spark/.metadata/com.nvidia.simready.packaging.bom.json

@@ -0,0 +1,213 @@
+{
+  "format_version": "1.0",
+  "items": [
+    {
+      "relative_path": "spark/.thumbs/256x256/standardbots_spark.usd.png",
+      "size": 13818,
+      "hash": {
+        "sha256-flat-1mb": "5254a042cd77e1f1e1c06d85ee8f4a10f8064e89507cd9f2d23242a98eeeb615",
+        "sha256": "9f806d3b80692847fea1233a642874d2b63bdd55835b3ac03e4e226b6132dd75"
+      }
+    },
+    {
+      "relative_path": "spark/.thumbs/256x256/standardbots_spark.usd_light.png",
+      "size": 14113,
+      "hash": {
+        "sha256-flat-1mb": "7db64fbaee38855e06d05944ca3eb47fa9d556ad0782542a46b6a6a3c210d920",
+        "sha256": "e6e5c0361e8e49497b06b091fbfe9ab2703fd4075450cfa41b2b04d370735062"
+      }
+    },
+    {
+      "relative_path": "spark/.thumbs/256x256/standardbots_spark.usd_transparent.png",
+      "size": 17330,
+      "hash": {
+        "sha256-flat-1mb": "a7311830c5dff0e1f99979ad7a1124a3de0f10d70fa39919f66e918d811f652b",
+        "sha256": "a73c49015dd5a2b70660f07603b5138ea5e5f422fbc5baad33d57339ef7f8d1e"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/OmniPBR/OmniPBR.mdl",
+      "size": 13989,
+      "hash": {
+        "sha256-flat-1mb": "4d0f54d47017bfbe22cc483cb02c4fe7e2254ddd1119cd618cbaea553639d52c",
+        "sha256": "d384fc800f120e3cad1b7ca8837f9c554f9c34343d194813fca27caa493001f2"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/OmniPBR/OmniPBRBase.mdl",
+      "size": 17274,
+      "hash": {
+        "sha256-flat-1mb": "4b54e7fb8bc92191512851b3acc6fc6fa9863f80d98ffece8f0cb9b99f5f4535",
+        "sha256": "701f37299b44106842bdbe025de52eedec391e35b038f61c4ed4d25bd98e7db1"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/OmniPBR/OmniPBR_ClearCoat.mdl",
+      "size": 27453,
+      "hash": {
+        "sha256-flat-1mb": "0e35217542eb4ece0205fc09f74eb71aaa6bfb75b3b861d64693d317282df424",
+        "sha256": "687fce3f0693146b91495f04407a7c38c78f6b9262b63621f44b4b1f09110469"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/spark_base.usd",
+      "size": 1924727,
+      "hash": {
+        "sha256-flat-1mb": "d555be5066c1349c1de663d34d495a0d4bff0af02265d13ca7e3a1a392038f47",
+        "sha256": "55baa19414ed45a233f398861ea78f49915f6a7f43b785bacf483b5dfd3cf008",
+        "sha256-first1m": "279999013aa8115204e1d70bfd7daa5c22eb85a39c42013dce76f514ad666c0b"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/spark_materials.usda",
+      "size": 5511,
+      "hash": {
+        "sha256-flat-1mb": "d818b9ee7cbad94043d8ede5ec9c369b246083e6bda3dfe3ddf365c3fb964632",
+        "sha256": "f2d07325b732db6bd87b2a0071a4dca2cb02ebf6106c641cd12695c834338368"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/spark_physics.usd",
+      "size": 4520,
+      "hash": {
+        "sha256-flat-1mb": "21f53a98fe7766c03cedf8c3fb0776efdb52517571349766a3aa6b0e99b37675",
+        "sha256": "a49941d84643b70046a92128da677afdb0a9227ffb2e1502c7bdb968c737850c"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/spark_sensor.usd",
+      "size": 645,
+      "hash": {
+        "sha256-flat-1mb": "704226d3d8e1cc625cec1d5475eca628a594a0af17e5b0e46781c6e9ca8eeb0d",
+        "sha256": "788b78a393765e01db8acca673f38b6c3388a65ca98e7979e7071b185c15186c"
+      }
+    },
+    {
+      "relative_path": "spark/configuration/spark_visual.usda",
+      "size": 32385,
+      "hash": {
+        "sha256-flat-1mb": "e09d9278e94a7741807658746f1e53a732bc80ba7c0e77f5ec4545f2b634c466",
+        "sha256": "3e97f7e3fd12abfe754b61e91b47fe9114c0f0da2bebb8e19568d32e4854767b"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/base_link.usd",
+      "size": 4456462,
+      "hash": {
+        "sha256-flat-1mb": "2e57e6bb0747b7b1b18e04d4143252ecd62a8cc081c11732652e5bd121a8a880",
+        "sha256": "64a1599e205750687d13b1504c21e26218f4423f7d366d79fbb809386d2d702e",
+        "sha256-first1m": "75a90d692daa7c4b508a9334db46538b96e795ce3e73781b9edb5c6e8b2bc315"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/forearm_link.usd",
+      "size": 11090641,
+      "hash": {
+        "sha256-flat-1mb": "39efd7a3d370f6716560bfbad1bad86a37f3a2049e6e4bcf3102f11f57688724",
+        "sha256": "ed00f891f0e17e32d1ee1a5f1d7a4b401532c2630e7c1e0d6f3548507d200a3f",
+        "sha256-first1m": "a9b03415d1d85726583c1292d7626db21c380126ff994ee7fd34ab59e5940006"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/gltf/pbr.mdl",
+      "size": 42240,
+      "hash": {
+        "sha256-flat-1mb": "0ea567c192a18e6835ba556207f797ebe90850414ac832952c61c571cff22a0d",
+        "sha256": "eeed10b53c18d789f94a24a3a6b996c49668ae2d5b6a909bae3420f2beb16fc8"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/shoulder_link.usd",
+      "size": 6258398,
+      "hash": {
+        "sha256-flat-1mb": "f5478184fef43041d20dec7280317710e92af72d6ca44f686d441d3d13806065",
+        "sha256": "68a67d936f0d1f7b1c7b84b254493d2203a7ac15fe884ce545d2c7f69b328941",
+        "sha256-first1m": "459e0f92490184c7ac1ca5476cf33115159d0bd3c9dfb46d0b73e6ae353ca0b9"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/upper_arm_link.usd",
+      "size": 13819892,
+      "hash": {
+        "sha256-flat-1mb": "e2286296132505585f9599a028834dec35e64b7e394348985128a35411645231",
+        "sha256": "e7e1250652e68a6d0a617c869feed986337d68d79602b7ed07541269af9a301e",
+        "sha256-first1m": "e4051b668ef10d4b84b6b22dfe2861d18a32accd5d4c63a7fa49774a33e4141d"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/wrist_1_link.usd",
+      "size": 4162675,
+      "hash": {
+        "sha256-flat-1mb": "cf60cc71f3f1d02560d439dda464b7bc2200e03be3ae6d9bc1831ae6d195de20",
+        "sha256": "8d3c3d8d1b7b51e3c8177036b85febda8c6de751261505f907f452f475780f87",
+        "sha256-first1m": "ca6869fc908d81b2eac2508e508197c00d2683d9fc321e38a8325eda8fd32c80"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/wrist_2_link.usd",
+      "size": 4162691,
+      "hash": {
+        "sha256-flat-1mb": "8ab096bd82b61bce05ea3d01e856701ce40c250a811f7b25d3952df1a544c38d",
+        "sha256": "3a0932e079527a4c80a3cd63f1fcf1ccaf9c71bc30a169be66b3c7aed81ce801",
+        "sha256-first1m": "5d865b8683fd56031bb9421b7f10292937bcc8d509ad0ed8ec0fa890996e71ee"
+      }
+    },
+    {
+      "relative_path": "spark/meshes/visual/wrist_3_link.usd",
+      "size": 4709471,
+      "hash": {
+        "sha256-flat-1mb": "5e3265bd891cc6be8e0c2841e5c3f7e7a45862a9430a5776caca0a183e236fe6",
+        "sha256": "676936b6939885e62810b632c4c384cbb36445dc95be27f3d32f20d68383f13e",
+        "sha256-first1m": "7c706e7460544118a7ffeb9c0ca70f18769123ca4fff06120b33af4c857a98da"
+      }
+    },
+    {
+      "relative_path": "spark/preview/spark_front.png",
+      "size": 133060,
+      "hash": {
+        "sha256-flat-1mb": "dfa5434047e1f47c71222288cac1678ade8d91895675193eda1dd3ae6ed48e66",
+        "sha256": "7647de5499ff1e3c1c1bfce351e94d144a5204344ea439fad503d1124a9b4249"
+      }
+    },
+    {
+      "relative_path": "spark/preview/spark_shoulder_detail.png",
+      "size": 371194,
+      "hash": {
+        "sha256-flat-1mb": "f4d2bbcec1695390a2aa063e03a2ba46439985c001bd655f4d85303ba64ecb18",
+        "sha256": "23a5c6ed787b5adb661c91ebf3ce0fd1e584a9205bf9bbd54ceb1624b51011f3"
+      }
+    },
+    {
+      "relative_path": "spark/preview/spark_side.png",
+      "size": 160551,
+      "hash": {
+        "sha256-flat-1mb": "b4d0de4c7ec3da3ddfefd9f51dff43c78b6a4b904b279ef4813a083abb5f446a",
+        "sha256": "091e6bfabd96072c4e4f20c952b16f7a3cc5ad66f59b1a6ca01c5fcc6c0f40a6"
+      }
+    },
+    {
+      "relative_path": "spark/preview/spark_three_quarter.png",
+      "size": 277504,
+      "hash": {
+        "sha256-flat-1mb": "4c8f7b44e8fffd3957e2622e4b5141f98039748dbc2c332b0f076decc5599f8e",
+        "sha256": "61e095145119f6fe1f3cad837790aa5da065c52081d84c1c48083cb9de3a0c25"
+      }
+    },
+    {
+      "relative_path": "spark/preview/spark_wrist_detail.png",
+      "size": 267612,
+      "hash": {
+        "sha256-flat-1mb": "a10d52565233b853a0df1c0d6f99634ddd62b183323b8b53755170378a669e60",
+        "sha256": "1da576bea6d7e7e548dea62da9bc722dfe49260ae352f3f7d4c1b079c80b3c65"
+      }
+    },
+    {
+      "relative_path": "spark/standardbots_spark.usd",
+      "size": 2555,
+      "hash": {
+        "sha256-flat-1mb": "36a922ab0e499ecd2c59900469ce15d4e803ad45bebd5ac2b83b5d4fbf95d4da",
+        "sha256": "6b4558f390fb173ac903b1a10695d17aa304c30792ede992e0e759e61ffc1ac3"
+      }
+    }
+  ]
+}

standardbots_spark/.metadata/standardbots_spark_validation.json

@@ -0,0 +1,242 @@
+{
+    "spark/standardbots_spark.usd": {
+        "features_summary": {
+            "FET_000_ISAAC": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_000_STANDARD': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.SR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_000_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_000_STANDARD': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.RV.007', 'com.nvidia.simready.SR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_000_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_000_STANDARD': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.RV.004', 'com.nvidia.simready.SR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_000_PHYSX": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_000_STANDARD': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.RV.001', 'com.nvidia.simready.SR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_000_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.SR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_001_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "1.0.1"
+            },
+            "FET_003_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.MUJOCO.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_003_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.NEWTON.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_003_PHYSX": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.4.0"
+            },
+            "FET_003_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_004_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_003_MUJOCO': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.MUJOCO.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_004_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_003_NEWTON': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.NEWTON.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_004_PHYSX": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_003_PHYSX': {'version': '0.4.0'}}]",
+                "passed": true,
+                "version": "0.4.0"
+            },
+            "FET_004_ROBOT_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.MUJOCO.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_004_ROBOT_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.NEWTON.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_004_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_003_STANDARD': {'version': '0.2.0'}}]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_006_MDL": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_006_OPENPBR": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.VM.PBR.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_006_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_010_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.DISP.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_021_ISAAC": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.3.0"
+            },
+            "FET_022_ISAAC": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_022_PHYSX': {'version': '0.2.0'}}]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_022_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_004_ROBOT_MUJOCO': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.MUJOCO.COL.001', 'com.nvidia.simready.MUJOCO.DJ.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_022_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_004_ROBOT_NEWTON': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.NEWTON.COL.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_022_PHYSX": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_004_PHYSX': {'version': '0.4.0'}}]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_022_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_004_STANDARD': {'version': '0.2.0'}}]",
+                "passed": true,
+                "version": "0.2.0"
+            },
+            "FET_023_ISAAC": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.1.0"
+            },
+            "FET_024_MUJOCO": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_024_STANDARD': {'version': '0.1.0'}}]",
+                "passed": true,
+                "version": "0.1.0"
+            },
+            "FET_024_NEWTON": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_024_STANDARD': {'version': '0.1.0'}}]",
+                "optional requirements": "['com.nvidia.simready.NEWTON.BA.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_024_PHYSX": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_024_STANDARD': {'version': '0.1.0'}}]",
+                "passed": true,
+                "version": "0.1.0"
+            },
+            "FET_024_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.1.0"
+            },
+            "FET_025_ROS": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "optional requirements": "['com.nvidia.simready.ROS.001']",
+                "passed": false,
+                "version": "0.1.0"
+            },
+            "FET_031_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[]",
+                "passed": true,
+                "version": "0.1.0"
+            },
+            "FET_033_STANDARD": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_031_STANDARD': {'version': '0.1.0'}}]",
+                "passed": true,
+                "version": "0.4.0"
+            },
+            "FET_100_ISAAC": {
+                "blocking_failure": false,
+                "dependencies": "[{'FET_003_PHYSX': {'version': '0.4.0'}}]",
+                "optional requirements": "['com.nvidia.simready.ISA.001']",
+                "passed": false,
+                "version": "0.3.0"
+            }
+        },
+        "profile_id": "Robot-Body",
+        "profile_version": "3.0.0",
+        "simready_validate_version": "2026.8.0",
+        "tier_versions": {
+            "sensors": "2026.8.0",
+            "tier_aif": "2026.8.0",
+            "tier_core": "2026.8.0"
+        }
+    }
+}

standardbots_spark/com.nvidia.simready.packaging.json

@@ -0,0 +1,31 @@
+{
+  "format_version": "1.0",
+  "package_id": "simready.hf.standardbots.simready-spark.standardbots_spark.2026.10.09_00",
+  "license": "cc-by-4.0",
+  "metadata": [
+    {
+      "name": "com.nvidia.simready.conformance.Package-Candidate@1.0.0.json",
+      "hash": {
+        "sha256": "a94dc5db15e80329983159306efcb4d09cef3d79a5f752ebe4146071503a7749"
+      }
+    },
+    {
+      "name": "com.nvidia.simready.packaging.bom.json",
+      "hash": {
+        "sha256": "1478ba4a8cf06ba8498e995c3be45796694d404c311d47b3ecd9041350f488c6"
+      }
+    },
+    {
+      "name": "com.nvidia.simready.root_usds.json",
+      "hash": {
+        "sha256": "5c31fbed623ec9b8f350e07c0b23099ad0d042af823d6161976193c3fa8c7900"
+      }
+    }
+  ],
+  "content_hash": {
+    "sha256": "5f6bfb51998b5798df7b7a175aecfd928e4646a709be8a873d0dd048d7368ae1"
+  },
+  "package_hash": {
+    "sha256": "c13dcaa248c81bd051b8a325045604fac7be440226fde6181865b6d02d735cd0"
+  }
+}

standardbots_spark/spark/configuration/OmniPBR/OmniPBR.mdl

@@ -0,0 +1,396 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+mdl 1.7;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::base::*;
+import ::state::*;
+import ::tex::*;
+import ::anno::*;
+
+import ::debug::*;
+
+import ::nvidia::core_definitions::file_texture;
+import ::nvidia::core_definitions::normalmap_texture;
+
+import OmniPBR_ClearCoat::*;
+
+
+//  OmniPBR  //
+
+export material OmniPBR(
+
+    //  Albdeo  //
+
+	color diffuse_color_constant = color(0.2) [[
+		anno::display_name("Albedo Color"),
+		anno::description("This is the albedo base color"),
+		anno::in_group("Albedo")
+	]],
+	uniform texture_2d diffuse_texture = texture_2d() [[
+		anno::display_name("Albedo Map"),
+		anno::in_group("Albedo")
+	]],
+	float albedo_desaturation = float(0.0) [[
+		anno::display_name("Albedo Map Desaturation"),
+		anno::description("Desaturates the albedo map"),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	float albedo_add = float(0.0) [[
+		anno::display_name("Albedo Add"),
+		anno::description("Adds a constant value to the diffuse color "),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(-1.0), float(1.0))
+	]],	
+	float albedo_brightness = float(1.0) [[
+		anno::display_name("Albedo Brightness"),
+		anno::description("Multiplier for the diffuse color "),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],	
+	color diffuse_tint = color(1.0) [[
+		anno::display_name("Color Tint"),
+		anno::description("When enabled, this color value is multiplied over the final albedo color"),
+		anno::in_group("Albedo")
+	]],
+	
+
+	//  Reflectivity //
+	
+	float reflection_roughness_constant = float(0.5) [[
+		anno::display_name("Roughness Amount"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	float reflection_roughness_texture_influence = float(0.0) [[
+		anno::display_name("Roughness Map Influence"),
+		anno::description("Blends between the constant value and the lookup of the roughness texture"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d reflectionroughness_texture = texture_2d() [[
+		anno::display_name("Roughness Map"),
+		anno::in_group("Reflectivity"),
+		anno::usage("roughness")
+	]],
+	float metallic_constant = float(0.0) [[
+		anno::display_name("Metallic Amount"),
+		anno::description("Metallic Material"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],	
+	float metallic_texture_influence = float(0.0) [[
+		anno::display_name("Metallic Map Influence"),
+		anno::description("Blends between the constant value and the lookup of the metallic texture"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d metallic_texture = texture_2d() [[
+		anno::display_name("Metallic Map"),
+		anno::in_group("Reflectivity"),
+		anno::usage("metalness")
+	]], 
+	float specular_level = float(0.5) [[
+		anno::display_name("Specular"),
+		anno::description("The specular level (intensity) of the material"),
+		anno::in_group("Reflectivity"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	
+
+	//  ORM  //
+ 
+	uniform bool enable_ORM_texture = false [[
+		anno::display_name("Enable ORM Texture"),
+		anno::description("The ORM texture will be used to extract the Occlusion, Roughness and Metallic textures from R,G,B channels"),
+		anno::in_group("Reflectivity")
+	]],
+	uniform texture_2d ORM_texture = texture_2d() [[
+		anno::display_name("ORM Map"),
+		anno::description("Texture that has Occlusion, Roughness and Metallic maps stored in their respective R, G and B channels"),
+		anno::in_group("Reflectivity"),
+		anno::usage("roughness")
+	]],
+
+
+	//  AO Group  // 
+
+	float ao_to_diffuse = 0.0 [[
+		anno::display_name("AO to diffuse"),
+		anno::description("Controls the amount of ambient occlusion multiplied against the diffuse color channel"),
+		anno::in_group("AO"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d ao_texture = texture_2d() [[
+		anno::display_name("Ambient Occlusion Map"),
+		anno::description("The ambient occlusion texture for the material"),
+		anno::in_group("AO"),
+		anno::usage("occlusion")
+	]],
+	
+	
+	//  Emission //  
+
+	uniform bool enable_emission = false [[
+        anno::display_name("Enable Emission"),
+		anno::description("Enables the emission of light from the material"),
+		anno::in_group("Emissive")
+	]],
+	color emissive_color = color(1.0,0.1,0.1) [[
+		anno::display_name("Emissive Color"),
+		anno::description("The emission color"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true")
+	]],
+    	uniform texture_2d emissive_color_texture = texture_2d() [[ 
+		anno::display_name("Emissive Color map"),
+        anno::in_group("Emissive"),
+		anno::description("The emissive color texture"),
+        anno::enable_if("enable_emission == true")
+    ]],	
+	uniform texture_2d emissive_mask_texture = texture_2d() [[
+		anno::display_name("Emissive Mask map"),
+		anno::description("The texture masking the emissive color"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true"),
+	 	anno::usage("occlusion")
+	]],
+	float emissive_intensity = float(40.0) [[
+		anno::display_name("Emissive Intensity"),    
+		anno::description("Intensity of the emission"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true")
+	]],	
+
+
+    //  Cutout Opacity  //
+	
+    uniform bool enable_opacity = false [[
+		anno::display_name("Enable Opacity"),
+		anno::description("Enables the use of cutout opacity"),
+		anno::in_group("Opacity")
+	]],
+ 	uniform texture_2d opacity_texture = texture_2d() [[
+		anno::display_name("Opacity Map"),
+		anno::in_group("Opacity"),
+		anno::usage("opacity")
+	]],
+	float opacity_constant = float(1.0) [[
+		anno::display_name("Opacity Amount"),    
+		anno::description("Opacity value between 0 and 1, when Opacity Map is not valid"),
+		anno::in_group("Opacity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform bool enable_opacity_texture = false [[
+		anno::display_name("Enable Opacity Texture"),
+		anno::description("Enables or disables the usage of the opacity texture map"),
+		anno::in_group("Opacity")
+	]],
+	uniform base::mono_mode opacity_mode = base::mono_average [[
+		anno::display_name("Opacity Mono Source"),
+		anno::description("Determines how to lookup opacity from the supplied texture. mono_alpha, mono_average, mono_luminance, mono_maximum"),
+		anno::in_group("Opacity")
+	]],
+	uniform float opacity_threshold = float(0.0) [[
+		anno::hard_range(0.0, 1.0),
+		anno::display_name("Opacity Threshold"),
+		anno::description("If 0, use fractional opacity values 'as is'; if > 0, remap opacity values to 1 when >= threshold and to 0 otherwise"),
+		anno::in_group("Opacity")
+	]],
+
+
+	//  Normal  // 
+	
+	uniform float geometry_normal_roughness_strength = 1.f
+	[[
+		anno::hard_range(0.0, 1.0),
+		anno::display_name("Normal map to roughness weight"),
+		anno::description("Enables and weights roughness induced by normal maps"),
+		anno::in_group("Normal")
+	]],
+	uniform float bump_factor = float(1.0) [[
+		anno::display_name("Normal Strength"),
+		anno::description("Strength of normal map"),
+		anno::in_group("Normal"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d normalmap_texture = texture_2d() [[
+		anno::display_name("Normal Map"),
+		anno::in_group("Normal"),
+		anno::usage("normal")
+	]], 
+	uniform float detail_bump_factor = float(0.3) [[
+		anno::display_name("Detail Normal Strength"),
+		anno::in_group("Normal"),
+		anno::description("Strength of the detail normal"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d detail_normalmap_texture = texture_2d() [[
+		anno::display_name("Detail Normal Map"),
+		anno::in_group("Normal"),
+		anno::usage("normal")
+	]],
+	uniform bool flip_tangent_u = false  [[
+        anno::display_name("Normal Map Flip U Tangent"),
+        anno::in_group("Normal")
+    	]],
+	uniform bool flip_tangent_v = true [[
+        anno::display_name("Normal Map Flip V Tangent"),
+        anno::in_group("Normal")
+    	]],
+
+
+	//  UVW Projection Group  //
+
+	uniform bool project_uvw = false [[
+		anno::display_name("Enable Project UVW Coordinates"),
+		anno::description("When enabled, UV coordinates will be generated by projecting them from a coordinate system"),
+		anno::in_group("UV")
+	]],
+	uniform bool world_or_object = false [[
+		anno::display_name("Enable World Space"),
+		anno::description("When enabled, uses world space for projection, otherwise object space is used"),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform int uv_space_index =  0 [[
+		anno::display_name("UV Space Index"),
+		anno::description("UV Space Index."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true"),
+		anno::hard_range(int(0), int(3))
+	]],
+	
+
+	//  UVW Adjustments Group  //
+
+	uniform float2 texture_translate =  float2(0.0) [[
+		anno::display_name("Texture Translate"),
+		anno::description("Controls position of texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float texture_rotate = float(0.0) [[
+		anno::display_name("Texture Rotate"),
+		anno::description("Rotates angle of texture in degrees."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 texture_scale =  float2(1.0) [[
+		anno::display_name("Texture Tiling"),
+		anno::description("Controls the repetition of the texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 detail_texture_translate =  float2(0.0) [[
+		anno::display_name("Detail Texture Translate"),
+		anno::description("Controls the position of the detail texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float detail_texture_rotate =  float(0.0) [[
+		anno::display_name("Detail Texture Rotate"),
+		anno::description("Rotates angle of the detail texture in degrees."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 detail_texture_scale =  float2(1.0) [[
+		anno::display_name("Detail Texture Tiling"),
+		anno::description("Controls the repetition of the detail texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+    ]],
+    
+
+    //  Geometry  //
+
+    uniform float round_edges_radius = float(0.0) [[
+        anno::display_name("Round Edge Radius"),
+        anno::description("Influence radius around the edges in meters"),
+        anno::in_group("Geometry"),
+        anno::soft_range(0.0, 1.0)
+    ]],
+    uniform float round_edges_roundness = float(1.0) [[
+        anno::display_name("Round Edge Roundness"),
+        anno::description("Determines how round the edge will look"),
+        anno::in_group("Geometry"),
+        anno::hard_range(0.0, 1.0)
+    ]],
+    uniform bool round_edges_across_materials = false [[
+        anno::display_name("Round Edge Across Materials"),
+        anno::description("Normal smoothing happens only between facets of equal material, \n"
+                          "\t\tunless this parameter is set true, in which case the smoothing \n"
+                          "\t\thappens between facets irrespective of their materials"),
+        anno::in_group("Geometry")
+    ]]
+) 
+[[
+	anno::display_name("OmniPBR"),
+	anno::description("OmniPBR Base with support for clear coat, opacity and ORM textures."),
+    anno::in_group("Base"),
+	anno::version( 2, 1, 2),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "PBR", "opacity", "omniverse", "generic"))
+]] = let {
+
+material base = OmniPBR_ClearCoat::OmniPBR_ClearCoat(
+    diffuse_color_constant: diffuse_color_constant,
+    diffuse_texture: diffuse_texture,
+    albedo_desaturation: albedo_desaturation,
+    albedo_add: albedo_add,
+    albedo_brightness: albedo_brightness,
+    diffuse_tint: diffuse_tint,
+    reflection_roughness_constant: reflection_roughness_constant,
+    reflection_roughness_texture_influence: reflection_roughness_texture_influence,
+    reflectionroughness_texture: reflectionroughness_texture,
+    metallic_constant: metallic_constant,
+    metallic_texture_influence: metallic_texture_influence,
+    metallic_texture: metallic_texture,
+    specular_level: specular_level,
+    enable_ORM_texture: enable_ORM_texture,
+    ORM_texture: ORM_texture,
+    ao_to_diffuse: ao_to_diffuse,
+    ao_texture: ao_texture,
+	enable_emission: enable_emission,
+    emissive_color: emissive_color,
+    emissive_color_texture: emissive_color_texture, 
+    emissive_mask_texture: emissive_mask_texture,
+    emissive_intensity: emissive_intensity,      
+    enable_opacity: enable_opacity,          
+    opacity_texture: opacity_texture,         
+    opacity_constant: opacity_constant,        
+    enable_opacity_texture: enable_opacity_texture,  
+    opacity_mode: opacity_mode,            
+    opacity_threshold: opacity_threshold,
+    geometry_normal_roughness_strength:     geometry_normal_roughness_strength,
+    bump_factor: bump_factor,             
+    normalmap_texture: normalmap_texture,
+    detail_bump_factor: detail_bump_factor,      
+    detail_normalmap_texture: detail_normalmap_texture,
+    flip_tangent_u: flip_tangent_u,          
+    flip_tangent_v: flip_tangent_v,                  
+	project_uvw: project_uvw,
+    world_or_object: world_or_object,         
+    uv_space_index: uv_space_index,          
+    texture_translate: texture_translate,       
+    texture_rotate: texture_rotate,          
+    texture_scale: texture_scale,           
+    detail_texture_translate: detail_texture_translate,
+    detail_texture_rotate: detail_texture_rotate, 
+    detail_texture_scale: detail_texture_scale,
+    round_edges_radius: round_edges_radius,
+    round_edges_roundness: round_edges_roundness,
+    round_edges_across_materials: round_edges_across_materials
+);
+
+} in material(
+surface:  base.surface,
+geometry: base.geometry
+);

standardbots_spark/spark/configuration/OmniPBR/OmniPBRBase.mdl

@@ -0,0 +1,470 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+mdl 1.7;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::base::*;
+import ::tex::*;
+import ::anno::*;
+import ::anno::*;
+
+export float3 HemiOctahedronToUnitVector( float2 Oct ) [[
+	anno::hidden()
+]]
+{
+    Oct = float2( Oct.x + Oct.y, Oct.x - Oct.y ) * 0.5;
+    float3 N = float3( Oct.x, Oct.y, 1.0 - math::dot( float2(1.0), math::abs(Oct) ) );
+    return math::normalize(N);
+}
+
+export struct NormalData  [[
+	anno::hidden()
+]]
+{
+	float3 normal;
+	float2 roughness;
+};
+
+export NormalData tangent_space_normal_roughness_texture(
+    uniform texture_2d texture
+        [[
+            anno::description("The input texture"),
+            anno::usage("normal")
+        ]],
+    uniform float factor = 1.0f
+        [[ anno::description("Determines the degree of bumpiness") ]],
+    uniform bool flip_tangent_u = false
+        [[ anno::description("Can be used to fix mismatches between the object's tangent space and the normal map's tangent space") ]],
+    uniform bool flip_tangent_v = false
+        [[ anno::description("Can be used to fix mismatches between the object's tangent space and the normal map's tangent space") ]],
+    base::texture_coordinate_info uvw = base::texture_coordinate_info()
+        [[ anno::description("Parameterization to be used for texture mapping. Defaults to texture channel 0.") ]],
+    uniform float2 crop_u = float2( 0.0, 1.0)
+        [[ anno::description("Restricts the texture access to sub-domain of the texture in the u direction") ]],
+    uniform float2 crop_v = float2( 0.0, 1.0)
+        [[ anno::description("Restricts the texture access to sub-domain of the texture in the v direction") ]],
+    uniform tex::wrap_mode wrap_u = tex::wrap_repeat
+        [[ anno::description("Wrapping mode in the u direction") ]],
+    uniform tex::wrap_mode wrap_v = tex::wrap_repeat
+        [[ anno::description("Wrapping mode in the v direction") ]],
+    uniform bool clip = false
+        [[
+            anno::description("deprecated, usewrap_mode=tex::wrap_clip. Defines wrap_clamp behavior. If true, lookup outside [0,1] results in no bump"),
+            anno::hidden()
+        ]],
+    uniform float scale = 1.
+        [[
+            anno::description("Scales the value red from the texture file. Can be used to adapt to different normal map formats"),
+            anno::unused()
+        ]],
+    uniform float offset = 0.
+        [[
+            anno::description("Offset applied to the value red from the texture file. Can be used to adapt to different normal map formats"),
+            anno::unused()
+        ]],
+    uniform float animation_start_time = 0.
+        [[ anno::description("When to start playing first frame of the animation ") ]],
+    uniform int2 animation_crop  = int2(0, 0)
+        [[ anno::description("If the texture is an animation, the range of frames to be played can be specified.") ]],
+    uniform tex::wrap_mode animation_wrap = tex::wrap_repeat
+        [[ anno::description("Defines what to do outside of regular animation time") ]],
+    uniform float animation_fps = 30
+        [[ anno::description("Framerate to use for animation playback") ]]
+)
+[[
+    anno::description("Interprets the color values of a bitmap as a vector in tangent space"),
+	anno::hidden(),
+    anno::noinline()
+]]
+{
+	NormalData normalData;
+	normalData.roughness = float2(0);
+	normalData.normal = state::normal();
+
+    float frame = 0.0;
+    if(animation_crop != int2(0,0)) //only if we have an animation
+    {
+        frame = (::state::animation_time()-animation_start_time) * animation_fps ; //start playing at first frame of the animation
+        switch ( animation_wrap) {
+            case tex::wrap_repeat:
+                frame=frame>0?  math::fmod(frame,animation_crop.y-animation_crop.x)+animation_crop.x:
+                                math::fmod(frame,animation_crop.y-animation_crop.x)+animation_crop.y;
+                break;
+            case tex::wrap_mirrored_repeat:
+                float animation_crop_2y = 2.0*animation_crop.y;
+                frame=frame>0?  math::fmod(frame,(animation_crop.y-animation_crop.x)*2.0)+animation_crop.x:
+                                math::fmod(frame,(animation_crop.y-animation_crop.x)*2.0)+animation_crop_2y-animation_crop.x;
+                if(frame>animation_crop.y)
+                    frame = animation_crop_2y-frame;
+                break;
+            case tex::wrap_clamp:
+                frame = math::clamp( frame+animation_crop.x, animation_crop.x, animation_crop.y);
+                break;
+            case tex::wrap_clip:
+                frame += animation_crop.x;
+                if(frame < animation_crop.x || frame > animation_crop.y) return normalData;
+                break;
+        }
+    }
+
+    if (tex::width(texture) == 0 || tex::height(texture) == 0 || // avoid division by zero in texremapu for invalid resource
+        factor == 0.0f)
+        return normalData;
+    {
+        if (clip) {
+            if (wrap_u == tex::wrap_clamp && (uvw.position.x < 0. || uvw.position.x > 1.)) {
+                return normalData;
+            }
+            if (wrap_v == tex::wrap_clamp && (uvw.position.y < 0. || uvw.position.y > 1.)) {
+                return normalData;
+            }
+        }
+        if (wrap_u == tex::wrap_clip && (uvw.position.x < 0. || uvw.position.x > 1.)) {
+            return normalData;
+        }
+        if (wrap_v == tex::wrap_clip && (uvw.position.y < 0. || uvw.position.y > 1.)) {
+            return normalData;
+        }
+    }
+    bool pixel_flip_u = flip_tangent_u;
+    bool pixel_flip_v = flip_tangent_v;
+    //if we mirror repeat a tangent space texture, tangent space needs to be flipped for every other tile
+    if (wrap_u == tex::wrap_mirrored_repeat) {
+        if( uvw.position.x > 0. && int(uvw.position.x) % 2 == 1)
+            pixel_flip_u = ! pixel_flip_u;
+        else if( uvw.position.x < 0. && int(uvw.position.x) % 2 == 0)
+            pixel_flip_u = ! pixel_flip_u;
+    }
+    if (wrap_v == tex::wrap_mirrored_repeat) {
+        if( uvw.position.y > 0. && int(uvw.position.y) % 2 == 1)
+            pixel_flip_v = ! pixel_flip_v;
+        else if( uvw.position.y < 0. && int(uvw.position.y) % 2 == 0)
+            pixel_flip_v = ! pixel_flip_v;
+    }
+
+    float3 transformed_tangent_u = uvw.tangent_u;
+    float3 transformed_tangent_v = uvw.tangent_v;
+
+    if (pixel_flip_u)
+        transformed_tangent_u=-transformed_tangent_u;
+    if (pixel_flip_v)
+        transformed_tangent_v=-transformed_tangent_v;
+
+    float3 tangent_space_normal;
+	float4 normal_raw = tex::lookup_float4(texture,float2(uvw.position.x,uvw.position.y), wrap_u, wrap_v, crop_u, crop_v, frame);
+	if(normal_raw.x > 1.5)
+	{
+		// octahedron packed by OV
+		normal_raw.x -= 2.0;
+		normal_raw.x -= 0.5;
+		normal_raw.y -= 0.5;
+		tangent_space_normal = HemiOctahedronToUnitVector(float2(normal_raw.x, normal_raw.y) * 2.0);
+		normalData.roughness = float2(normal_raw.z, normal_raw.w);
+	}
+	else
+	{
+		// regular
+		tangent_space_normal = (float3(normal_raw.x, normal_raw.y, normal_raw.z) - float3(0.5)) * 2.0;
+		normalData.roughness = float2(0);
+	}
+
+	normalData.normal =  math::normalize(
+        transformed_tangent_u * tangent_space_normal.x * factor +
+        transformed_tangent_v * tangent_space_normal.y * factor +
+        state::normal() * tangent_space_normal.z);
+
+	return normalData;
+}
+
+
+export material OmniPBRBase(
+
+	
+    //  Albdeo  //
+
+	color diffuse_reflection_color = color(0.2) [[
+		anno::display_name("Albedo Color"),
+		anno::description("This is the albedo base color"),
+		anno::in_group("Albedo")
+	]],
+	color diffuse_tint = color(1.0) [[
+		anno::display_name("Albedo Tint"),
+		anno::description("When enabled, this color value is multiplied over the final albedo color"),
+		anno::in_group("Albedo")
+	]],
+
+	
+	//  Reflecitivity //
+	
+	float specular_reflection_roughness = float(0.0) [[
+		anno::display_name("Roughness"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(0.0, 1.0)
+	]],
+	float2 specular_reflection_aniso_roughness = float2(0.0, 0.0) [[
+		anno::display_name("Aniso roughness"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Reflectivity"),
+		anno::hidden()
+	]],
+	float metalness = float(0.0) [[
+		anno::display_name("Metalness"),
+		anno::description("Bias towards pure specular reflection"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(0.0, 1.0)
+	]],	
+	float specular_level = float(0.5) [[
+		anno::display_name("Specular"),
+		anno::description("The specular level (intensity) of the material"),
+		anno::in_group("Reflectivity"),
+		anno::soft_range(0.0, 1.0)
+	]],
+
+
+	//  Emission  //
+	
+	uniform bool enable_emission = false [[
+		anno::display_name("Enable Emission"),
+		anno::description("Enables the emission of light from the material"),
+		anno::in_group("Emissive")
+	]],
+	color emission_color = color(1.0,0.1,0.1) [[
+		anno::display_name("Emissive Color"),
+		anno::description("The emission color"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true")
+	]],
+	float emission_intensity = float(40.0) [[
+		anno::display_name("Emissive Intensity"),    
+		anno::description("Intensity of the emission"),
+		anno::in_group("Emissive"),
+		anno::soft_range(0.0, 1000.0),
+		anno::enable_if("enable_emission == true")
+	]],
+
+	
+    //  Geometry Opacity  //
+	
+    uniform bool enable_opacity = false [[
+		anno::display_name("Enable Opacity"),
+		anno::description("Enables the use of cutout opacity"),
+		anno::in_group("Opacity")
+	]],
+	float geometry_opacity = float(1.0) [[
+		anno::display_name("Opacity Amount"),    
+		anno::description("Opacity value between 0 and 1, when Opacity Map is not valid"),
+		anno::in_group("Opacity"),
+		anno::hard_range(0.0, 1.0)
+	]],
+	uniform float geometry_opacity_threshold = 0.f
+	[[
+		anno::display_name("Opacity Threshold"),
+		anno::description("If 0, use fractional opacity values 'as is'; if > 0, remap opacity values to 1 when >= threshold and to 0 otherwise"),
+		anno::in_group("Opacity"),
+		anno::hard_range(0.0, 1.0)
+	]],
+
+	
+	//  Clearcoat // 
+	
+    uniform bool enable_coat = false [[
+		anno::display_name("Enable Clearcoat Layer"),
+		anno::description("Adds a coat layer on top of the material when enabled"),
+		anno::in_group("Clearcoat")
+	]],
+	float coat_weight = float(1.0) [[
+		anno::display_name("Clearcoat Weight"),
+		anno::description("Sets the weight for coat layer"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(0.0, 1.0)
+	]],
+	color coat_color = color(1.0) [[
+		anno::display_name("Clearcoat Tint"),
+		anno::description("Clearcoat is tinted and affects the underlying material"),
+		anno::in_group("Clearcoat")
+	]],
+	float coat_transparency = float(1.0) [[
+		anno::display_name("Clearcoat Transparency"),
+		anno::description("Adjusts the transparency of the coat. Can be turned into a fully opaque coat covering the underlying layer"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(0.0, 1.0)
+	]],
+	float coat_roughness = float(0.0) [[
+		anno::display_name("Clearcoat Roughness"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(0.0, 1.0)
+	]],
+	float2 coat_aniso_roughness = float2(0.0, 0.0) [[
+		anno::display_name("Clearcoat aniso roughness"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Clearcoat"),
+		anno::hidden()
+	]],
+	float coat_ior = float(1.56) [[
+		anno::display_name("Clearcoat IOR"),
+		anno::description("Sets the Index of refraction for the coat layer"),
+		anno::in_group("Clearcoat"),
+		anno::soft_range(0.0, 4.0)
+	]],
+    float3 clearcoat_geometry_normal = state::normal() [[
+        anno::display_name("Clearcoat Normal"),
+        anno::in_group("Clearcoat"),
+        anno::usage("normal")
+    ]],
+
+
+	//  Geometry  //
+
+    uniform float round_edges_radius = float(0.0) [[
+        anno::display_name("Round Edge Radius"),
+        anno::description("Influence radius around the edges in meters"),
+        anno::in_group("Geometry"),
+        anno::soft_range(0.0, 1.0)
+    ]],
+    uniform float round_edges_roundness = float(1.0) [[
+        anno::display_name("Round Edge Roundness"),
+        anno::description("Determines how round the edge will look"),
+        anno::in_group("Geometry"),
+        anno::hard_range(0.0, 1.0)
+    ]],
+    uniform bool round_edges_across_materials = false [[
+        anno::display_name("Round Edge Across Materials"),
+        anno::description("Normal smoothing happens only between facets of equal material, \n"
+                          "\t\tunless this parameter is set true, in which case the smoothing \n"
+                          "\t\thappens between facets irrespective of their materials"),
+        anno::in_group("Geometry")
+    ]],
+    float3 geometry_normal = state::normal() [[
+        anno::display_name("Geometry Normal"),
+        anno::in_group("Geometry"),
+        anno::usage("normal")
+    ]]
+
+) 
+[[
+	anno::display_name("OmniPBR Base"),
+	anno::description("OmniPBR Base with support for clear coat, opacity and ORM textures."),
+ 	anno::in_group("Omni Materials"),
+	anno::version( 2, 1, 1),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "PBR", "opacity", "omniverse", "generic"))
+]]
+ = let{
+
+    //  Diffuse Bsdf  //	
+    
+    color tinted_diffuse_color = diffuse_reflection_color * diffuse_tint;
+
+    color base_color = tinted_diffuse_color;
+
+    bsdf diffuse_bsdf = df::weighted_layer(
+		weight: 1.0,
+		layer:  df::diffuse_reflection_bsdf(
+			        tint:       base_color,
+			        roughness:  float(0.0)
+                ),
+		base:   bsdf(),
+		normal: geometry_normal
+	);
+
+	//  Glossy Reflection Bsdf  //
+
+	float roughness_u = math::clamp(specular_reflection_roughness * specular_reflection_roughness
+		+ specular_reflection_aniso_roughness.x * specular_reflection_aniso_roughness.x, 0, 1);
+	float roughness_v = math::clamp(specular_reflection_roughness * specular_reflection_roughness
+		+ specular_reflection_aniso_roughness.y * specular_reflection_aniso_roughness.y, 0, 1);
+	bsdf ggx_smith_bsdf = df::microfacet_ggx_smith_bsdf(
+		roughness_u:    roughness_u,
+		roughness_v:    roughness_v,
+		tint:           color(1.0),
+		mode:           df::scatter_reflect
+	);
+	
+	bsdf custom_curve_layer_bsdf = df::custom_curve_layer(
+		normal_reflectivity:  0.08,		
+		grazing_reflectivity: 1.0,
+		exponent:	          5.0,
+		weight:	              specular_level,
+		layer:                ggx_smith_bsdf,
+		base:	              diffuse_bsdf,
+		normal:               geometry_normal
+	);
+	
+	bsdf directional_factor_bsdf = df::tint(base_color, ggx_smith_bsdf);
+	
+	bsdf omni_PBR_bsdf = df::weighted_layer(
+        weight:     metalness,
+        layer:	    directional_factor_bsdf,
+		base:	    custom_curve_layer_bsdf,
+		normal:     geometry_normal
+	);
+	
+	//  Clear Coat  // 
+
+	float coat_roughness_u = math::clamp(coat_roughness * coat_roughness
+		+ coat_aniso_roughness.x * coat_aniso_roughness.x, 0, 1);
+	float coat_roughness_v = math::clamp(coat_roughness * coat_roughness
+		+ coat_aniso_roughness.y * coat_aniso_roughness.y, 0, 1);
+	bsdf coat_bsdf = df::microfacet_ggx_smith_bsdf(
+		roughness_u: coat_roughness_u,
+		roughness_v: coat_roughness_v,
+		tint:        color(1.0),
+		mode:        df::scatter_reflect
+	);
+	
+	bsdf opaque_coat = df::weighted_layer(
+        weight:     coat_transparency,
+		layer:	    ::df::tint( 
+					    tint: coat_color,
+					    base: omni_PBR_bsdf
+                    ),
+		base:	    ::df::diffuse_reflection_bsdf(
+					    tint: coat_color
+                    )
+	);
+	
+	bsdf omni_PBR_coated_bsdf = df::fresnel_layer(
+		ior:     coat_ior,
+		weight:  coat_weight,
+		layer:   coat_bsdf,
+		base:    opaque_coat,
+		normal:  clearcoat_geometry_normal 
+	);
+	
+    bsdf final_bsdf = enable_coat ? omni_PBR_coated_bsdf : omni_PBR_bsdf;
+                                    
+    color emission_value = enable_emission ? emission_color * color(emission_intensity) : color(0.0);
+	
+	float opacity_value = geometry_opacity;
+    float cutout_opacity = enable_opacity ? ((geometry_opacity_threshold == 0.0) ? opacity_value : ((opacity_value >= geometry_opacity_threshold) ? 1.0 : 0)) : 1.0;
+ 
+    material_emission emission = material_emission(
+                                    df::diffuse_edf(),
+                                    intensity: emission_value 
+                                    );
+
+    material_surface surface =  material_surface(
+		                            scattering: final_bsdf,
+		                            emission:   emission
+		                            );
+
+    material_geometry geometry = material_geometry(
+                                    normal: state::rounded_corner_normal(
+                                        radius: round_edges_radius,
+                                        across_materials: round_edges_across_materials,
+                                        roundness: round_edges_roundness
+                                    ),
+                                    cutout_opacity: cutout_opacity
+                                    );
+
+} in material(
+	surface: surface,
+	geometry: geometry
+);

standardbots_spark/spark/configuration/OmniPBR/OmniPBR_ClearCoat.mdl

@@ -0,0 +1,711 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+mdl 1.7;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::base::*;
+import ::state::*;
+import ::tex::*;
+import ::anno::*;
+
+import ::debug::*;
+
+import ::nvidia::core_definitions::file_texture;
+import ::nvidia::core_definitions::normalmap_texture;
+
+import OmniPBRBase::*;
+
+//  Functions  //
+
+
+//  Returns a matrix from R,T,S. inputs //
+
+uniform float4x4 rotation_translation_scale(
+    uniform float3 rotation = float3(0.)
+        [[ anno::description("Rotation applied to every UVW coordinate") ]],
+    uniform float3 translation = float3(0.)
+        [[ anno::description("Offset applied to every UVW coordinate") ]],
+    uniform float3 scaling = float3(1.)
+        [[ anno::description("Scale applied to every UVW coordinate") ]]
+)
+[[
+    anno::description("Construct a transformation matrix from euler rotation, translation and scale"),
+    anno::hidden()
+]]
+{
+    float4x4 scale =
+        float4x4(scaling.x         , 0.0               , 0.0               , 0.0,
+                 0.0               , scaling.y         , 0.0               , 0.0,
+                 0.0               , 0.0               , scaling.z         , 0.0,
+                 translation.x     , translation.y     , translation.z     , 1.0);
+
+    float3 s = math::sin(rotation);
+    float3 c = math::cos(rotation);
+    
+    float4x4 rotate =
+        float4x4(  c.y*c.z    , -c.x*s.z + s.x*s.y*c.z ,  s.x*s.z + c.x*s.y*c.z , 0.0,
+                   c.y*s.z    ,  c.x*c.z + s.x*s.y*s.z , -s.x*c.z + c.x*s.y*s.z , 0.0,
+                  -s.y        ,  s.x*c.y               ,  c.x*c.y               , 0.0,
+                   0.0        ,  0.0                   ,  0                     , 1.0);
+
+    return   scale * rotate;
+}
+
+//  Returns the normal n in tangent space, given n is in internal space. //
+
+float3 transform_internal_to_tangent(float3 n)
+{
+	/* flip_tangent_v */
+    return
+        n.x* float3(state::texture_tangent_u(0).x,-state::texture_tangent_v(0).x,state::normal().x)+
+        n.y* float3(state::texture_tangent_u(0).y,-state::texture_tangent_v(0).y,state::normal().y)+
+        n.z* float3(state::texture_tangent_u(0).z,-state::texture_tangent_v(0).z,state::normal().z);
+}
+
+//  Returns the normal n in internal space, given n is in tangent space.
+float3 transform_tangent_to_internal(float3 n)
+{
+    return  state::texture_tangent_u(0) * n.x -
+            state::texture_tangent_v(0) * n.y + /* flip_tangent_v */
+            state::normal() * n.z;
+}
+
+//  Returns a normal by adding a detail normal to a global normal.
+export float3 add_detail_normal(float3 nd = state::normal(), float3 n = state::normal())
+{
+    // http://blog.selfshadow.com/publications/blending-in-detail/
+    float3  n_t = transform_internal_to_tangent(n);
+    float3 nd_t = transform_internal_to_tangent(nd);
+            n_t = n_t + float3(0.,0.,1.);
+           nd_t = nd_t *  float3(-1.,-1.,1.);
+              n = n_t * math::dot(n_t, nd_t)/n_t.z - nd_t;
+    return math::normalize(transform_tangent_to_internal(n));
+}
+
+base::texture_return multiply_colors(
+    color color_1 = color(1.0, 1.0, 1.0),
+    color color_2 = color(.5, .5, .5),
+	float weight  = 1.0
+    ) 
+[[ 
+    anno::hidden() 
+]]
+{
+    return base::blend_color_layers(
+                layers: base::color_layer[](
+                    base::color_layer(
+                        layer_color:    color_2,
+                        weight:         weight,
+                        mode:           base::color_layer_multiply
+                        )),
+                base: color_1
+            );
+}
+
+
+//  OmniPBR Clearcoat  //
+
+export material OmniPBR_ClearCoat(
+
+    //  Albdeo  //
+
+	color diffuse_color_constant = color(0.2) [[
+		anno::display_name("Albedo Color"),
+		anno::description("This is the albedo base color"),
+		anno::in_group("Albedo")
+	]],
+	uniform texture_2d diffuse_texture = texture_2d() [[
+		anno::display_name("Albedo Map"),
+		anno::in_group("Albedo")
+	]],
+	float albedo_desaturation = float(0.0) [[
+		anno::display_name("Albedo Map Desaturation"),
+		anno::description("Desaturates the albedo map"),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	float albedo_add = float(0.0) [[
+		anno::display_name("Albedo Add"),
+		anno::description("Adds a constant value to the diffuse color "),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(-1.0), float(1.0))
+	]],	
+	float albedo_brightness = float(1.0) [[
+		anno::display_name("Albedo Brightness"),
+		anno::description("Multiplier for the diffuse color "),
+		anno::in_group("Albedo"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],	
+	color diffuse_tint = color(1.0) [[
+		anno::display_name("Color Tint"),
+		anno::description("When enabled, this color value is multiplied over the final albedo color"),
+		anno::in_group("Albedo")
+	]],
+	
+
+	//  Reflectivity //
+	
+	float reflection_roughness_constant  = float(0.5) [[
+		anno::display_name("Roughness Amount"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	float reflection_roughness_texture_influence = float(0.0) [[
+		anno::display_name("Roughness Map Influence"),
+		anno::description("Blends between the constant value and the lookup of the roughness texture"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d reflectionroughness_texture = texture_2d() [[
+		anno::display_name("Roughness Map"),
+		anno::in_group("Reflectivity"),
+		anno::usage("roughness")
+	]],
+	float metallic_constant = float(0.0) [[
+		anno::display_name("Metallic Amount"),
+		anno::description("Metallic Material"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],	
+	float metallic_texture_influence = float(0.0) [[
+		anno::display_name("Metallic Map Influence"),
+		anno::description("Blends between the constant value and the lookup of the metallic texture"),
+		anno::in_group("Reflectivity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d metallic_texture = texture_2d() [[
+		anno::display_name("Metallic Map"),
+		anno::in_group("Reflectivity"),
+		anno::usage("metalness")
+	]], 
+	float specular_level = float(0.5) [[
+		anno::display_name("Specular"),
+		anno::description("The specular level (intensity) of the material"),
+		anno::in_group("Reflectivity"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	
+
+	//  ORM  //
+ 
+	uniform bool enable_ORM_texture = false [[
+		anno::display_name("Enable ORM Texture"),
+		anno::description("The ORM texture will be used to extract the Occlusion, Roughness and Metallic textures from R,G,B channels"),
+		anno::in_group("Reflectivity")
+	]],
+	uniform texture_2d ORM_texture = texture_2d() [[
+		anno::display_name("ORM Map"),
+		anno::description("Texture that has Occlusion, Roughness and Metallic maps stored in their respective R, G and B channels"),
+		anno::in_group("Reflectivity"),
+		anno::usage("roughness")
+	]],
+
+
+	//  AO Group  // 
+
+	float ao_to_diffuse = 0.0 [[
+		anno::display_name("AO to diffuse"),
+		anno::description("Controls the amount of ambient occlusion multiplied against the diffuse color channel"),
+		anno::in_group("AO"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d ao_texture = texture_2d() [[
+		anno::display_name("Ambient Occlusion Map"),
+		anno::description("The ambient occlusion texture for the material"),
+		anno::in_group("AO"),
+		anno::usage("occlusion")
+	]],
+	
+	
+	//  Emission //  
+
+	uniform bool enable_emission = false [[
+        anno::display_name("Enable Emission"),
+		anno::description("Enables the emission of light from the material"),
+		anno::in_group("Emissive")
+	]],
+	color emissive_color = color(1.0,0.1,0.1) [[
+		anno::display_name("Emissive Color"),
+		anno::description("The emission color"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true")
+	]],
+    	uniform texture_2d emissive_color_texture = texture_2d() [[ 
+		anno::display_name("Emissive Color map"),
+        anno::in_group("Emissive"),
+		anno::description("The emissive color texture"),
+        anno::enable_if("enable_emission == true")
+    	]],	
+	uniform texture_2d emissive_mask_texture = texture_2d() [[
+		anno::display_name("Emissive Mask map"),
+		anno::description("The texture masking the emissive color"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true"),
+		anno::usage("occlusion")
+	]],
+	float emissive_intensity = float(40.0) [[
+		anno::display_name("Emissive Intensity"),    
+		anno::description("Intensity of the emission"),
+		anno::in_group("Emissive"),
+		anno::enable_if("enable_emission == true")
+	]],	
+
+
+    //  Cutout Opacity  //
+	
+    uniform bool enable_opacity = false [[
+		anno::display_name("Enable Opacity"),
+		anno::description("Enables the use of cutout opacity"),
+		anno::in_group("Opacity")
+	]],
+ 	uniform texture_2d opacity_texture = texture_2d() [[
+		anno::display_name("Opacity Map"),
+		anno::in_group("Opacity"),
+		anno::usage("opacity")
+	]],
+	float opacity_constant = float(1.0) [[
+		anno::display_name("Opacity Amount"),    
+		anno::description("Opacity value between 0 and 1, when Opacity Map is not valid"),
+		anno::in_group("Opacity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	uniform bool enable_opacity_texture = false [[
+		anno::display_name("Enable Opacity Texture"),
+		anno::description("Enables or disables the usage of the opacity texture map"),
+		anno::in_group("Opacity")
+	]],
+	uniform base::mono_mode opacity_mode = base::mono_average [[
+		anno::display_name("Opacity Mono Source"),
+		anno::description("Determines how to lookup opacity from the supplied texture. mono_alpha, mono_average, mono_luminance, mono_maximum"),
+		anno::in_group("Opacity")
+	]],
+	uniform float opacity_threshold = float(0.0) [[
+		anno::display_name("Opacity Threshold"),
+		anno::description("If 0, use fractional opacity values 'as is'; if > 0, remap opacity values to 1 when >= threshold and to 0 otherwise"),
+		anno::in_group("Opacity"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+
+
+	//  Clearcoat // 
+	
+	uniform bool enable_clearcoat = false [[
+		anno::display_name("Enable Clearcoat Layer"),
+		anno::description("Adds a clearcoat layer on top of the material when enabled"),
+		anno::in_group("Clearcoat")
+	]],
+	float clearcoat_weight = float(1.0) [[
+		anno::display_name("Clearcoat Weight"),
+		anno::description("Sets the weight for clearcoat layer"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	color clearcoat_tint = color(1.0) [[
+		anno::display_name("Clearcoat Tint"),
+		anno::description("Clearcoat is tinted and affects the underlying material"),
+		anno::in_group("Clearcoat")
+	]],
+	float clearcoat_transparency = float(1.0) [[
+		anno::display_name("Clearcoat Transparency"),
+		anno::description("Adjusts the transparency of the clearcoat. Can be turned into a fully opaque clearcoat covering the underlying layer"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	float clearcoat_reflection_roughness = float(0.0) [[
+		anno::display_name("Clearcoat Roughness"),
+		anno::description("Higher roughness values lead to more blurry reflections"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+	float clearcoat_ior = float(1.56) [[
+		anno::display_name("Clearcoat IOR"),
+		anno::description("Sets the Index of refraction for the clearcoat layer"),
+		anno::in_group("Clearcoat"),
+		anno::soft_range(float(0.0), float(4.0))
+	]],
+	uniform float clearcoat_bump_factor = float(1.0) [[
+		anno::display_name("Clearcoat Normal Map Strength"),
+		anno::description("Strength of normal map."),
+		anno::in_group("Clearcoat"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d clearcoat_normalmap_texture = texture_2d() [[
+		anno::display_name("Clearcoat Normal Map"),
+		anno::description("Enables the usage of the normalmap texture"),
+		anno::in_group("Clearcoat"),
+		anno::usage("normal")
+	]], 	
+	uniform float2 clearcoat_texture_translate =  float2(0.0) [[
+		anno::display_name("Clearcoat Texture Translate"),
+		anno::description("Controls the position of the clearcoat texture"),
+		anno::ui_order(1),
+		anno::in_group("UV")
+	]],
+	uniform float clearcoat_texture_rotate = float(0.0) [[
+		anno::display_name("Clearcoat Texture Rotate"),
+		anno::description("Rotates angle of the clearcoat texture in degrees"),
+		anno::ui_order(2),
+		anno::in_group("UV")
+	]],
+	uniform float2 clearcoat_texture_scale = float2(1.0) [[
+		anno::display_name("Clearcoat Texture Tiling"),
+		anno::description("Controls the repetition of the clearcoat texture"),
+		anno::ui_order(3),
+		anno::in_group("UV")
+	]],
+	float clearcoat_flatten = float(1.0) [[
+		anno::display_name("Clearcoat Flatten"),
+		anno::description("Flattens the clearcoat to even out the underlying bump maps"),
+		anno::in_group("Clearcoat"),
+		anno::hard_range(float(0.0), float(1.0))
+	]],
+
+
+	//  Normal  // 
+	
+	uniform float geometry_normal_roughness_strength = 1.f
+	[[
+		anno::hard_range(0.0, 1.0),
+		anno::display_name("Normal map to roughness weight"),
+		anno::description("Enables and weights roughness induced by normal maps"),
+		anno::in_group("Normal")
+	]],
+	uniform float bump_factor = float(1.0) [[
+		anno::display_name("Normal Strength"),
+		anno::description("Strength of normal map"),
+		anno::in_group("Normal"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d normalmap_texture = texture_2d() [[
+		anno::display_name("Normal Map"),
+		anno::in_group("Normal"),
+		anno::usage("normal")
+	]], 
+	uniform float detail_bump_factor = float(0.3) [[
+		anno::display_name("Detail Normal Strength"),
+		anno::in_group("Normal"),
+		anno::description("Strength of the detail normal"),
+		anno::soft_range(float(0.0), float(1.0))
+	]],
+	uniform texture_2d detail_normalmap_texture = texture_2d() [[
+		anno::display_name("Detail Normal Map"),
+		anno::in_group("Normal"),
+		anno::usage("normal")
+	]],
+	uniform bool flip_tangent_u = false [[
+        	anno::display_name("Normal Map Flip U Tangent"),
+        	anno::in_group("Normal")
+    ]],
+	uniform bool flip_tangent_v = true [[
+        	anno::display_name("Normal Map Flip V Tangent"),
+        	anno::in_group("Normal")
+    ]],
+
+
+	//  UVW Projection Group  //
+
+	uniform bool project_uvw = false [[
+		anno::display_name("Enable Project UVW Coordinates"),
+		anno::description("When enabled, UV coordinates will be generated by projecting them from a coordinate system"),
+		anno::in_group("UV")
+	]],
+	uniform bool world_or_object = false [[
+		anno::display_name("Enable World Space"),
+		anno::description("When enabled, uses world space for projection, otherwise object space is used"),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform int uv_space_index =  0 [[
+		anno::display_name("UV Space Index"),
+		anno::description("UV Space Index"),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true"),
+		anno::hard_range(int(0), int(3))
+	]],
+	
+
+	//  UVW Adjustments Group  //
+
+	uniform float2 texture_translate = float2(0.0) [[
+		anno::display_name("Texture Translate"),
+		anno::description("Controls position of texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float texture_rotate = float(0.0) [[
+		anno::display_name("Texture Rotate"),
+		anno::description("Rotates angle of texture in degrees."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 texture_scale = float2(1.0) [[
+		anno::display_name("Texture Tiling"),
+		anno::description("Controls repetition of the texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 detail_texture_translate = float2(0.0) [[
+		anno::display_name("Detail Texture Translate"),
+		anno::description("Controls the position of the detail texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float detail_texture_rotate = float(0.0) [[
+		anno::display_name("Detail Texture Rotate"),
+		anno::description("Rotates angle of the detail texture in degrees."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+	]],
+	uniform float2 detail_texture_scale = float2(1.0) [[
+		anno::display_name("Detail Texture Tiling"),
+		anno::description("Controls repetition of the detail texture."),
+		anno::in_group("UV"),
+		anno::enable_if("project_uvw == true")
+    ]],
+
+
+    //  Geometry  //
+
+    uniform float round_edges_radius = float(0.0) [[
+        anno::display_name("Round Edge Radius"),
+        anno::description("Influence radius around the edges in meters"),
+        anno::in_group("Geometry"),
+        anno::soft_range(0.0, 1.0)
+    ]],
+    uniform float round_edges_roundness = float(1.0) [[
+        anno::display_name("Round Edge Roundness"),
+        anno::description("Determines how round the edge will look"),
+        anno::in_group("Geometry"),
+        anno::hard_range(0.0, 1.0)
+    ]],
+    uniform bool round_edges_across_materials = false [[
+        anno::display_name("Round Edge Across Materials"),
+        anno::description("Normal smoothing happens only between facets of equal material, \n"
+                          "\t\tunless this parameter is set true, in which case the smoothing \n"
+                          "\t\thappens between facets irrespective of their materials"),
+        anno::in_group("Geometry")
+    ]]
+) 
+[[
+	anno::display_name("OmniPBR ClearCoat "),
+	anno::description("OmniPBR Base with support for clear coat, opacity and ORM textures."),
+	anno::in_group("Base"),
+	anno::version( 2, 1, 1),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "PBR", "opacity", "clearcoat", "omniverse", "generic"))
+]] = let {
+
+	//  UVW lookup and transformation  //
+	base::texture_coordinate_system the_system = world_or_object ? base::texture_coordinate_world : base::texture_coordinate_object;
+	
+	base::texture_coordinate_info uvw = project_uvw ?  base::coordinate_projection(
+								coordinate_system: the_system,
+								    texture_space: uv_space_index,
+								  projection_type: base::projection_cubic 
+							    ) :
+							    base::coordinate_source(
+								coordinate_system: base::texture_coordinate_uvw,
+								    texture_space: uv_space_index 
+							    );							
+	
+	base::texture_coordinate_info transformed_uvw = base::transform_coordinate(
+								  			transform: rotation_translation_scale(
+						                      scaling: float3(texture_scale.x, texture_scale.y, 1.0),
+								   			 rotation: float3(0.0, 0.0, texture_rotate/180.*math::PI ),
+							        	  translation: float3(texture_translate.x, texture_translate.y, 0.0)
+							        ),
+							        coordinate: uvw
+								);
+	
+	base::texture_coordinate_info detail_transformed_uvw = base::transform_coordinate(
+							       		  transform: rotation_translation_scale(
+								  	    	scaling: float3(detail_texture_scale.x, detail_texture_scale.y, 1.0),
+								           rotation: float3(0.0, 0.0, detail_texture_rotate/180.*math::PI ),
+								        translation: float3(detail_texture_translate.x, detail_texture_translate.y, 0.0)
+								        ),
+								        coordinate: uvw
+									);
+
+	base::texture_coordinate_info clearcoat_transformed_uvw =   base::transform_coordinate(
+									  	  transform: rotation_translation_scale(
+								            scaling: float3(clearcoat_texture_scale.x, clearcoat_texture_scale.y, 1.0),
+								           rotation: float3(0.0, 0.0, clearcoat_texture_rotate/180.*math::PI ),
+								        translation: float3(clearcoat_texture_translate.x, clearcoat_texture_translate.y, 0.f)
+									),
+									coordinate: uvw
+									);	
+
+	//  Normal calculations  //
+	OmniPBRBase::NormalData defaultData = OmniPBRBase::NormalData(state::normal(), float2(0));
+
+	OmniPBRBase::NormalData normal_data = tex::texture_isvalid(normalmap_texture) ?
+		OmniPBRBase::tangent_space_normal_roughness_texture(
+							texture:        normalmap_texture,
+							factor:         bump_factor,
+							uvw:            transformed_uvw,
+							flip_tangent_u: flip_tangent_u,
+							flip_tangent_v: flip_tangent_v	// true for dx, false for opengl
+							//flip_tangent_v: true
+
+		) : defaultData;
+	float3 the_normal = normal_data.normal;
+
+	OmniPBRBase::NormalData detail_normal_data = tex::texture_isvalid(detail_normalmap_texture) ?
+		OmniPBRBase::tangent_space_normal_roughness_texture(
+							texture:        detail_normalmap_texture,
+							factor:         detail_bump_factor,
+							uvw:            detail_transformed_uvw,
+							flip_tangent_u: flip_tangent_u,
+							flip_tangent_v: flip_tangent_v	// true for dx, false for opengl
+							) : defaultData;
+	float3 detail_normal = detail_normal_data.normal;
+
+	OmniPBRBase::NormalData clearcoat_normal_data = tex::texture_isvalid(clearcoat_normalmap_texture) ?
+		OmniPBRBase::tangent_space_normal_roughness_texture(
+								texture:        clearcoat_normalmap_texture,
+								factor:         clearcoat_bump_factor,
+								uvw:            clearcoat_transformed_uvw,
+								flip_tangent_u: flip_tangent_u,
+								flip_tangent_v: flip_tangent_v	// true for dx, false for opengl
+							) : defaultData;
+	float3 clearcoat_normal = clearcoat_normal_data.normal;
+
+
+	float3 diffuse_gloss_normal	        = tex::texture_isvalid(detail_normalmap_texture) ?  add_detail_normal(detail_normal, the_normal) : the_normal;
+	float3 flattened_clearcoat_normal   = ::math::lerp(diffuse_gloss_normal, ::state::normal(), clearcoat_flatten);
+	float3 final_clearcoat_normal       = tex::texture_isvalid(clearcoat_normalmap_texture) ? add_detail_normal(flattened_clearcoat_normal, clearcoat_normal)
+                                                                                            : flattened_clearcoat_normal;
+
+
+	//  ORM Handling  // 
+
+	float3 ORM_lookup = tex::lookup_float3( 
+                              tex: ORM_texture, 
+                            coord: float2(transformed_uvw.position.x, transformed_uvw.position.y)
+                            );
+
+	 
+	float3 roughness_lookup = tex::lookup_float3(
+					  tex: reflectionroughness_texture,
+					coord: float2(transformed_uvw.position.x, transformed_uvw.position.y)		
+					);
+	
+	float roughness_selection    = enable_ORM_texture ? ORM_lookup.y : roughness_lookup.x;
+	float reflection_roughness_s   = math::lerp(reflection_roughness_constant, roughness_selection, reflection_roughness_texture_influence);
+	float2 reflection_roughness = float2(math::sqrt(reflection_roughness_s*reflection_roughness_s + (geometry_normal_roughness_strength * normal_data.roughness.x * normal_data.roughness.x)),
+	                                     math::sqrt(reflection_roughness_s*reflection_roughness_s + (geometry_normal_roughness_strength * normal_data.roughness.y * normal_data.roughness.y)));
+
+	float2 clearcoat_reflection_roughness2 = float2(math::sqrt(clearcoat_reflection_roughness*clearcoat_reflection_roughness + (geometry_normal_roughness_strength * clearcoat_normal_data.roughness.x * clearcoat_normal_data.roughness.x)),
+												    math::sqrt(clearcoat_reflection_roughness*clearcoat_reflection_roughness + (geometry_normal_roughness_strength * clearcoat_normal_data.roughness.y * clearcoat_normal_data.roughness.y)));
+
+	//  Diffuse Color Lookup and AO  //
+	
+	base::texture_return base_lookup = base::file_texture(
+						      	  texture: diffuse_texture,
+					    	 color_offset: color(albedo_add),
+					          color_scale: color(albedo_brightness),
+					          mono_source: base::mono_luminance,
+					                  uvw: transformed_uvw,
+					                 clip: false		
+						);
+	
+	base::texture_return ao_lookup = base::file_texture(
+					 	      	  texture: ao_texture,
+					       	 color_offset: color(0.0, 0.0, 0.0),
+					          color_scale: color(1.0, 1.0, 1.0),
+					          mono_source: base::mono_average,
+					                  uvw: transformed_uvw,
+					       	         clip: false		
+						);
+
+
+	color ao_color          = enable_ORM_texture ? color(ORM_lookup.x) : ao_lookup.tint;
+	color desaturated_base  = math::lerp(base_lookup.tint, color(base_lookup.mono), albedo_desaturation);
+	color diffuse           = tex::texture_isvalid(diffuse_texture)? desaturated_base : diffuse_color_constant;
+	color tinted_diffuse    = multiply_colors(diffuse, diffuse_tint, 1.0).tint;
+	
+	color base_color = multiply_colors(
+			   	color_1: tinted_diffuse,
+				color_2: ao_color,
+				 weight: ao_to_diffuse
+				).tint;
+
+	
+	//  Metalness   //
+
+	float3 metallic_lookup = tex::lookup_float3(
+				tex: metallic_texture,
+				coord: float2(transformed_uvw.position.x, transformed_uvw.position.y)
+				);
+					
+	float metallic_selection = enable_ORM_texture ? ORM_lookup.z : metallic_lookup.x;
+	float metallic = math::lerp(metallic_constant, metallic_selection, metallic_texture_influence);
+
+
+	//  Emission   //
+
+	color emission_color_texture = tex::texture_isvalid(emissive_color_texture) ?
+                                        base::file_texture(
+												texture: emissive_color_texture,
+                                           color_offset: color(0.0, 0.0, 0.0),
+                                            color_scale: color(1.0, 1.0, 1.0),
+                                            mono_source: base::mono_average,
+						    						uvw: transformed_uvw,
+						   						   clip: false        
+                                            ).tint : emissive_color;
+
+    color emission_mask_texture = tex::texture_isvalid(emissive_mask_texture) ?
+                                        base::file_texture(
+												texture: emissive_mask_texture,
+                                           color_offset: color(0.0, 0.0, 0.0),
+                                            color_scale: color(1.0, 1.0, 1.0),
+                                            mono_source: base::mono_average,
+						    						uvw: transformed_uvw,
+						   						   clip: false        
+                                            ).tint : color(1.0);
+  
+    color final_emission_color = enable_emission ? emission_color_texture * emission_mask_texture: color(0.0);
+
+    //  Opacity   //
+	
+    float opacity_value = enable_opacity_texture ? base::file_texture(
+						    texture: opacity_texture,
+						mono_source: opacity_mode,
+								uvw: transformed_uvw
+						).mono : opacity_constant;
+
+    float cutout_opacity = enable_opacity ? ((opacity_threshold == 0.0) ? opacity_value : ((opacity_value >= opacity_threshold) ? 1.0 : 0)) : 1.0;
+
+	material base = OmniPBRBase::OmniPBRBase(
+		diffuse_reflection_color: base_color, 
+		specular_reflection_aniso_roughness: reflection_roughness, 
+		specular_level: specular_level,
+		metalness: metallic,
+		enable_emission: enable_emission,
+		emission_color: final_emission_color,
+		emission_intensity: emissive_intensity,
+		enable_coat: enable_clearcoat,
+		coat_weight: clearcoat_weight,
+		coat_color: clearcoat_tint,
+		coat_transparency: clearcoat_transparency,
+		coat_aniso_roughness: clearcoat_reflection_roughness2,
+		coat_ior: clearcoat_ior,
+		enable_opacity: enable_opacity,
+		geometry_opacity: cutout_opacity,
+		clearcoat_geometry_normal: final_clearcoat_normal,
+		round_edges_radius: round_edges_radius,
+		round_edges_roundness: round_edges_roundness,
+		round_edges_across_materials: round_edges_across_materials,
+		geometry_normal: diffuse_gloss_normal
+    );
+
+} in material(
+surface:  base.surface,
+geometry: base.geometry
+);

standardbots_spark/spark/configuration/spark_base.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55baa19414ed45a233f398861ea78f49915f6a7f43b785bacf483b5dfd3cf008
+size 1924727

standardbots_spark/spark/configuration/spark_materials.usda

@@ -0,0 +1,171 @@
+#usda 1.0
+(
+    defaultPrim = "spark"
+)
+
+over "spark"
+{
+    over "Looks"
+    {
+        over "material_base_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_base_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_forearm_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_forearm_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_shoulder_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_shoulder_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_upper_arm_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_upper_arm_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_wrist_1_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_wrist_1_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_wrist_2_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_wrist_2_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "material_wrist_3_link_color"
+        {
+            token outputs:surface.connect = </spark/Looks/material_wrist_3_link_color/PreviewSurface.outputs:surface>
+
+            over "Shader"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (0.86667, 0.86667, 0.8902)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+
+        over "DefaultMaterial"
+        {
+            token outputs:surface.connect = </spark/Looks/DefaultMaterial/PreviewSurface.outputs:surface>
+
+            over "DefaultMaterial"
+            {
+                float inputs:metallic_constant = 0
+                float inputs:reflection_roughness_constant = 0.32
+            }
+
+            def Shader "PreviewSurface"
+            {
+                uniform token info:id = "UsdPreviewSurface"
+                color3f inputs:diffuseColor = (1, 1, 1)
+                float inputs:metallic = 0
+                float inputs:roughness = 0.32
+                token outputs:surface
+            }
+        }
+    }
+}
+

standardbots_spark/spark/configuration/spark_visual.usda

@@ -0,0 +1,799 @@
+#usda 1.0
+(
+    """Visual-appearance layer for spark, built by tools/texture_nvidia_asset.py on 2026-09-29.
+Replaces the STL visual meshes NVIDIA's URDF import made with the textured meshes the
+web visualizer renders (../meshes/visual/<link>.usd, converted from its GLBs), each
+rotated into its link frame by the measured rotation, and sets metallic_factor to the
+visualizer's runtime value (0.5; the GLBs leave it unset = glTF 1.0).
+Geometry, collision and physics layers are untouched; removing this layer from
+spark_physics.usd's subLayers restores NVIDIA's plain STL look."""
+    defaultPrim = "spark"
+    subLayers = [
+        @./spark_base.usd@
+    ]
+)
+
+over "visuals"
+{
+    over "base_link"
+    {
+        over "base_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "base_link_textured" (
+            "from base_link.glb (sha256 1b4f5bace0bb)"
+            prepend references = @../meshes/visual/base_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "URDF_SPARK_GEN2___Base___base_link_Base_URDF_color_212_217__009"
+                {
+                    token outputs:surface.connect = </visuals/base_link/base_link_textured/Looks/URDF_SPARK_GEN2___Base___base_link_Base_URDF_color_212_217__009/PreviewSurface.outputs:surface>
+
+                    over "URDF_SPARK_GEN2___Base___base_link_Base_URDF_color_212_217__009"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.831373, 0.85098, 0.858824)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "New_Arm_Hard_Anodise_Black__1_010"
+                {
+                    token outputs:surface.connect = </visuals/base_link/base_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_010/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_010"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Rough___1__1_010"
+                {
+                    token outputs:surface.connect = </visuals/base_link/base_link_textured/Looks/Aluminum_Rough___1__1_010/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Rough___1__1_010"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "shoulder_link"
+    {
+        over "shoulder_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "shoulder_link_textured" (
+            "from shoulder_link.glb (sha256 d077660d44eb)"
+            prepend references = @../meshes/visual/shoulder_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "New_Arm_Hard_Anodise_Black__1_014"
+                {
+                    token outputs:surface.connect = </visuals/shoulder_link/shoulder_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_014/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_014"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_001"
+                {
+                    token outputs:surface.connect = </visuals/shoulder_link/shoulder_link_textured/Looks/Hard_Rough_Plastic_Orange___1_001/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_001"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_001"
+                {
+                    token outputs:surface.connect = </visuals/shoulder_link/shoulder_link_textured/Looks/Aluminum_Brushed_90___1__1_001/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_001"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "upper_arm_link"
+    {
+        over "upper_arm_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "upper_arm_link_textured" (
+            "from upper_arm_link.glb (sha256 033d05a50997)"
+            prepend references = @../meshes/visual/upper_arm_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "New_Arm_Hard_Anodise_Black__1_015"
+                {
+                    token outputs:surface.connect = </visuals/upper_arm_link/upper_arm_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_015/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_015"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_002"
+                {
+                    token outputs:surface.connect = </visuals/upper_arm_link/upper_arm_link_textured/Looks/Hard_Rough_Plastic_Orange___1_002/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_002"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Rubber__1__1___1"
+                {
+                    token outputs:surface.connect = </visuals/upper_arm_link/upper_arm_link_textured/Looks/Rubber__1__1___1/PreviewSurface.outputs:surface>
+
+                    over "Rubber__1__1___1"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0004, 0.0004, 0.0004)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_003"
+                {
+                    token outputs:surface.connect = </visuals/upper_arm_link/upper_arm_link_textured/Looks/Hard_Rough_Plastic_Orange___1_003/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_003"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_002"
+                {
+                    token outputs:surface.connect = </visuals/upper_arm_link/upper_arm_link_textured/Looks/Aluminum_Brushed_90___1__1_002/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_002"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "forearm_link"
+    {
+        over "forearm_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "forearm_link_textured" (
+            "from forearm_link.glb (sha256 327f01f23b34)"
+            prepend references = @../meshes/visual/forearm_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "Rubber__1__1___1_001"
+                {
+                    token outputs:surface.connect = </visuals/forearm_link/forearm_link_textured/Looks/Rubber__1__1___1_001/PreviewSurface.outputs:surface>
+
+                    over "Rubber__1__1___1_001"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0004, 0.0004, 0.0004)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "New_Arm_Hard_Anodise_Black__1_016"
+                {
+                    token outputs:surface.connect = </visuals/forearm_link/forearm_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_016/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_016"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_004"
+                {
+                    token outputs:surface.connect = </visuals/forearm_link/forearm_link_textured/Looks/Hard_Rough_Plastic_Orange___1_004/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_004"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_003"
+                {
+                    token outputs:surface.connect = </visuals/forearm_link/forearm_link_textured/Looks/Aluminum_Brushed_90___1__1_003/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_003"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "URDF_SPARK_GEN2___J2___forearm_link_J2_URDF_color_192_192_192"
+                {
+                    token outputs:surface.connect = </visuals/forearm_link/forearm_link_textured/Looks/URDF_SPARK_GEN2___J2___forearm_link_J2_URDF_color_192_192_192/PreviewSurface.outputs:surface>
+
+                    over "URDF_SPARK_GEN2___J2___forearm_link_J2_URDF_color_192_192_192"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.752941, 0.752941, 0.752941)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "wrist_1_link"
+    {
+        over "wrist_1_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "wrist_1_link_textured" (
+            "from wrist_1_link.glb (sha256 d4212951eafc)"
+            prepend references = @../meshes/visual/wrist_1_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "Rubber__1__1___1_002"
+                {
+                    token outputs:surface.connect = </visuals/wrist_1_link/wrist_1_link_textured/Looks/Rubber__1__1___1_002/PreviewSurface.outputs:surface>
+
+                    over "Rubber__1__1___1_002"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0004, 0.0004, 0.0004)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_005"
+                {
+                    token outputs:surface.connect = </visuals/wrist_1_link/wrist_1_link_textured/Looks/Hard_Rough_Plastic_Orange___1_005/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_005"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "New_Arm_Hard_Anodise_Black__1_017"
+                {
+                    token outputs:surface.connect = </visuals/wrist_1_link/wrist_1_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_017/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_017"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_004"
+                {
+                    token outputs:surface.connect = </visuals/wrist_1_link/wrist_1_link_textured/Looks/Aluminum_Brushed_90___1__1_004/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_004"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "wrist_2_link"
+    {
+        over "wrist_2_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "wrist_2_link_textured" (
+            "from wrist_2_link.glb (sha256 d05b7bf89c44)"
+            prepend references = @../meshes/visual/wrist_2_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.7071067811865475, 0.7071067811865476, 0, 0)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "Rubber__1__1___1_003"
+                {
+                    token outputs:surface.connect = </visuals/wrist_2_link/wrist_2_link_textured/Looks/Rubber__1__1___1_003/PreviewSurface.outputs:surface>
+
+                    over "Rubber__1__1___1_003"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0004, 0.0004, 0.0004)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Hard_Rough_Plastic_Orange___1_006"
+                {
+                    token outputs:surface.connect = </visuals/wrist_2_link/wrist_2_link_textured/Looks/Hard_Rough_Plastic_Orange___1_006/PreviewSurface.outputs:surface>
+
+                    over "Hard_Rough_Plastic_Orange___1_006"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 0.235031, 0.00221455)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "New_Arm_Hard_Anodise_Black__1_018"
+                {
+                    token outputs:surface.connect = </visuals/wrist_2_link/wrist_2_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_018/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_018"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_005"
+                {
+                    token outputs:surface.connect = </visuals/wrist_2_link/wrist_2_link_textured/Looks/Aluminum_Brushed_90___1__1_005/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_005"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+
+    over "wrist_3_link"
+    {
+        over "wrist_3_link" (
+            active = false
+        )
+        {
+        }
+
+        def Xform "wrist_3_link_textured" (
+            "from wrist_3_link.glb (sha256 0c303efc4df4)"
+            prepend references = @../meshes/visual/wrist_3_link.usd@
+        )
+        {
+            quatd xformOp:orient = (0.5, 0.5, 0.5, 0.5)
+            double3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            over "Looks"
+            {
+                over "New_Arm_Hard_Anodise_Black__1_021"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_021/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_021"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Brushed_90___1__1_007"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/Aluminum_Brushed_90___1__1_007/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Brushed_90___1__1_007"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Rough___1__1_015"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/Aluminum_Rough___1__1_015/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Rough___1__1_015"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "New_Arm_Hard_Anodise_Black__1_022"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/New_Arm_Hard_Anodise_Black__1_022/PreviewSurface.outputs:surface>
+
+                    over "New_Arm_Hard_Anodise_Black__1_022"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.0117647, 0.0117647, 0.0117647)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "URDF_SPARK_GEN2___J5___wrist_3_link_URDF_color_202_209_238_001"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/URDF_SPARK_GEN2___J5___wrist_3_link_URDF_color_202_209_238_001/PreviewSurface.outputs:surface>
+
+                    over "URDF_SPARK_GEN2___J5___wrist_3_link_URDF_color_202_209_238_001"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Aluminum_Rough___1__1_016"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/Aluminum_Rough___1__1_016/PreviewSurface.outputs:surface>
+
+                    over "Aluminum_Rough___1__1_016"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (0.792157, 0.819608, 0.933333)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+
+                over "Paint_Matte_White__1"
+                {
+                    token outputs:surface.connect = </visuals/wrist_3_link/wrist_3_link_textured/Looks/Paint_Matte_White__1/PreviewSurface.outputs:surface>
+
+                    over "Paint_Matte_White__1"
+                    {
+                        float inputs:metallic_factor = 0.5
+                    }
+
+                    def Shader "PreviewSurface"
+                    {
+                        uniform token info:id = "UsdPreviewSurface"
+                        color3f inputs:diffuseColor = (1, 1, 1)
+                        float inputs:ior = 1.45
+                        float inputs:metallic = 0.5
+                        float inputs:roughness = 0.5527864
+                        token outputs:surface
+                    }
+                }
+            }
+        }
+    }
+}
+

standardbots_spark/spark/meshes/visual/base_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64a1599e205750687d13b1504c21e26218f4423f7d366d79fbb809386d2d702e
+size 4456462

standardbots_spark/spark/meshes/visual/forearm_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed00f891f0e17e32d1ee1a5f1d7a4b401532c2630e7c1e0d6f3548507d200a3f
+size 11090641

standardbots_spark/spark/meshes/visual/gltf/pbr.mdl

@@ -0,0 +1,1004 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+mdl 1.8;
+
+import ::anno::*;
+import ::base::*;
+import ::df::*;
+import ::math::*;
+import ::state::*;
+import ::tex::*;
+import ::scene::*;
+import ::limits::*;
+
+export enum gltf_alpha_mode {
+    opaque,
+    mask,
+    blend
+};
+
+export enum gltf_wrapping_mode {
+    clamp_to_edge = 33071,
+    mirrored_repeat = 33648,
+    repeat = 10497
+};
+
+export struct gltf_texture_lookup_value
+{
+    bool valid = false;
+    float4 value = float4(0.0, 0.0, 0.0, 1.0);
+};
+
+export struct gltf_normal_texture_lookup_value
+{
+    bool valid = false;
+    float3 value = float3(0.0);
+};
+
+float compute_opacity(gltf_alpha_mode mode, float alpha, float cutoff) {
+    switch (mode) {
+        case mask:
+            return alpha < cutoff ? 0.0 : 1.0;
+        case blend:
+            return alpha;
+        case opaque:
+            return 1.0;
+    }
+}
+
+float4 gltf_prepare_tex_float4(gltf_texture_lookup_value sample, float4 default_value = float4(1.0)) {
+    return sample.valid ? sample.value : default_value;
+}
+
+float3 gltf_prepare_tex_float3(gltf_texture_lookup_value sample, float3 default_value = float3(1.0)) {
+    return sample.valid ? float3(sample.value.x, sample.value.y, sample.value.z) : default_value;
+}
+
+float3 gltf_prepare_normal(gltf_normal_texture_lookup_value sample) {
+    return sample.valid ? sample.value : state::normal();
+}
+
+float gltf_prepare_occlusion(gltf_texture_lookup_value sample, float occlusion_strength) {
+    float occulusion = sample.valid ? sample.value.x : 1.0;
+    return math::lerp(1.0, occulusion, occlusion_strength);
+}
+
+color gltf_perpare_emission(gltf_texture_lookup_value sample, color emissive_factor) {
+    return emissive_factor * color(gltf_prepare_tex_float3(sample));
+}
+
+::tex::wrap_mode convert_wrap_mode(gltf_wrapping_mode mode)
+{
+    if (mode == clamp_to_edge)
+        return ::tex::wrap_clamp;
+    if (mode == mirrored_repeat)
+        return ::tex::wrap_mirrored_repeat;
+
+    return ::tex::wrap_repeat;
+}
+
+float2 khr_texture_transform_apply(
+    float2 coord,
+    float2 offset,
+    float rotation,
+    float2 scale
+)
+{
+    // MDL expects the texture coordinate origin at the bottom left (gltf at top left)
+    // Assuming the renderer follows the MDL specification in which case the coordinates
+    // have been flipped either while loading the glTF geometry or while setting up the state.
+
+    // Undo the flipping for the transformation to get into the original glTF texture space.
+    coord = float2(coord.x, 1.0f - coord.y);
+
+    // first scale
+    coord = coord * scale;
+    // then rotate
+    float cos_rotation = ::math::cos(rotation);
+    float sin_rotation = ::math::sin(rotation);
+    coord = float2(cos_rotation * coord.x + sin_rotation * coord.y, cos_rotation * coord.y - sin_rotation * coord.x);
+    // then translate
+    coord = coord + offset;
+
+    // flip back
+    coord = float2(coord.x, 1.0f - coord.y);
+    return coord;
+}
+
+export gltf_texture_lookup_value gltf_texture_lookup(
+    uniform texture_2d texture = texture_2d()
+    [[
+        anno::in_group("Source"),
+        anno::display_name("Texture"),
+        anno::description("Texture File")
+    ]],
+    uniform int tex_coord_index = 0
+    [[
+        anno::in_group("Source"),
+        anno::display_name("Coordinate Set"),
+        anno::description("Texture coordinate set (UV-Set). KHR_texture_transform overrides the textureInfo texCoord value if supplied."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+
+    uniform float2 offset = float2(0.0f, 0.0)
+    [[
+        anno::in_group("Texture Transform"),
+        anno::display_name("Offset"),
+        anno::description("The offset of the UV coordinate origin as a factor of the texture dimensions."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+    uniform float rotation = 0.0
+    [[
+        anno::hard_range(0.0, 2.0 * ::math::PI),
+        anno::in_group("Texture Transform"),
+        anno::display_name("Rotation"),
+        anno::description("Rotate the UVs by this many radians counter-clockwise around the origin. This is equivalent to a similar rotation of the image clockwise."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+    uniform float2 scale = float2(1.0f, 1.0f)
+    [[
+        anno::in_group("Texture Transform"),
+        anno::display_name("Scale"),
+        anno::description("The scale factor applied to the components of the UV coordinates."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+
+    uniform gltf_wrapping_mode wrap_s = repeat
+    [[
+        anno::in_group("Sampler"),
+        anno::display_name("Wrap S"),
+        anno::description("S (U) wrapping mode."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+    uniform gltf_wrapping_mode wrap_t = repeat
+    [[
+        anno::in_group("Sampler"),
+        anno::display_name("Wrap T"),
+        anno::description("T (V) wrapping mode."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]]
+)
+[[
+    anno::author("NVIDIA Corporation"),
+    anno::display_name("GLTF Texture Lookup"),
+    anno::description("Function to read a color or color with alpha channel texture.")
+]]
+{
+    gltf_texture_lookup_value tex_ret;
+    if (!tex::texture_isvalid(texture))
+        return tex_ret;
+
+    float3 tex_coord3 = state::texture_coordinate(tex_coord_index);
+    float2 tex_coord = khr_texture_transform_apply(
+        coord: float2(tex_coord3.x, tex_coord3.y),
+        offset: offset,
+        rotation: rotation,
+        scale: scale);
+
+    tex_ret.value = tex::lookup_float4(
+        tex: texture,
+        coord: tex_coord,
+        wrap_u: convert_wrap_mode(wrap_s),
+        wrap_v: convert_wrap_mode(wrap_t));
+    tex_ret.valid = true;
+    return tex_ret;
+}
+
+export gltf_normal_texture_lookup_value gltf_normal_texture_lookup(
+    uniform texture_2d texture = texture_2d()
+    [[
+        anno::in_group("Source"),
+        anno::display_name("Texture"),
+        anno::description("Texture File")
+    ]],
+    uniform float normal_scale_factor = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Source"),
+        anno::display_name("Normal Scale Factor"),
+        anno::description("Strength of the base layer normal mapping."),
+        anno::enable_if("::tex::texture_isvalid(texture)")
+    ]],
+    uniform int tex_coord_index = 0
+    [[
+        anno::in_group("Source"),
+        anno::display_name("Coordinate Set"),
+        anno::description("Texture coordinate set (UV-Set). KHR_texture_transform overrides the textureInfo texCoord value if supplied."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+    uniform int tex_tangent_index = 0
+    [[
+        anno::hidden(),
+        anno::in_group("Source"),
+        anno::display_name("Coordinate Set"),
+        anno::description("Tangent to be to construct the tangent frame."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+
+    uniform float2 offset = float2(0.0f, 0.0)
+    [[
+        anno::in_group("Texture Transform"),
+        anno::display_name("Offset"),
+        anno::description("The offset of the UV coordinate origin as a factor of the texture dimensions."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+    uniform float rotation = 0.0
+    [[
+        anno::hard_range(0.0, 2.0 * ::math::PI),
+        anno::in_group("Texture Transform"),
+        anno::display_name("Rotation"),
+        anno::description("Rotate the UVs by this many radians counter-clockwise around the origin. This is equivalent to a similar rotation of the image clockwise."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+    uniform float2 scale = float2(1.0f, 1.0f)
+    [[
+        anno::in_group("Texture Transform"),
+        anno::display_name("Scale"),
+        anno::description("The scale factor applied to the components of the UV coordinates."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+
+    uniform gltf_wrapping_mode wrap_s = repeat
+    [[
+        anno::in_group("Sampler"),
+        anno::display_name("Wrap S"),
+        anno::description("S (U) wrapping mode."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]],
+    uniform gltf_wrapping_mode wrap_t = repeat
+    [[
+        anno::in_group("Sampler"),
+        anno::display_name("Wrap T"),
+        anno::description("T (V) wrapping mode."),
+        anno::enable_if("::tex::texture_isvalid(texture) && normal_scale_factor>0.0")
+    ]]
+)
+[[
+    anno::author("NVIDIA Corporation"),
+    anno::display_name("GLTF Normal Texture Lookup"),
+    anno::description("Function to read a normal texture.")
+]]
+{
+    gltf_normal_texture_lookup_value tex_ret;
+    if (!::tex::texture_isvalid(texture))
+        return tex_ret;
+
+    tex_ret.value = base::tangent_space_normal_texture(
+        texture: texture,
+        factor: normal_scale_factor,
+        uvw: base::transform_coordinate(
+            transform: base::rotation_translation_scale(
+                rotation: float3(0, 0, rotation),
+                translation: float3(offset.x, offset.y, 0),
+                scaling: float3(scale.x, scale.y, 1)
+            ),
+            coordinate: base::texture_coordinate_info(
+                position: state::texture_coordinate(tex_coord_index),
+                tangent_u: state::texture_tangent_u(tex_tangent_index),
+                tangent_v: state::texture_tangent_v(tex_tangent_index)
+            )
+        ),
+        wrap_u: convert_wrap_mode(wrap_s),
+        wrap_v: convert_wrap_mode(wrap_t));
+    tex_ret.valid = true;
+    return tex_ret;
+}
+
+export material gltf_material(
+    // base color
+    uniform color base_color_factor = color(1.0)
+    [[
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("Base Color Factor"),
+        anno::description("The base color of the material. Multiplied to the 'Base Color Texture' if available.")
+    ]],
+
+    gltf_texture_lookup_value base_color_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("Base Color Texture"),
+        anno::description("The base color of the material. Influenced by the 'Base Color Factor'.")
+    ]],
+
+    // KHR_materials_specular
+    uniform float specular_factor = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Specular"),
+        anno::display_name("Specular Factor"),
+        anno::description("The strength of the specular reflection. Multiplied to the 'Specular Texture' if available.")
+    ]],
+    gltf_texture_lookup_value specular_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Specular"),
+        anno::display_name("Specular Texture"),
+        anno::description("A texture that defines the strength of the specular reflection, stored in the alpha (A) channel. This will be multiplied by the 'Specular Factor'.")
+    ]],
+    uniform color specular_color_factor = color(1.0)
+    [[
+        anno::in_group("Specular"),
+        anno::display_name("Specular Color Factor"),
+        anno::description("The F0 color of the specular reflection (linear RGB). Multiplied to the 'Specular Color Texture' if available.")
+    ]],
+    gltf_texture_lookup_value specular_color_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Specular"),
+        anno::display_name("Specular Color Texture"),
+        anno::description("A texture that defines the F0 color of the specular reflection, stored in the RGB channels and encoded in sRGB. This texture will be multiplied by 'Specular Color Factor'.")
+    ]],
+
+    // metallic roughness
+    uniform float metallic_factor = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("Metallic Factor"),
+        anno::description("The metalness of the material. Select between dielectric (0.0) and metallic (1.0). Multiplied to the 'Metal/Rough Texture' value if available.")
+    ]],
+
+    uniform float roughness_factor = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("Roughness Factor"),
+        anno::description("The roughness of the material. Select between very glossy (0.0) and dull (1.0). Multiplied to the 'Metal/Rough Texture' value if available.")
+    ]],
+    gltf_texture_lookup_value metallic_roughness_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("Metal/Rough Texture"),
+        anno::description("Metallic in the red or blue component and roughness in the green component. Influenced by the 'Metallic Factor' and 'Roughness Factor'."),
+        anno::enable_if("metallic_factor>0.0 || roughness_factor>0.0")
+    ]],
+
+    // KHR_materials_anisotropy
+    uniform float anisotropy_strength = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Anisotropy"),
+        anno::display_name("Anisotropy Strength"),
+        anno::description("The anisotropy strength. When the anisotropy texture is present, this value is multiplied by the texture's blue channel.")
+    ]],
+    uniform float anisotropy_rotation = 0.0
+    [[
+        anno::hard_range(0.0, 2.0 * ::math::PI),
+        anno::in_group("Anisotropy"),
+        anno::display_name("Anisotropy Rotation"),
+        anno::description("The rotation of the anisotropy in tangent, bitangent space, measured in radians counter-clockwise from the tangent. When the anisotropy texture is present, this value provides additional rotation to the vectors in the texture.")
+    ]],
+    gltf_texture_lookup_value anisotropy_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Anisotropy"),
+        anno::display_name("Anisotropy Texture"),
+        anno::description("The anisotropy texture. Red and green channels represent the anisotropy direction in [− 1, 1] tangent, bitangent space to be rotated by the anisotropy rotation. The blue channel contains strength as [0, 1] to be multiplied by the anisotropy strength.")
+    ]],
+
+    // KHR_materials_ior
+    uniform float ior = 1.5
+    [[
+        anno::hard_range(1.0, 5.0),
+        anno::in_group("Metallic Roughness"),
+        anno::display_name("IOR"),
+        anno::description("The index of refraction.")
+    ]],
+
+    // normal map
+    gltf_normal_texture_lookup_value normal_texture = gltf_normal_texture_lookup()
+    [[
+        anno::in_group("Normal Mapping"),
+        anno::display_name("Normal Texture"),
+        anno::description("Base layer normal map.")
+    ]],
+
+    // KHR_materials_transmission
+    uniform float transmission_factor = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Transmission"),
+        anno::display_name("Transmission Factor"),
+        anno::description("The base percentage of light that is transmitted through the surface. Multiplied to the 'Transmission Texture' if available.")
+    ]],
+    gltf_texture_lookup_value transmission_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Transmission"),
+        anno::display_name("Transmission Texture"),
+        anno::description("A texture that defines the transmission percentage of the surface, stored in the R channel. Influenced by the 'Transmission Factor'."),
+        anno::enable_if("transmission_factor>0")
+    ]],
+
+    // KHR_materials_sheen
+    uniform color sheen_color_factor = color(0.0)
+    [[
+        anno::in_group("Sheen"),
+        anno::display_name("Sheen Color Factor"),
+        anno::description("The sheen color in linear space. Multiplied to the 'Sheen Color Texture' if available.")
+    ]],
+    gltf_texture_lookup_value sheen_color_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Sheen"),
+        anno::display_name("Sheen Color Texture"),
+        anno::description("The sheen color (RGB). The sheen color is in sRGB transfer function. Influenced by the 'Sheen Color Factor'.")
+    ]],
+    uniform float sheen_roughness_factor = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Sheen"),
+        anno::display_name("Sheen Roughness Factor"),
+        anno::description("The sheen roughness. Multiplied to the 'Sheen Roughness Texture' if available.")
+    ]],
+    gltf_texture_lookup_value sheen_roughness_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Sheen"),
+        anno::display_name("Sheen Roughness Texture"),
+        anno::description("The sheen roughness (Alpha) texture. Influenced by the 'Sheen Roughness Factor'.")
+    ]],
+
+    // KHR_materials_clearcoat
+    uniform float clearcoat_factor = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Clearcoat"),
+        anno::display_name("Clearcoat Factor"),
+        anno::description("Strength of the clearcoat. Multiplied to the 'Clearcoat Texture' if available.")
+    ]],
+    gltf_texture_lookup_value clearcoat_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Clearcoat"),
+        anno::display_name("Clearcoat Texture"),
+        anno::description("Strength of the clearcoat. Influenced by the 'Clearcoat Factor'."),
+        anno::enable_if("clearcoat_factor>0")
+    ]],
+    uniform float clearcoat_roughness_factor = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Clearcoat"),
+        anno::display_name("Clearcoat Roughness Factor"),
+        anno::description("The clearcoat layer roughness. Multiplied to the 'Clearcoat Roughness Texture' if available."),
+        anno::enable_if("clearcoat_factor>0.0")
+    ]],
+    gltf_texture_lookup_value clearcoat_roughness_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Clearcoat"),
+        anno::display_name("Clearcoat Roughness Texture"),
+        anno::description("The clearcoat layer roughness texture. Influenced by the 'Clearcoat Roughness Texture'."),
+        anno::enable_if("clearcoat_factor>0.0 && clearcoat_roughness_factor>0.0")
+    ]],
+    gltf_normal_texture_lookup_value clearcoat_normal_texture = gltf_normal_texture_lookup()
+    [[
+        anno::in_group("Clearcoat"),
+        anno::display_name("Clearcoat Normal"),
+        anno::description("The clearcoat normal map texture."),
+        anno::enable_if("clearcoat_factor>0.0")
+    ]],
+
+    // KHR_materials_iridescence
+    uniform float iridescence_factor = 0.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence Factor"),
+        anno::description("Strength of the iridescence. Multiplied to the 'Iridescence Texture' if available.")
+    ]],
+    gltf_texture_lookup_value iridescence_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence Texture"),
+        anno::description("Strength of the iridescence. Uses only the red channel, assuming linear space. Influenced by the 'Iridescence Factor'."),
+        anno::enable_if("iridescence_factor>0")
+    ]],
+    uniform float iridescence_ior = 1.3
+    [[
+        anno::soft_range(1.0, 5.0),
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence IOR"),
+        anno::description("The index of refraction of the dielectric thin-film layer.")
+    ]],
+    uniform float iridescence_thickness_minimum = 100
+    [[
+        anno::soft_range(0.0, 600.0),
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence Thickness Minimum"),
+        anno::description("The minimum thickness of the thin-film layer given in nanometers.")
+    ]],
+    uniform float iridescence_thickness_maximum = 400
+    [[
+        anno::soft_range(0.0, 1000.0),
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence Thickness Maximum"),
+        anno::description("The maximum thickness of the thin-film layer given in nanometers. Used as thickness if no 'Iridescence Thickness Texture' if available.")
+    ]],
+    gltf_texture_lookup_value iridescence_thickness_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Iridescence"),
+        anno::display_name("Iridescence Thickness Texture"),
+        anno::description("The thickness texture of the thin-film layer.  Uses only the red channel, assuming linear space. Used to blend between 'Iridescence Thickness Minimum' and 'Iridescence Thickness Maximum'."),
+        anno::enable_if("iridescence_factor>0")
+    ]],
+
+    // emission
+    uniform color emissive_factor = color(0.0)
+    [[
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Factor"),
+        anno::description("The emissive color of the material. Multiplied to the 'Emissive Texture' if available.")
+    ]],
+    gltf_texture_lookup_value emissive_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Texture"),
+        anno::description("The emissive map texture. Influenced by the 'Emissive Factor'."),
+        anno::enable_if("::math::average(emissive_factor)>0.0")
+    ]],
+    // KHR_materials_emissive_strength
+    uniform float emissive_strength = 1.0
+    [[
+        anno::soft_range(0.0, 10000),
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Strength"),
+        anno::description("The maximum strength of the emissive texture. Multiplied to the 'Emissive Factor'."),
+        anno::enable_if("::math::average(emissive_factor)>0.0")
+    ]],
+
+    // KHR_materials_volume
+    uniform bool thin_walled = true
+    [[
+        anno::in_group("Volume"),
+        anno::display_name("Thin-walled"),
+        anno::description("If true the material is thin-walled. Otherwise the material is a volume boundary. The doubleSided property has no effect on volume boundaries. Note, the thickness parameters are ignored since ray-tracing is used to compute the traveled distance within the volume.")
+    ]],
+    uniform float attenuation_distance = 0.0
+    [[
+        anno::soft_range(0.0, ::limits::FLOAT_MAX),
+        anno::in_group("Volume"),
+        anno::display_name("Attenuation Distance"),
+        anno::description("Density of the medium given as the average distance that light travels in the medium before interacting with a particle. The value is given in world space. A value 0.0 disables it")
+    ]],
+    uniform color attenuation_color = color(1.0)
+    [[
+        anno::in_group("Volume"),
+        anno::display_name("Attenuation Color"),
+        anno::description("The color that white light turns into due to absorption when reaching the attenuation distance.")
+    ]],
+
+    // ambient occlusion
+    gltf_texture_lookup_value occlusion_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Occlusion"),
+        anno::display_name("Occlusion Texture"),
+        anno::description("The occlusion map texture. Influenced by the 'Occlusion Strength'.")
+    ]],
+    uniform float occlusion_strength = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Occlusion"),
+        anno::display_name("Occlusion Strength"),
+        anno::description("A scalar multiplier controlling the amount of occlusion applied. Multiplied to the 'Occlusion Texture'.")
+    ]],
+
+    // alpha
+    uniform gltf_alpha_mode alpha_mode = opaque
+    [[
+        anno::in_group("Opacity"),
+        anno::display_name("Alpha Mode"),
+        anno::description("Select how to interpret the alpha value.")
+    ]],
+    uniform float base_alpha = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Opacity"),
+        anno::display_name("Base Alpha"),
+        anno::description("Select between transparent (0.0) and opaque (1.0). Multiplied to the base color texture alpha channel if available."),
+        anno::enable_if("alpha_mode!=opaque")
+    ]],
+    // alpha for gltf_alpha_mode::mask
+    uniform float alpha_cutoff  = 0.5
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Opacity"),
+        anno::display_name("Alpha Cutoff"),
+        anno::description("Threshold to decide between fully transparent and fully opaque when alpha mode is 'mask'."),
+        anno::enable_if("alpha_mode==mask")
+    ]],
+
+    uniform string vertex_color_name = string("displayColor")
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Vertex Color Name"),
+        anno::description("Name of the vertex color primvar usually COLOR_0(gltf), or displayColor(usd)")
+    ]],
+
+    uniform bool use_vertex_color_alpha = false
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Use Opacity Channel From Vertex Color"),
+        anno::description("Multipy the Alpha or .w channel from the vertex color with the base alpha value.")
+    ]],
+
+    uniform string vertex_opacity_name = string("displayOpacity")
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Vertex Opacity Name"),
+        anno::description("Name of the vertex opacity primvar usually the fourth component of COLOR_0(gltf), or displayOpacity(usd)")
+    ]]
+
+) [[
+    anno::author("NVIDIA Corporation"),
+    anno::display_name("GLTF Material - Metallic-Roughness"),
+    anno::description("Metallic-Roughness Material that takes the GLTF PBR model and KHR extension parameters as input.")
+]] = let {
+
+    // handling GLTF parameters
+    // ------------------------------------------------------------------------
+
+    float4 base_float4 = gltf_prepare_tex_float4(base_color_texture) * ::scene::data_lookup_float4(vertex_color_name, float4(1.0)); // apply vertex color
+    color base_color = base_color_factor * color(base_float4.x, base_float4.y, base_float4.z);
+
+    float alpha = base_alpha * (use_vertex_color_alpha == 1 ? base_float4.w : 1.0) * ((vertex_color_name != vertex_opacity_name) ? ::scene::data_lookup_float(vertex_opacity_name, float(1.0)) : 1.0);
+
+    float3 metallic_roughness = gltf_prepare_tex_float3(metallic_roughness_texture);
+    float metallic = metallic_factor * metallic_roughness.z;
+    float roughness = roughness_factor * metallic_roughness.y;
+
+    float3 normal = gltf_prepare_normal(normal_texture);
+    float occlusion = gltf_prepare_occlusion(occlusion_texture, occlusion_strength);
+    color emissive_color = gltf_perpare_emission(emissive_texture, emissive_factor * math::max(0.0f, emissive_strength));
+
+    // KHR_materials_specular
+    // ------------------------------------------------------------------------
+    color specular_color = color(gltf_prepare_tex_float3(specular_color_texture)) * specular_color_factor;
+    float specular = gltf_prepare_tex_float4(specular_texture).w * specular_factor;
+
+    // KHR_materials_transmission
+    // ------------------------------------------------------------------------
+    float transmission = gltf_prepare_tex_float4(transmission_texture).x * transmission_factor;
+
+    // KHR_materials_sheen
+    // ------------------------------------------------------------------------
+    color sheen_color = color(gltf_prepare_tex_float3(sheen_color_texture)) * sheen_color_factor;
+    float sheen_roughness = gltf_prepare_tex_float4(sheen_roughness_texture).w * sheen_roughness_factor;
+
+    // KHR_materials_clearcoat
+    // ------------------------------------------------------------------------
+    float clearcoat_blend = gltf_prepare_tex_float3(clearcoat_texture).x * clearcoat_factor;
+    float clearcoat_roughness = gltf_prepare_tex_float3(clearcoat_roughness_texture).y * clearcoat_roughness_factor;
+    float clearcoat_roughness2 = clearcoat_roughness * clearcoat_roughness;
+    float3 clearcoat_normal = gltf_prepare_normal(clearcoat_normal_texture);
+    float grazing_refl_coat = math::max((1.0 - clearcoat_roughness), 0.0);
+
+    // KHR_materials_iridescence
+    // ------------------------------------------------------------------------
+    float iridescence_strength = gltf_prepare_tex_float3(iridescence_texture).x * iridescence_factor;
+    float iridescence_thickness = math::lerp(iridescence_thickness_minimum, iridescence_thickness_maximum, gltf_prepare_tex_float3(iridescence_thickness_texture).x);
+
+    // KHR_materials_anisotropy
+    // ------------------------------------------------------------------------
+    float3 anisotropy_tex = gltf_prepare_tex_float3(anisotropy_texture, float3(1.0, 0.5, 1.0));
+    float2 anisotropy_tex_dir = float2(anisotropy_tex.x * 2.0 - 1.0, anisotropy_tex.y * 2.0 - 1.0);
+    float2 anisotropy_rot = float2(math::cos(anisotropy_rotation), math::sin(anisotropy_rotation));
+    float2 anisotropy_dir = float2x2(anisotropy_rot.x, anisotropy_rot.y, -anisotropy_rot.y, anisotropy_rot.x) * math::normalize(anisotropy_tex_dir);
+    float3 anisotropy_tangent_u = state::texture_tangent_u(0) * anisotropy_dir.x + state::texture_tangent_v(0) * anisotropy_dir.y;
+    float anisotropy = anisotropy_strength * anisotropy_tex.z;
+
+    // metallic roughness model
+    // ------------------------------------------------------------------------
+
+    // compute final roughness by squaring the "roughness" parameter
+    float roughness2 = roughness * roughness;
+
+    float anisotropy_roughness_u = math::lerp(roughness2, 1.0, anisotropy * anisotropy);
+    float anisotropy_roughness_v = roughness2;
+
+    // reduce the reflectivity at grazing angles to avoid "dark edges"
+    // for high roughness due to the layering
+    float grazing_refl = math::max((1.0 - roughness), 0.0);
+
+    // fresnel term based on ior
+    float f0 = math::pow((ior - 1.0)/(ior + 1.0), 2.0);
+
+    // for the dielectric component we layer the glossy component on top of the diffuse one,
+    // the glossy layer has no color tint
+    bsdf dielectric_component = df::color_custom_curve_layer(
+        weight: color(1.0), // roughness is used to weight between diffuse and glossy
+        normal_reflectivity: math::min(f0 * specular_color, color(1.0)) * specular,
+        grazing_reflectivity: color(grazing_refl * specular),
+        layer: df::microfacet_ggx_vcavities_bsdf(
+            roughness_u: anisotropy_roughness_u,
+            roughness_v: anisotropy_roughness_v,
+            tangent_u: anisotropy_tangent_u),
+        base: df::weighted_layer(
+            weight: transmission,
+            base: df::diffuse_reflection_bsdf(tint: base_color * occlusion),
+            layer: df::microfacet_ggx_vcavities_bsdf(
+                roughness_u: roughness2,
+                tint: base_color * occlusion,
+                mode: df::scatter_transmit)),
+        normal: normal
+        );
+
+    // apply iridescence and make the strength adjustable using a weighted layer
+    bsdf dielectric_component_with_thin_film = df::weighted_layer(
+        weight: iridescence_strength,
+        base: dielectric_component,
+        layer: df::thin_film(
+            thickness: iridescence_thickness,
+            ior: color(iridescence_ior),
+            base: dielectric_component
+        )
+    );
+
+    // the metallic component doesn't have a diffuse component,
+    // its only glossy base_color is applied to tint it
+    bsdf metallic_component = df::microfacet_ggx_vcavities_bsdf(
+        tint: base_color * occlusion,
+        roughness_u: anisotropy_roughness_u,
+        roughness_v: anisotropy_roughness_v,
+        tangent_u: anisotropy_tangent_u);
+
+    // apply iridescence and make the strength adjustable using a weighted layer
+    // according to KHR_materials_iridescence spec: using dielectric thin film fresnel for metals, too
+    color base_color_sqrt = math::min(math::sqrt(math::saturate(base_color * occlusion)), color(0.99f));
+    color dielectric_ior = (color(1.0f) + base_color_sqrt) / (color(1.0f) - base_color_sqrt);
+    bsdf metallic_component_with_thin_film = df::weighted_layer(
+        weight: iridescence_strength,
+        base: metallic_component,
+        layer: df::thin_film(
+            thickness: iridescence_thickness,
+            ior: color(iridescence_ior),
+            base: df::fresnel_factor(
+                ior: dielectric_ior,
+                extinction_coefficient: color(0.0f),
+                base: df::microfacet_ggx_vcavities_bsdf(roughness_u: roughness2))
+        )
+    );
+
+    // apply sheen to the dielectric component
+    // add the sheen_color as weight in an outer layer to be able to blend and disable on default
+    // otherwise, sheen would be applied and tinted black
+    bsdf dielectric_sheen_component = df::color_weighted_layer(
+        weight: sheen_color,
+        layer: df::sheen_bsdf(
+            roughness: sheen_roughness * sheen_roughness,
+            tint:  color(1.0),
+            multiscatter_tint: color(1.0),
+            multiscatter: dielectric_component // don't apply thin_film
+        ),
+        base: dielectric_component_with_thin_film);
+
+    // final BSDF is a linear blend between dielectric and metallic component
+    bsdf dielectric_metal_mix = df::weighted_layer(
+        weight: metallic,
+        base: dielectric_sheen_component,
+        layer: metallic_component_with_thin_film,
+        normal: normal);
+
+    bsdf clearcoated = df::custom_curve_layer(
+        weight: clearcoat_blend,
+        normal_reflectivity: 0.04,
+        grazing_reflectivity: grazing_refl_coat,
+        layer: df::microfacet_ggx_vcavities_bsdf(
+            mode: df::scatter_reflect,
+            roughness_u: clearcoat_roughness2,
+            tint: color(1.0)),
+        base: df::weighted_layer(
+            weight: 1.0,
+            layer: dielectric_metal_mix,
+            normal: normal),
+        normal: clearcoat_normal);
+
+} in material(
+    thin_walled: thin_walled,
+    surface: material_surface(
+        scattering: clearcoated,
+        emission:  material_emission (
+            emission: df::diffuse_edf(),
+            intensity: emissive_color * ::math::PI
+        )
+    ),
+    volume: material_volume(
+        absorption_coefficient: thin_walled ? color(0.0) : (attenuation_distance == 0) ? color(0.0) : -math::log(attenuation_color) / attenuation_distance
+    ),
+    ior: color(ior),
+    geometry: material_geometry(
+        cutout_opacity: compute_opacity(alpha_mode, alpha, alpha_cutoff)
+    )
+);
+
+
+export material gltf_material_khr_specular_glossiness(
+    // diffuse color
+    uniform color diffuse_factor = color(1.0)
+    [[
+        anno::in_group("PBR Specular Glossiness"),
+        anno::display_name("Diffuse Factor"),
+        anno::description("The diffuse color of the material. Multiplied to the 'Diffuse Texture' if available.")
+    ]],
+    gltf_texture_lookup_value diffuse_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("PBR Specular Glossiness"),
+        anno::display_name("Diffuse Texture"),
+        anno::description("The diffuse color of the material. Influenced by the 'Diffuse Factor'.")
+    ]],
+
+    // specular glossiness
+    uniform color specular_factor = 1.0
+    [[
+        anno::in_group("PBR Specular Glossiness"),
+        anno::display_name("Specular Factor"),
+        anno::description("The specular color of the material. Multiplied to the rgb values of the 'Specular/Glossy Texture' if available.")
+    ]],
+    uniform float glossiness_factor = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("PBR Specular Glossiness"),
+        anno::display_name("Glossiness Factor"),
+        anno::description("The glossiness of the material. Select between diffuse (0.0) and nearly specular (1.0). Multiplied to the alpha value of the 'Specular/Glossy Texture' if available.")
+    ]],
+    gltf_texture_lookup_value specular_glossiness_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("PBR Specular Glossiness"),
+        anno::display_name("Specular/Glossy Texture"),
+        anno::description("The specular-glossiness texture. Influenced by the 'Specular Factor' and 'Glossiness Factor'.")
+    ]],
+
+    // normal map
+    gltf_normal_texture_lookup_value normal_texture = gltf_normal_texture_lookup()
+    [[
+        anno::in_group("Normal Mapping"),
+        anno::display_name("Normal Texture"),
+        anno::description("Base layer normal map.")
+    ]],
+
+    // emission
+    uniform color emissive_factor = color(0.0)
+    [[
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Factor"),
+        anno::description("The emissive color of the material. Multiplied to the 'Emissive Texture' if available.")
+    ]],
+    gltf_texture_lookup_value emissive_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Texture"),
+        anno::description("The emissive map texture. Influenced by the 'Emissive Factor'."),
+        anno::enable_if("::math::average(emissive_factor)>0.0")
+    ]],
+    // KHR_materials_emissive_strength
+    uniform float emissive_strength = 1.0
+    [[
+        anno::soft_range(0.0, 10000),
+        anno::in_group("Emission"),
+        anno::display_name("Emissive Strength"),
+        anno::description("The maximum strength of the emissive texture. Multiplied to the 'Emissive Factor'."),
+        anno::enable_if("::math::average(emissive_factor)>0.0")
+    ]],
+
+    // ambient occlusion
+    gltf_texture_lookup_value occlusion_texture = gltf_texture_lookup()
+    [[
+        anno::in_group("Occlusion"),
+        anno::display_name("Occlusion Texture"),
+        anno::description("The occlusion map texture. Influenced by the 'Occlusion Strength'.")
+    ]],
+    uniform float occlusion_strength = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Occlusion"),
+        anno::display_name("Occlusion Strength"),
+        anno::description("A scalar multiplier controlling the amount of occlusion applied. Multiplied to the 'Occlusion Texture'.")
+    ]],
+
+    // alpha
+    uniform gltf_alpha_mode alpha_mode = opaque
+    [[
+        anno::in_group("Opacity"),
+        anno::display_name("Alpha Mode"),
+        anno::description("Select how to interpret the alpha value.")
+    ]],
+    uniform float base_alpha = 1.0
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Opacity"),
+        anno::display_name("Base Alpha"),
+        anno::description("Select between transparent (0.0) and opaque (1.0). Multiplied to the base color texture alpha channel if available."),
+        anno::enable_if("alpha_mode!=opaque")
+    ]],
+
+    // alpha for gltf_alpha_mode::mask
+    uniform float alpha_cutoff = 0.5
+    [[
+        anno::hard_range(0.0, 1.0),
+        anno::in_group("Opacity"),
+        anno::display_name("Alpha Cutoff"),
+        anno::description("Threshold to decide between fully transparent and fully opaque when alpha mode is 'mask'."),
+        anno::enable_if("alpha_mode==mask")
+    ]],
+
+    uniform string vertex_color_name_spec = string("displayColor")
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Vertex Color Name"),
+        anno::description("Name of the vertex color primvar usually COLOR_0 'gltf', or displayColor 'usd'.")
+    ]],
+
+    uniform bool use_vertex_color_alpha_spec = false
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Use Opacity Channel From Vertex Color"),
+        anno::description("Multiply the Alpha or .w channel from the vertex color with the base alpha value.")
+    ]],
+
+    uniform string vertex_opacity_name_spec = string("displayOpacity")
+    [[
+        anno::in_group("Primvar"),
+        anno::display_name("Vertex Opacity Name"),
+        anno::description("Name of the vertex color primvar usually the .w component of COLOR_0 'gltf', or displayOpacity 'usd'.")
+    ]]
+
+) [[
+    anno::author("NVIDIA Corporation"),
+    anno::display_name("GLTF Material - Specular-Glossiness"),
+    anno::description("Specular-Glossiness Material that takes the GLTF KHR extension parameters as input.")
+]] = let {
+
+    // handling GLTF parameters
+    // ------------------------------------------------------------------------
+    float4 diffuse_float4 = gltf_prepare_tex_float4(diffuse_texture) * ::scene::data_lookup_float4(vertex_color_name_spec, float4(1.0)); // apply vertex color
+    color diffuse = diffuse_factor * color(diffuse_float4.x, diffuse_float4.y, diffuse_float4.z);
+
+    float alpha = base_alpha * (use_vertex_color_alpha_spec == 1 ? diffuse_float4.w : 1.0)  * ((vertex_color_name_spec != vertex_opacity_name_spec) ? ::scene::data_lookup_float(vertex_opacity_name_spec, float(1.0)) : 1.0);
+    //float alpha = base_alpha;
+    float4 specular_glossiness = gltf_prepare_tex_float4(specular_glossiness_texture);
+    color specular = specular_factor * color(specular_glossiness.x, specular_glossiness.y, specular_glossiness.z);
+    float glossiness = glossiness_factor * specular_glossiness.w;
+
+    float3 normal = gltf_prepare_normal(normal_texture);
+    float occlusion = gltf_prepare_occlusion(occlusion_texture, occlusion_strength);
+    color emissive_color = gltf_perpare_emission(emissive_texture, emissive_factor * math::max(0.0f, emissive_strength));
+
+    // specular glossiness model
+    // ------------------------------------------------------------------------
+
+    //color c_diff = diffuse * (1.0 - math::maxvalue(specular));
+    float F_0 = math::max_value(specular);
+    color F_0_tint = F_0==0.0? color(0.0) : (specular/F_0);
+
+    float a = (1.0 - glossiness) * (1.0 - glossiness);
+
+    // diffuse BRDF
+    bsdf diffuse_brdf = df::diffuse_reflection_bsdf(
+        tint: diffuse * occlusion,
+        roughness: 0.0);
+
+    // specular BRDF
+    bsdf specular_brdf = df::microfacet_ggx_smith_bsdf(
+        tint: color(occlusion),
+        roughness_u: a,
+        roughness_v: a,
+        tangent_u: state::texture_tangent_u(0));
+    bsdf tinted_specular =  df::directional_factor(normal_tint: F_0_tint, grazing_tint: color(1.0), exponent: 5.0, base: specular_brdf);
+    //- Custom curve for specular/diffuse angular mix
+    bsdf diffuse_specular_mix = df::custom_curve_layer(
+        normal_reflectivity: F_0,
+        grazing_reflectivity: 1.0,
+        exponent: 5.0,
+        weight: 1.0,
+        layer: tinted_specular,
+        base: diffuse_brdf,
+        normal: normal);
+
+} in material(
+    surface: material_surface(
+        scattering: diffuse_specular_mix,
+        emission:  material_emission (
+            emission: df::diffuse_edf(),
+            intensity: emissive_color * ::math::PI
+        )
+    ),
+    geometry: material_geometry(
+        normal: normal,
+        cutout_opacity: compute_opacity(alpha_mode, alpha, alpha_cutoff)
+    )
+);

standardbots_spark/spark/meshes/visual/shoulder_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68a67d936f0d1f7b1c7b84b254493d2203a7ac15fe884ce545d2c7f69b328941
+size 6258398

standardbots_spark/spark/meshes/visual/upper_arm_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7e1250652e68a6d0a617c869feed986337d68d79602b7ed07541269af9a301e
+size 13819892

standardbots_spark/spark/meshes/visual/wrist_1_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d3c3d8d1b7b51e3c8177036b85febda8c6de751261505f907f452f475780f87
+size 4162675

standardbots_spark/spark/meshes/visual/wrist_2_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a0932e079527a4c80a3cd63f1fcf1ccaf9c71bc30a169be66b3c7aed81ce801
+size 4162691

standardbots_spark/spark/meshes/visual/wrist_3_link.usd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:676936b6939885e62810b632c4c384cbb36445dc95be27f3d32f20d68383f13e
+size 4709471