Add files using upload-large-folder tool

.version

@@ -0,0 +1 @@
+0.1.0

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/.collect.mapping.json

@@ -0,0 +1,83 @@
+{
+    "version": "1.0",
+    "file_records": [
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/base.usd",
+            "source_hash": "cf42c783681d9be4aa7f67865dbd1acd0c441774",
+            "target_url": "./base.usd",
+            "target_hash": "f63bd719073e2ab81755f2aa52ea333f4066d10a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/Downloads/brown_photostudio_02_4k.exr",
+            "source_hash": "1e6ba41f32c58f9673f1dc2701a6eddf7a950fb3",
+            "target_url": "./Downloads/brown_photostudio_02_4k.exr",
+            "target_hash": "892754ce1ad95b44fc0db1ea4def923c2da1cfe0"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/objaverse_usd/8c63e5e160064cd3862e4b5f8781032b.usd",
+            "source_hash": "b6ac7ef3feed333ecad0059230d9ca9178d0d17c",
+            "target_url": "./objaverse_usd/8c63e5e160064cd3862e4b5f8781032b.usd",
+            "target_hash": "13e451ec625eafa8820dfe37b0aaabb7c80b484d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/instance.usd",
+            "source_hash": "6cb56b0d2a74169f2e7fb0dcb6900c1ae4b613d6",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/instance.usd",
+            "target_hash": "95b58850747681815474c6fc79bc56732720016e"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/objaverse_usd/saved/assets/scene_usds/IROS_scenes/objaverse_usd/textures/8c63e5e160064cd3862e4b5f8781032b_texture0.png",
+            "source_hash": "41c015550995362567b59e0a4bba7865560a4cf2",
+            "target_url": "./objaverse_usd/saved/assets/scene_usds/IROS_scenes/objaverse_usd/textures/8c63e5e160064cd3862e4b5f8781032b_texture0.png",
+            "target_hash": "6b83b0cf51175813c0c82bbaa58e40e2f000417b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/5e952df017e93b0001a51caa_color.png",
+            "source_hash": "db810e6bf14cc86a1f939dc5e97a7dadf373ff64",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/5e952df017e93b0001a51caa_color.png",
+            "target_hash": "b6cd3fff01cc27169d0c6b1f01d8b14dfe94e841"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/5e952df017e93b0001a51caa_metallic.png",
+            "source_hash": "920b0d4b3e3b4b35183e71c4cb841a7e666aab64",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/5e952df017e93b0001a51caa_metallic.png",
+            "target_hash": "4751ef63f36d6f3c246ab8752d3b3ecbdae2ec40"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/normal.png",
+            "source_hash": "fda3302107811bbbfe98901f8d21f3e9d0d2cab9",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/normal.png",
+            "target_hash": "bdd733c98876fab2ba53010cfdec44af0abedd4b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/white.png",
+            "source_hash": "dc8d8b485f6d70389652db708551f15a2f8738a5",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/white.png",
+            "target_hash": "9f406ab3c3d7c736a861c959d513e552079621dc"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Num5acdb7530d69eb04199ed4dd.mdl",
+            "source_hash": "98cba9e14903c4955cd847c6fad6b6af493faf9b",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Num5acdb7530d69eb04199ed4dd.mdl",
+            "target_hash": "525c183e76f311154fd9e6be0a4cd41669fcd05f"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/black.png",
+            "source_hash": "9bd9bcd2ed41b7bb8a6f08c5d8bdd461a32cacd5",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Textures/black.png",
+            "target_hash": "1073163bf1318dbf1c06518cb3c2d580d6b04aac"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Function.mdl",
+            "source_hash": "e3c55f1bb5692be493ff772f4c11f415acc5c0e0",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Function.mdl",
+            "target_hash": "bd17e4476f5beccf66b1d4e8df69f3cc0b0c20ff"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/object_place1/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Base.mdl",
+            "source_hash": "bbd3e10bd83bde12efc7dc69b1b01e10d3a8d136",
+            "target_url": "./object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Base.mdl",
+            "target_hash": "e0cd5e23bd5a8bcd5aed4df07175927d021ad165"
+        }
+    ]
+}

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/objaverse_usd/8c63e5e160064cd3862e4b5f8781032b.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_8c63e5e160064cd3862e4b5f8781032b" (
+        prepend payload = @./8c63e5e160064cd3862e4b5f8781032b.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/Num5acdb7530d69eb04199ed4dd.mdl

@@ -0,0 +1,284 @@
+mdl 1.6;
+
+import ::math::*;
+import ::state::*;
+import ::tex::*;
+import ::anno::*;
+using OmniUe4Function import *;
+using OmniUe4Base import *;
+
+export annotation sampler_color();
+export annotation sampler_normal();
+export annotation sampler_grayscale();
+export annotation sampler_alpha();
+export annotation sampler_masks();
+export annotation sampler_distancefield();
+export annotation dither_masked_off();
+export annotation world_space_normal();
+
+export material Num5acdb7530d69eb04199ed4dd(
+	uniform texture_2d Normal_Tex = texture_2d("./Textures/normal.png",::tex::gamma_linear)
+	[[
+		anno::display_name("Normal_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Normal"),
+		sampler_normal()
+	]],
+	float4 Normal_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Normal_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Normal")
+	]],
+	float EmissiveIntensity = 0.0
+	[[
+		anno::display_name("EmissiveIntensity"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsEmissiveTex = 0.0
+	[[
+		anno::display_name("IsEmissiveTex"),
+		anno::in_group("EmissiveColor")
+	]],
+	float4 Emissive_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Emissive_Color"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	uniform texture_2d Emissive_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Emissive_Tex"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor"),
+		sampler_color()
+	]],
+	float4 Emissive_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Emissive_UVA"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsBaseColorTex = 0.0
+	[[
+		anno::display_name("IsBaseColorTex"),
+		anno::in_group("BaseColor")
+	]],
+	float4 BaseColor_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("BaseColor_Color"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	uniform texture_2d BaseColor_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("BaseColor_Tex"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor"),
+		sampler_color()
+	]],
+	float4 BaseColor_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("BaseColor_UVA"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	float IsMetallicTex = 0.0
+	[[
+		anno::display_name("IsMetallicTex"),
+		anno::in_group("Metallic")
+	]],
+	float4 Metallic_Color = float4(0.0,0.0,0.0,1.0)
+	[[
+		anno::display_name("Metallic_Color"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	uniform texture_2d Metallic_Tex = texture_2d("./Textures/black.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Metallic_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Metallic"),
+		sampler_color()
+	]],
+	float4 Metallic_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Metallic_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	float IsSpecularTex = 0.0
+	[[
+		anno::display_name("IsSpecularTex"),
+		anno::in_group("Specular")
+	]],
+	float4 Specular_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Specular_Color"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	uniform texture_2d Specular_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Specular_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Specular"),
+		sampler_color()
+	]],
+	float4 Specular_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Specular_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	float IsGlossTex = 0.0
+	[[
+		anno::display_name("IsGlossTex"),
+		anno::in_group("Roughness")
+	]],
+	float4 Gloss_Color = float4(0.1,0.1,0.1,1.0)
+	[[
+		anno::display_name("Gloss_Color"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	uniform texture_2d Gloss_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Gloss_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Roughness"),
+		sampler_color()
+	]],
+	float4 Gloss_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Gloss_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	float PolygonOffset = 0.0
+	[[
+		anno::display_name("PolygonOffset"),
+		anno::ui_order(32),
+		anno::in_group("WorldPosition")
+	]],
+	int MaxTexCoordIndex = 3
+	[[
+		anno::hidden()
+	]])
+ = 
+	let {
+	float3 Local82 = ::camera_position();
+	float3 Local83 = (Local82 - (::convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), true)*state::meters_per_scene_unit()*100.0));
+	float Local84 = math::dot(Local83, Local83);
+	float Local85 = math::sqrt(Local84);
+	float3 Local86 = (Local83 / Local85);
+	float3 Local87 = (Local86 * PolygonOffset);
+
+	float3 WorldPositionOffset_mdl = Local87;
+	float2 CustomizedUV0_mdl = float2(state::texture_coordinate(math::min(0,MaxTexCoordIndex)).x,1.0-state::texture_coordinate(math::min(0,MaxTexCoordIndex)).y);
+
+	float2 Local0 = (float2(0.5,0.5) * -1.0);
+	float Local1 = (CustomizedUV0_mdl.x * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).x);
+	float Local2 = (CustomizedUV0_mdl.y * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).y);
+	float2 Local3 = (Local0 + float2(Local1,Local2));
+	float Local4 = (3.141592 * -2.0);
+	float Local5 = (float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).z / Local4);
+	float Local6 = (Local5 * 6.283185);
+	float Local7 = math::cos(Local6);
+	float Local8 = math::sin(Local6);
+	float Local9 = (Local8 * -1.0);
+	float Local10 = math::dot(Local3, float2(Local7,Local9));
+	float Local11 = math::dot(Local3, float2(Local8,Local7));
+	float2 Local12 = (float2(0.5,0.5) + float2(Local10,Local11));
+	float4 Local13 = ::unpack_normal_map(tex::lookup_float4(Normal_Tex,float2(Local12.x,1.0-Local12.y),tex::wrap_repeat,tex::wrap_repeat));
+	float3 Local14 = ((math::abs(1.0 - 1.0) > 0.00001) ? (float3(0.0,0.0,0.0)) : float3(Local13.x,Local13.y,Local13.z));
+
+	float3 Normal_mdl = Local14;
+
+	float Local15 = (CustomizedUV0_mdl.x * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).x);
+	float Local16 = (CustomizedUV0_mdl.y * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).y);
+	float2 Local17 = (Local0 + float2(Local15,Local16));
+	float Local18 = (float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).z / Local4);
+	float Local19 = (Local18 * 6.283185);
+	float Local20 = math::cos(Local19);
+	float Local21 = math::sin(Local19);
+	float Local22 = (Local21 * -1.0);
+	float Local23 = math::dot(Local17, float2(Local20,Local22));
+	float Local24 = math::dot(Local17, float2(Local21,Local20));
+	float2 Local25 = (float2(0.5,0.5) + float2(Local23,Local24));
+	float4 Local26 = tex::lookup_float4(Emissive_Tex,float2(Local25.x,1.0-Local25.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local27 = ((math::abs(IsEmissiveTex - 1.0) > 0.00001) ? (float3(Emissive_Color.x,Emissive_Color.y,Emissive_Color.z)) : float3(Local26.x,Local26.y,Local26.z));
+	float3 Local28 = (EmissiveIntensity * Local27);
+	float Local29 = (CustomizedUV0_mdl.x * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).x);
+	float Local30 = (CustomizedUV0_mdl.y * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).y);
+	float2 Local31 = (Local0 + float2(Local29,Local30));
+	float Local32 = (float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).z / Local4);
+	float Local33 = (Local32 * 6.283185);
+	float Local34 = math::cos(Local33);
+	float Local35 = math::sin(Local33);
+	float Local36 = (Local35 * -1.0);
+	float Local37 = math::dot(Local31, float2(Local34,Local36));
+	float Local38 = math::dot(Local31, float2(Local35,Local34));
+	float2 Local39 = (float2(0.5,0.5) + float2(Local37,Local38));
+	float4 Local40 = tex::lookup_float4(BaseColor_Tex,float2(Local39.x,1.0-Local39.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local41 = ((math::abs(IsBaseColorTex - 1.0) > 0.00001) ? (float3(BaseColor_Color.x,BaseColor_Color.y,BaseColor_Color.z)) : float3(Local40.x,Local40.y,Local40.z));
+	float Local42 = (CustomizedUV0_mdl.x * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).x);
+	float Local43 = (CustomizedUV0_mdl.y * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).y);
+	float2 Local44 = (Local0 + float2(Local42,Local43));
+	float Local45 = (float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).z / Local4);
+	float Local46 = (Local45 * 6.283185);
+	float Local47 = math::cos(Local46);
+	float Local48 = math::sin(Local46);
+	float Local49 = (Local48 * -1.0);
+	float Local50 = math::dot(Local44, float2(Local47,Local49));
+	float Local51 = math::dot(Local44, float2(Local48,Local47));
+	float2 Local52 = (float2(0.5,0.5) + float2(Local50,Local51));
+	float4 Local53 = tex::lookup_float4(Metallic_Tex,float2(Local52.x,1.0-Local52.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local54 = ((math::abs(IsMetallicTex - 1.0) > 0.00001) ? (float3(Metallic_Color.x,Metallic_Color.y,Metallic_Color.z)) : float3(Local53.x,Local53.y,Local53.z));
+	float Local55 = (CustomizedUV0_mdl.x * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).x);
+	float Local56 = (CustomizedUV0_mdl.y * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).y);
+	float2 Local57 = (Local0 + float2(Local55,Local56));
+	float Local58 = (float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).z / Local4);
+	float Local59 = (Local58 * 6.283185);
+	float Local60 = math::cos(Local59);
+	float Local61 = math::sin(Local59);
+	float Local62 = (Local61 * -1.0);
+	float Local63 = math::dot(Local57, float2(Local60,Local62));
+	float Local64 = math::dot(Local57, float2(Local61,Local60));
+	float2 Local65 = (float2(0.5,0.5) + float2(Local63,Local64));
+	float4 Local66 = tex::lookup_float4(Specular_Tex,float2(Local65.x,1.0-Local65.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local67 = ((math::abs(IsSpecularTex - 1.0) > 0.00001) ? (float3(Specular_Color.x,Specular_Color.y,Specular_Color.z)) : float3(Local66.x,Local66.y,Local66.z));
+	float Local68 = (CustomizedUV0_mdl.x * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).x);
+	float Local69 = (CustomizedUV0_mdl.y * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).y);
+	float2 Local70 = (Local0 + float2(Local68,Local69));
+	float Local71 = (float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).z / Local4);
+	float Local72 = (Local71 * 6.283185);
+	float Local73 = math::cos(Local72);
+	float Local74 = math::sin(Local72);
+	float Local75 = (Local74 * -1.0);
+	float Local76 = math::dot(Local70, float2(Local73,Local75));
+	float Local77 = math::dot(Local70, float2(Local74,Local73));
+	float2 Local78 = (float2(0.5,0.5) + float2(Local76,Local77));
+	float4 Local79 = tex::lookup_float4(Gloss_Tex,float2(Local78.x,1.0-Local78.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local80 = ((math::abs(IsGlossTex - 1.0) > 0.00001) ? (float3(Gloss_Color.x,Gloss_Color.y,Gloss_Color.z)) : float3(Local79.x,Local79.y,Local79.z));
+	float3 Local81 = (1.0 - Local80);
+
+	float3 EmissiveColor_mdl = Local28;
+	float OpacityMask_mdl = 1.0;
+	float3 BaseColor_mdl = Local41;
+	float Metallic_mdl = Local54.x;
+	float Specular_mdl = Local67.x;
+	float Roughness_mdl = Local81.x;
+
+	} in
+		::OmniUe4Base(
+			base_color: BaseColor_mdl,
+			metallic: Metallic_mdl,
+			roughness: Roughness_mdl,
+			specular: Specular_mdl,
+			normal: Normal_mdl,
+			opacity: OpacityMask_mdl,
+			emissive_color: EmissiveColor_mdl,
+			displacement: WorldPositionOffset_mdl,
+			two_sided: false);

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Base.mdl

@@ -0,0 +1,224 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+ 
+//* 1.0.0 - first version
+//* 1.0.1 - merge unlit template
+//* 1.0.2 - Fix EDF in the back side: the EDF contained in surface is only used for the front side and not for the back side
+//* 1.0.3 - UE4 normal mapping: Geometry normal shouldn't be changed
+//* 1.0.4 - using absolute import paths when importing standard modules
+
+mdl 1.3;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+float emissive_multiplier()
+[[
+    anno::description("the multiplier to convert UE4 emissive to raw data"),
+    anno::noinline()
+]]
+{
+    return 20.0f * 128.0f;
+}
+
+float3 tangent_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in tangent space"),
+    anno::noinline()
+]]
+{
+    return math::normalize(
+        tangent_u * normal.x - /* flip_tangent_v */
+        tangent_v * normal.y +
+        state::normal() * (normal.z));
+}
+
+float3 world_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in world space"),
+    anno::noinline()
+]]
+{
+    return tangent_space_normal(
+        math::normalize(
+        normal.x * float3(tangent_u.x, tangent_v.x, state::normal().x) -
+        normal.y * float3(tangent_u.y, tangent_v.y, state::normal().y) +
+        normal.z * float3(tangent_u.z, tangent_v.z, state::normal().z)),
+        tangent_u,
+        tangent_v
+    );
+}
+
+export material OmniUe4Base(
+   float3 base_color = float3(0.0, 0.0, 0.0),
+   float metallic = 0.0,
+   float roughness = 0.5,
+   float specular = 0.5,
+   float3 normal = float3(0.0,0.0,1.0),
+   float clearcoat_weight = 0.0,
+   float clearcoat_roughness = 0.0,
+   float3 clearcoat_normal = float3(0.0,0.0,1.0),
+   uniform bool enable_opacity = true,
+   float opacity = 1.0,
+   float3 emissive_color = float3(0.0, 0.0, 0.0),
+   float3 displacement = float3(0.0),
+   uniform bool is_tangent_space_normal = true,
+   uniform bool two_sided = false,
+   uniform bool is_unlit = false
+)
+[[
+	anno::display_name("Omni UE4 Base"),
+	anno::description("Omni UE4 Base, supports UE4 default lit and clearcoat shading model"),
+	anno::version( 1, 0, 0),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "UE4", "omniverse", "lit", "clearcoat", "generic"))
+]]
+ = let {     
+   color final_base_color = math::saturate(base_color);
+   float final_metallic = math::saturate(metallic);
+   float final_roughness = math::saturate(roughness);
+   float final_specular = math::saturate(specular);
+   color final_emissive_color = math::max(emissive_color, 0.0f) * emissive_multiplier(); /*factor for converting ue4 emissive to raw value*/
+   float final_clearcoat_weight = math::saturate(clearcoat_weight);
+   float final_clearcoat_roughness = math::saturate(clearcoat_roughness);
+   float3 final_normal = math::normalize(normal);
+   float3 final_clearcoat_normal = math::normalize(clearcoat_normal);
+
+   // - compute final roughness by squaring the "roughness" parameter
+   float alpha = final_roughness * final_roughness;
+   // reduce the reflectivity at grazing angles to avoid "dark edges" for high roughness due to the layering
+   float grazing_refl = math::max((1.0 - final_roughness), 0.0);
+
+	float3 the_normal =  is_unlit ? state::normal() : 
+							(is_tangent_space_normal ? 
+                            tangent_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(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::custom_curve_layer(
+       weight: final_specular,
+       normal_reflectivity: 0.08,
+       grazing_reflectivity: grazing_refl,
+       layer: df::microfacet_ggx_smith_bsdf(roughness_u: alpha),
+       base: df::diffuse_reflection_bsdf(tint: final_base_color),
+       normal: the_normal);
+
+   // the metallic component doesn't have a diffuse component, it's only glossy
+   // base_color is applied to tint it
+   bsdf metallic_component = df::microfacet_ggx_smith_bsdf(tint: final_base_color, roughness_u: alpha);
+
+   // final BSDF is a linear blend between dielectric and metallic component
+   bsdf dielectric_metal_mix =
+       df::normalized_mix(
+           components:
+               df::bsdf_component[](
+                   df::bsdf_component(
+                       component: metallic_component,
+                       weight: final_metallic),
+                   df::bsdf_component(
+                       component: dielectric_component,
+                       weight: 1.0-final_metallic)
+               )
+       );
+
+   // clearcoat layer
+   float clearcoat_grazing_refl = math::max((1.0 - final_clearcoat_roughness), 0.0);
+   float clearcoat_alpha = final_clearcoat_roughness * final_clearcoat_roughness;
+
+   float3 the_clearcoat_normal = is_tangent_space_normal ? tangent_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            );
+
+
+   bsdf clearcoat =
+       df::custom_curve_layer(
+           base: df::weighted_layer(
+               layer: dielectric_metal_mix,
+               weight: 1.0,
+               normal: final_clearcoat_weight == 0.0 ? state::normal() : the_normal
+           ),
+           layer: df::microfacet_ggx_smith_bsdf(
+               roughness_u: clearcoat_alpha,
+               tint: color(1.0)
+           ),
+           normal_reflectivity: 0.04,
+           grazing_reflectivity: clearcoat_grazing_refl,
+           normal: the_clearcoat_normal,
+           weight: final_clearcoat_weight
+       );
+   bsdf surface = is_unlit ? bsdf() : clearcoat;
+} 
+in material(
+   thin_walled: two_sided, // Graphene?
+   surface: material_surface(
+       scattering: surface,
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   backface: material_surface(
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   geometry: material_geometry(
+       displacement: displacement,
+       normal: final_clearcoat_weight == 0.0 ? the_normal : state::normal(),
+       cutout_opacity: enable_opacity ? opacity : 1.0
+   )
+);

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/Materials/OmniUe4Function.mdl

@@ -0,0 +1,1413 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+
+//* 1.0.1 - using absolute import paths when importing standard modules
+
+mdl 1.6;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+
+export float3 convert_to_left_hand(float3 vec3, uniform bool up_z = true, uniform bool is_position = true)
+[[
+    anno::description("convert from RH to LH"),
+	anno::noinline()
+]]
+{
+	float4x4 ZupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4x4 YupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4 vec4 = float4(vec3.x, vec3.y, vec3.z, is_position ? 1.0f : 0.0f);
+
+	vec4 = vec4 * (up_z ? ZupConversion : YupConversion);
+
+	return float3(vec4.x, vec4.y, vec4.z);
+}
+
+export float3 transform_vector_from_tangent_to_world(float3 vector, 
+													uniform bool up_z = true, 
+													float3 tangent_u = state::texture_tangent_u(0),
+    												float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from tangent space to world space"),
+    anno::noinline()
+]]
+{
+	/* flip_tangent_v */
+    return  convert_to_left_hand(
+			tangent_u * vector.x - tangent_v * vector.y + state::normal() * vector.z, 
+			up_z, false);
+}
+
+export float3 transform_vector_from_world_to_tangent(float3 vector, 
+													uniform bool up_z = true,
+													float3 tangent_u = state::texture_tangent_u(0),
+													float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from world space to tangent space"),
+    anno::noinline()
+]]
+{
+	float3 vecRH = convert_to_left_hand(vector, up_z, false);
+	/* flip_tangent_v */
+	return 	vecRH.x * float3(tangent_u.x, -tangent_v.x, state::normal().x) +
+        	vecRH.y * float3(tangent_u.y, -tangent_v.y, state::normal().y) +
+        	vecRH.z * float3(tangent_u.z, -tangent_v.z, state::normal().z);
+}
+
+export float4 unpack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Unpack a normal stored in a normal map"),
+    anno::noinline()
+]]
+{
+    float2 normal_xy = float2(texture_sample.x, texture_sample.y);
+
+	normal_xy = normal_xy * float2(2.0,2.0) - float2(1.0,1.0);
+	float normal_z = math::sqrt( math::saturate( 1.0 - math::dot( normal_xy, normal_xy ) ) );
+	return float4( normal_xy.x, normal_xy.y, normal_z, 1.0 );
+}
+
+// for get color value from normal.
+export float4 pack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Pack to color from a normal")
+]]
+{
+    float2 return_xy = float2(texture_sample.x, texture_sample.y);
+
+	return_xy = (return_xy + float2(1.0,1.0)) / float2(2.0,2.0);
+	
+	return float4( return_xy.x, return_xy.y, 0.0, 1.0 );
+}
+
+export float4 greyscale_texture_lookup(
+    float4 texture_sample = float4(0.0, 0.0, 0.0, 1.0)
+    )
+[[
+    anno::description("Sampling a greyscale texture"),
+    anno::noinline()
+]]
+{
+    return float4(texture_sample.x, texture_sample.x, texture_sample.x, texture_sample.x);
+}     
+
+export float3 pixel_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Pixel normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 vertex_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Vertex normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 landscape_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Landscape normal in world space")
+]]
+{
+	float3 normalFromNormalmap = math::floor((::vertex_normal_world_space(up_z) * 0.5 + 0.5) * 255.0) / 255.0 * 2.0 - 1.0;
+	
+	float2 normalXY = float2(normalFromNormalmap.x, normalFromNormalmap.y);
+	return float3(normalXY.x, normalXY.y, math::sqrt(math::saturate(1.0 - math::dot(normalXY, normalXY))));
+}
+
+// Different implementation specific between mdl and hlsl for smoothstep
+export float smoothstep(float a, float b, float l)
+{
+	if (a < b)
+	{
+		return math::smoothstep(a, b, l);
+	}
+	else if (a > b)
+	{
+		return 1.0 - math::smoothstep(b, a, l);
+	}
+	else
+	{
+		return l <= a ? 0.0 : 1.0;
+	}
+}
+
+export float2 smoothstep(float2 a, float2 b, float2 l)
+{
+	return float2(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y));
+}
+
+export float3 smoothstep(float3 a, float3 b, float3 l)
+{
+	return float3(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z));
+}
+
+export float4 smoothstep(float4 a, float4 b, float4 l)
+{
+	return float4(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z), smoothstep(a.w, b.w, l.w));
+}
+
+export float2 smoothstep(float2 a, float2 b, float l)
+{
+	return float2(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l));
+}
+
+export float3 smoothstep(float3 a, float3 b, float l)
+{
+	return float3(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l));
+}
+
+export float4 smoothstep(float4 a, float4 b, float l)
+{
+	return float4(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l), smoothstep(a.w, b.w, l));
+}
+
+export float2 smoothstep(float a, float b, float2 l)
+{
+	return float2(smoothstep(a, b, l.x), smoothstep(a, b, l.y));
+}
+
+export float3 smoothstep(float a, float b, float3 l)
+{
+	return float3(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z));
+}
+
+export float4 smoothstep(float a, float b, float4 l)
+{
+	return float4(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z), smoothstep(a, b, l.w));
+}
+
+//------------------ Random from UE4 -----------------------
+float length2(float3 v)
+{
+	return math::dot(v, v);
+}
+
+float3 GetPerlinNoiseGradientTextureAt(uniform texture_2d PerlinNoiseGradientTexture, float3 v)
+{
+	const float2 ZShear = float2(17.0f, 89.0f);
+
+	float2 OffsetA = v.z * ZShear;
+	float2 TexA = (float2(v.x, v.y) + OffsetA + 0.5f) / 128.0f;
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA.x,1.0-TexA.y),tex::wrap_repeat,tex::wrap_repeat);
+	return float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z) * 2.0 - 1.0;
+}
+
+float3 SkewSimplex(float3 In)
+{
+	return In + math::dot(In, float3(1.0 / 3.0f) );
+}
+float3 UnSkewSimplex(float3 In)
+{
+	return In - math::dot(In, float3(1.0 / 6.0f) );
+}
+
+// 3D random number generator inspired by PCGs (permuted congruential generator)
+// Using a **simple** Feistel cipher in place of the usual xor shift permutation step
+// @param v = 3D integer coordinate
+// @return three elements w/ 16 random bits each (0-0xffff).
+// ~8 ALU operations for result.x    (7 mad, 1 >>)
+// ~10 ALU operations for result.xy  (8 mad, 2 >>)
+// ~12 ALU operations for result.xyz (9 mad, 3 >>)
+
+//TODO: uint3
+int3 Rand3DPCG16(int3 p)
+{
+	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
+	//TODO: uint3
+	int3 v = int3(p);
+
+	// Linear congruential step. These LCG constants are from Numerical Recipies
+	// For additional #'s, PCG would do multiple LCG steps and scramble each on output
+	// So v here is the RNG state
+	v = v * 1664525 + 1013904223;
+
+	// PCG uses xorshift for the final shuffle, but it is expensive (and cheap
+	// versions of xorshift have visible artifacts). Instead, use simple MAD Feistel steps
+	//
+	// Feistel ciphers divide the state into separate parts (usually by bits)
+	// then apply a series of permutation steps one part at a time. The permutations
+	// use a reversible operation (usually ^) to part being updated with the result of
+	// a permutation function on the other parts and the key.
+	//
+	// In this case, I'm using v.x, v.y and v.z as the parts, using + instead of ^ for
+	// the combination function, and just multiplying the other two parts (no key) for 
+	// the permutation function.
+	//
+	// That gives a simple mad per round.
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+
+	// only top 16 bits are well shuffled
+	return v >> 16;
+}
+
+// Wraps noise for tiling texture creation
+// @param v = unwrapped texture parameter
+// @param bTiling = true to tile, false to not tile
+// @param RepeatSize = number of units before repeating
+// @return either original or wrapped coord
+float3 NoiseTileWrap(float3 v,  bool bTiling, float RepeatSize)
+{
+	return bTiling ? (math::frac(v / RepeatSize) * RepeatSize) : v;
+}
+
+// Evaluate polynomial to get smooth transitions for Perlin noise
+// only needed by Perlin functions in this file
+// scalar(per component): 2 add, 5 mul
+float4 PerlinRamp(float4 t)
+{
+	return t * t * t * (t * (t * 6 - 15) + 10); 
+}
+
+// Blum-Blum-Shub-inspired pseudo random number generator
+// http://www.umbc.edu/~olano/papers/mNoise.pdf
+// real BBS uses ((s*s) mod M) with bignums and M as the product of two huge Blum primes
+// instead, we use a single prime M just small enough not to overflow
+// note that the above paper used 61, which fits in a half, but is unusably bad
+// @param Integer valued floating point seed
+// @return random number in range [0,1)
+// ~8 ALU operations (5 *, 3 frac)
+float RandBBSfloat(float seed)
+{
+	float BBS_PRIME24 = 4093.0;
+	float s = math::frac(seed / BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	return s;
+}
+
+// Modified noise gradient term
+// @param seed - random seed for integer lattice position
+// @param offset - [-1,1] offset of evaluation point from lattice point
+// @return gradient direction (xyz) and contribution (w) from this lattice point
+float4 MGradient(int seed, float3 offset)
+{
+	//TODO uint
+	int rand = Rand3DPCG16(int3(seed,0,0)).x;
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1.0 / 0x4000, 1.0 / 0x2000, 1.0 / 0x1000);
+	float3 direction = float3(int3(rand, rand, rand) & MGradientMask) * MGradientScale - 1;
+	return float4(direction.x, direction.y, direction.z, math::dot(direction, offset));
+}
+
+// compute Perlin and related noise corner seed values
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = true to return seed values for a repeating noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @param seed000-seed111 = hash function seeds for the eight corners
+// @return fractional part of v
+struct SeedValue
+{
+	float3 fv = float3(0);
+	float seed000 = 0;
+	float seed001 = 0;
+	float seed010 = 0;
+	float seed011 = 0;
+	float seed100 = 0;
+	float seed101 = 0;
+	float seed110 = 0;
+	float seed111 = 0;
+};
+
+SeedValue NoiseSeeds(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds;
+	seeds.fv = math::frac(v);
+	float3 iv = math::floor(v);
+
+	const float3 primes = float3(19, 47, 101);
+
+	if (bTiling)
+	{	// can't algebraically combine with primes
+		seeds.seed000 = math::dot(primes, NoiseTileWrap(iv, true, RepeatSize));
+		seeds.seed100 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 0), true, RepeatSize));
+		seeds.seed010 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 0), true, RepeatSize));
+		seeds.seed110 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 0), true, RepeatSize));
+		seeds.seed001 = math::dot(primes, NoiseTileWrap(iv + float3(0, 0, 1), true, RepeatSize));
+		seeds.seed101 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 1), true, RepeatSize));
+		seeds.seed011 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 1), true, RepeatSize));
+		seeds.seed111 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 1), true, RepeatSize));
+	}
+	else
+	{	// get to combine offsets with multiplication by primes in this case
+		seeds.seed000 = math::dot(iv, primes);
+		seeds.seed100 = seeds.seed000 + primes.x;
+		seeds.seed010 = seeds.seed000 + primes.y;
+		seeds.seed110 = seeds.seed100 + primes.y;
+		seeds.seed001 = seeds.seed000 + primes.z;
+		seeds.seed101 = seeds.seed100 + primes.z;
+		seeds.seed011 = seeds.seed010 + primes.z;
+		seeds.seed111 = seeds.seed110 + primes.z;
+	}
+
+	return seeds;
+}
+
+struct SimplexWeights
+{
+	float4 Result = float4(0);
+	float3 PosA = float3(0);
+	float3 PosB = float3(0);
+	float3 PosC = float3(0);
+	float3 PosD = float3(0);
+};
+
+// Computed weights and sample positions for simplex interpolation
+// @return float4(a,b,c, d) Barycentric coordinate defined as Filtered = Tex(PosA) * a + Tex(PosB) * b + Tex(PosC) * c + Tex(PosD) * d
+SimplexWeights ComputeSimplexWeights3D(float3 OrthogonalPos)
+{
+	SimplexWeights weights;
+	float3 OrthogonalPosFloor = math::floor(OrthogonalPos);
+
+	weights.PosA = OrthogonalPosFloor;
+	weights.PosB = weights.PosA + float3(1, 1, 1);
+
+	OrthogonalPos -= OrthogonalPosFloor;
+
+	float Largest = math::max(OrthogonalPos.x, math::max(OrthogonalPos.y, OrthogonalPos.z));
+	float Smallest = math::min(OrthogonalPos.x, math::min(OrthogonalPos.y, OrthogonalPos.z));
+
+	weights.PosC = weights.PosA + float3(Largest == OrthogonalPos.x, Largest == OrthogonalPos.y, Largest == OrthogonalPos.z);
+	weights.PosD = weights.PosA + float3(Smallest != OrthogonalPos.x, Smallest != OrthogonalPos.y, Smallest != OrthogonalPos.z);
+
+	float RG = OrthogonalPos.x - OrthogonalPos.y;
+	float RB = OrthogonalPos.x - OrthogonalPos.z;
+	float GB = OrthogonalPos.y - OrthogonalPos.z;
+
+	weights.Result.z = 
+		  math::min(math::max(0, RG), math::max(0, RB))		// X
+		+ math::min(math::max(0, -RG), math::max(0, GB))		// Y
+		+ math::min(math::max(0, -RB), math::max(0, -GB));	// Z
+	
+	weights.Result.w = 
+		  math::min(math::max(0, -RG), math::max(0, -RB))		// X
+		+ math::min(math::max(0, RG), math::max(0, -GB))		// Y
+		+ math::min(math::max(0, RB), math::max(0, GB));		// Z
+
+	weights.Result.y = Smallest;
+	weights.Result.x = 1.0f - weights.Result.y - weights.Result.z - weights.Result.w;
+
+	return weights;
+}
+
+// filtered 3D gradient simple noise (few texture lookups, high quality)
+// @param v >0
+// @return random number in the range -1 .. 1
+float SimplexNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 EvalPos)
+{
+	float3 OrthogonalPos = SkewSimplex(EvalPos);
+
+	SimplexWeights Weights = ComputeSimplexWeights3D(OrthogonalPos);
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 32 bit)
+	float3 A = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosA);
+	float3 B = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosB);
+	float3 C = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosC);
+	float3 D = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosD);
+	
+	Weights.PosA = UnSkewSimplex(Weights.PosA);
+	Weights.PosB = UnSkewSimplex(Weights.PosB);
+	Weights.PosC = UnSkewSimplex(Weights.PosC);
+	Weights.PosD = UnSkewSimplex(Weights.PosD);
+
+	float DistanceWeight;
+
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosA));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float a = math::dot(A, EvalPos - Weights.PosA) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosB));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float b = math::dot(B, EvalPos - Weights.PosB) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosC));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float c = math::dot(C, EvalPos - Weights.PosC) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosD));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float d = math::dot(D, EvalPos - Weights.PosD) * DistanceWeight;
+
+	return 32 * (a + b + c + d);
+}
+
+// filtered 3D noise, can be optimized
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 v, bool bTiling, float RepeatSize)
+{
+	bTiling = true;
+	float3 fv = math::frac(v);
+	float3 iv0 = NoiseTileWrap(math::floor(v), bTiling, RepeatSize);
+	float3 iv1 = NoiseTileWrap(iv0 + 1, bTiling, RepeatSize);
+
+	const int2 ZShear = int2(17, 89);
+	
+	float2 OffsetA = iv0.z * ZShear;
+	float2 OffsetB = OffsetA + ZShear;	// non-tiling, use relative offset
+	if (bTiling)						// tiling, have to compute from wrapped coordinates
+	{
+		OffsetB = iv1.z * ZShear;
+	}
+
+	// Texture size scale factor
+	float ts = 1 / 128.0f;
+
+	// texture coordinates for iv0.xy, as offset for both z slices
+	float2 TexA0 = (float2(iv0.x, iv0.y) + OffsetA + 0.5f) * ts;
+	float2 TexB0 = (float2(iv0.x, iv0.y) + OffsetB + 0.5f) * ts;
+
+	// texture coordinates for iv1.xy, as offset for both z slices
+	float2 TexA1 = TexA0 + ts;	// for non-tiling, can compute relative to existing coordinates
+	float2 TexB1 = TexB0 + ts;
+	if (bTiling)				// for tiling, need to compute from wrapped coordinates
+	{
+		TexA1 = (float2(iv1.x, iv1.y) + OffsetA + 0.5f) * ts;
+		TexB1 = (float2(iv1.x, iv1.y) + OffsetB + 0.5f) * ts;
+	}
+
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 8, 16 or 32 bit)
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 A = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 B = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 C = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 D = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 E = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 F = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 G = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 H = PerlinNoiseColor * 2 - 1;
+
+	float a = math::dot(A, fv - float3(0, 0, 0));
+	float b = math::dot(B, fv - float3(1, 0, 0));
+	float c = math::dot(C, fv - float3(0, 1, 0));
+	float d = math::dot(D, fv - float3(1, 1, 0));
+	float e = math::dot(E, fv - float3(0, 0, 1));
+	float f = math::dot(F, fv - float3(1, 0, 1));
+	float g = math::dot(G, fv - float3(0, 1, 1));
+	float h = math::dot(H, fv - float3(1, 1, 1));
+
+	float4 Weights = PerlinRamp(math::frac(float4(fv.x, fv.y, fv.z, 0)));
+	
+	float i = math::lerp(math::lerp(a, b, Weights.x), math::lerp(c, d, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(e, f, Weights.x), math::lerp(g, h, Weights.x), Weights.y);
+
+	return math::lerp(i, j, Weights.z);
+}
+
+// @return random number in the range -1 .. 1
+// scalar: 6 frac, 31 mul/mad, 15 add, 
+float FastGradientPerlinNoise3D_TEX(uniform texture_3d PerlinNoise3DTexture, float3 xyz)
+{
+	// needs to be the same value when creating the PerlinNoise3D texture
+	float Extent = 16;
+
+	// last texel replicated and needed for filtering
+	// scalar: 3 frac, 6 mul
+	xyz = math::frac(xyz / (Extent - 1)) * (Extent - 1);
+
+	// scalar: 3 frac
+	float3 uvw = math::frac(xyz);
+	// = floor(xyz);
+	// scalar: 3 add
+	float3 p0 = xyz - uvw;
+//	float3 f = math::pow(uvw, 2) * 3.0f - math::pow(uvw, 3) * 2.0f;	// original perlin hermite (ok when used without bump mapping)
+	// scalar: 2*3 add 5*3 mul
+	float4 pr = PerlinRamp(float4(uvw.x, uvw.y, uvw.z, 0));
+	float3 f = float3(pr.x, pr.y, pr.z);	// new, better with continues second derivative for bump mapping
+	// scalar: 3 add
+	float3 p = p0 + f;
+	// scalar: 3 mad
+	// TODO: need reverse???
+	float4 NoiseSample = tex::lookup_float4(PerlinNoise3DTexture, p / Extent + 0.5f / Extent);	// +0.5f to get rid of bilinear offset
+
+	// reconstruct from 8bit (using mad with 2 constants and dot4 was same instruction count)
+	// scalar: 4 mad, 3 mul, 3 add 
+	float3 n = float3(NoiseSample.x, NoiseSample.y, NoiseSample.z) * 255.0f / 127.0f - 1.0f;
+	float d = NoiseSample.w * 255.f - 127;
+	return math::dot(xyz, n) - d;
+}
+
+// Perlin-style "Modified Noise"
+// http://www.umbc.edu/~olano/papers/index.html#mNoise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = MGradient(int(seeds.seed000), seeds.fv - float3(0, 0, 0)).w;
+	float rand100 = MGradient(int(seeds.seed100), seeds.fv - float3(1, 0, 0)).w;
+	float rand010 = MGradient(int(seeds.seed010), seeds.fv - float3(0, 1, 0)).w;
+	float rand110 = MGradient(int(seeds.seed110), seeds.fv - float3(1, 1, 0)).w;
+	float rand001 = MGradient(int(seeds.seed001), seeds.fv - float3(0, 0, 1)).w;
+	float rand101 = MGradient(int(seeds.seed101), seeds.fv - float3(1, 0, 1)).w;
+	float rand011 = MGradient(int(seeds.seed011), seeds.fv - float3(0, 1, 1)).w;
+	float rand111 = MGradient(int(seeds.seed111), seeds.fv - float3(1, 1, 1)).w;
+
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D value noise - used to be incorrectly called Perlin noise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float ValueNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = RandBBSfloat(seeds.seed000) * 2 - 1;
+	float rand100 = RandBBSfloat(seeds.seed100) * 2 - 1;
+	float rand010 = RandBBSfloat(seeds.seed010) * 2 - 1;
+	float rand110 = RandBBSfloat(seeds.seed110) * 2 - 1;
+	float rand001 = RandBBSfloat(seeds.seed001) * 2 - 1;
+	float rand101 = RandBBSfloat(seeds.seed101) * 2 - 1;
+	float rand011 = RandBBSfloat(seeds.seed011) * 2 - 1;
+	float rand111 = RandBBSfloat(seeds.seed111) * 2 - 1;
+	
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+	
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D jitter offset within a voronoi noise cell
+// @param pos - integer lattice corner
+// @return random offsets vector
+float3 VoronoiCornerSample(float3 pos, int Quality)
+{
+	// random values in [-0.5, 0.5]
+	float3 noise = float3(Rand3DPCG16(int3(pos))) / 0xffff - 0.5;
+
+	// quality level 1 or 2: searches a 2x2x2 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 2x2x2 search
+	if (Quality <= 2)
+	{
+		return math::normalize(noise) * 0.2588;
+	}
+
+	// quality level 3: searches a 3x3x3 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 3x3x3 search
+	if (Quality == 3)
+	{
+		return math::normalize(noise) * 0.3090;
+	}
+
+	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
+	return noise;
+}
+
+// compare previous best with a new candidate
+// not producing point locations makes it easier for compiler to eliminate calculations when they're not needed
+// @param minval = location and distance of best candidate seed point before the new one
+// @param candidate = candidate seed point
+// @param offset = 3D offset to new candidate seed point
+// @param bDistanceOnly = if true, only set maxval.w with distance, otherwise maxval.w is distance and maxval.xyz is position
+// @return position (if bDistanceOnly is false) and distance to closest seed point so far
+float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
+{
+	if (bDistanceOnly)
+	{
+		return float4(0, 0, 0, math::min(minval.w, math::dot(offset, offset)));
+	}
+	else
+	{
+		float newdist = math::dot(offset, offset);
+		return newdist > minval.w ? minval : float4(candidate.x, candidate.y, candidate.z, newdist);
+	}
+}
+
+// 220 instruction Worley noise
+float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
+{
+	float3 fv = math::frac(v),  fv2 = math::frac(v + 0.5);
+	float3 iv = math::floor(v), iv2 = math::floor(v + 0.5);
+
+	// with initial minimum distance = infinity (or at least bigger than 4), first min is optimized away
+	float4 mindist = float4(0,0,0,100);
+	float3 p, offset;
+
+	// quality level 3: do a 3x3x3 search
+	if (Quality == 3)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = -1; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = -1; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = -1; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// everybody else searches a base 2x2x2 neighborhood
+	else
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = 0; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// quality level 2, do extra set of points, offset by half a cell
+					if (Quality == 2)
+					{
+						// 467 is just an offset to a different area in the random number field to avoid similar neighbor artifacts
+						p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize) + 467, Quality);
+						mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+					}
+				}
+			}
+		}
+	}
+
+	// quality level 4: add extra sets of four cells in each direction
+	if (Quality >= 4)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;	
+		for (offset_x = -1; offset_x <= 2; offset_x += 3)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					// along x axis
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along y axis
+					p = float3(offset.y, offset.z, offset.x) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.y, offset.z, offset.x), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along z axis
+					p = float3(offset.z, offset.x, offset.y) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.z, offset.x, offset.y), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// transform squared distance to real distance
+	return float4(mindist.x, mindist.y, mindist.z, math::sqrt(mindist.w));
+}
+
+// Coordinates for corners of a Simplex tetrahedron
+// Based on McEwan et al., Efficient computation of noise in GLSL, JGT 2011
+// @param v = 3D noise argument
+// @return 4 corner locations
+float4x3 SimplexCorners(float3 v)
+{
+	// find base corner by skewing to tetrahedral space and back
+	float3 tet = math::floor(v + v.x/3 + v.y/3 + v.z/3);
+	float3 base = tet - tet.x/6 - tet.y/6 - tet.z/6;
+	float3 f = v - base;
+
+	// Find offsets to other corners (McEwan did this in tetrahedral space,
+	// but since skew is along x=y=z axis, this works in Euclidean space too.)
+	float3 g = math::step(float3(f.y,f.z,f.x), float3(f.x,f.y,f.z)), h = 1 - float3(g.z, g.x, g.y);
+	float3 a1 = math::min(g, h) - 1.0 / 6.0, a2 = math::max(g, h) - 1.0 / 3.0;
+
+	// four corners
+	return float4x3(base, base + a1, base + a2, base + 0.5);
+}
+
+// Improved smoothing function for simplex noise
+// @param f = fractional distance to four tetrahedral corners
+// @return weight for each corner
+float4 SimplexSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	return (1 * scale + s*(-3 * scale + s*(3 * scale - s*scale)));
+}
+
+// Derivative of simplex noise smoothing function
+// @param f = fractional distanc eto four tetrahedral corners
+// @return derivative of smoothing function for each corner by x, y and z
+float3x4 SimplexDSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	s = -12 * scale + s*(24 * scale - s * 12 * scale);
+
+	return float3x4(
+		s * float4(f[0][0], f[1][0], f[2][0], f[3][0]),
+		s * float4(f[0][1], f[1][1], f[2][1], f[3][1]),
+		s * float4(f[0][2], f[1][2], f[2][2], f[3][2]));
+}
+
+// Simplex noise and its Jacobian derivative
+// @param v = 3D noise argument
+// @param bTiling = whether to repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension, must be a multiple of 3
+// @return float3x3 Jacobian in J[*].xyz, vector noise in J[*].w
+//     J[0].w, J[1].w, J[2].w is a Perlin-style simplex noise with vector output, e.g. (Nx, Ny, Nz)
+//     J[i].x is X derivative of the i'th component of the noise so J[2].x is dNz/dx
+// You can use this to compute the noise, gradient, curl, or divergence:
+//   float3x4 J = JacobianSimplex_ALU(...);
+//   float3 VNoise = float3(J[0].w, J[1].w, J[2].w);	// 3D noise
+//   float3 Grad = J[0].xyz;							// gradient of J[0].w
+//   float3 Curl = float3(J[1][2]-J[2][1], J[2][0]-J[0][2], J[0][1]-J[1][2]);
+//   float Div = J[0][0]+J[1][1]+J[2][2];
+// All of these are confirmed to compile out all unneeded terms.
+// So Grad of X doesn't compute Y or Z components, and VNoise doesn't do any of the derivative computation.
+float3x4 JacobianSimplex_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1. / 0x4000, 1. / 0x2000, 1. / 0x1000);
+
+	// corners of tetrahedron
+	float4x3 T = SimplexCorners(v);
+	// TODO: uint3
+	int3 rand = int3(0);
+	float4x3 gvec0 = float4x3(1.0);
+	float4x3 gvec1 = float4x3(1.0);
+	float4x3 gvec2 = float4x3(1.0);
+	float4x3 fv = float4x3(1.0);
+	float3x4 grad = float3x4(1.0);
+
+	// processing of tetrahedral vertices, unrolled
+	// to compute gradient at each corner
+	fv[0] = v - T[0];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[0] + 0.5, bTiling, RepeatSize))));
+	gvec0[0] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[0] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[0] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][0] = math::dot(gvec0[0], fv[0]);
+	grad[1][0] = math::dot(gvec1[0], fv[0]);
+	grad[2][0] = math::dot(gvec2[0], fv[0]);
+
+	fv[1] = v - T[1];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[1] + 0.5, bTiling, RepeatSize))));
+	gvec0[1] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][1] = math::dot(gvec0[1], fv[1]);
+	grad[1][1] = math::dot(gvec1[1], fv[1]);
+	grad[2][1] = math::dot(gvec2[1], fv[1]);
+
+	fv[2] = v - T[2];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[2] + 0.5, bTiling, RepeatSize))));
+	gvec0[2] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[2] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[2] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][2] = math::dot(gvec0[2], fv[2]);
+	grad[1][2] = math::dot(gvec1[2], fv[2]);
+	grad[2][2] = math::dot(gvec2[2], fv[2]);
+
+	fv[3] = v - T[3];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[3] + 0.5, bTiling, RepeatSize))));
+	gvec0[3] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[3] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[3] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][3] = math::dot(gvec0[3], fv[3]);
+	grad[1][3] = math::dot(gvec1[3], fv[3]);
+	grad[2][3] = math::dot(gvec2[3], fv[3]);
+
+	// blend gradients
+	float4 sv = SimplexSmooth(fv);
+	float3x4 ds = SimplexDSmooth(fv);
+
+	float3x4 jacobian = float3x4(1.0);
+	float3 vec0 = gvec0*sv + grad[0]*ds; // NOTE: mdl is column major, convert from UE4 (row major)
+	jacobian[0] = float4(vec0.x, vec0.y, vec0.z, math::dot(sv, grad[0]));
+	float3 vec1 = gvec1*sv + grad[1]*ds;
+	jacobian[1] = float4(vec1.x, vec1.y, vec1.z, math::dot(sv, grad[1]));
+	float3 vec2 = gvec2*sv + grad[2]*ds;
+	jacobian[2] = float4(vec2.x, vec2.y, vec2.z, math::dot(sv, grad[2]));
+
+	return jacobian;
+}
+
+// While RepeatSize is a float here, the expectation is that it would be largely integer values coming in from the UI. The downstream logic assumes
+// floats for all called functions (NoiseTileWrap) and this prevents any float-to-int conversion errors from automatic type conversion.
+float Noise3D_Multiplexer(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, int Function, float3 Position, int Quality, bool bTiling, float RepeatSize)
+{
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch(Function)
+	{
+		case 0:
+			return SimplexNoise3D_TEX(PerlinNoiseGradientTexture, Position);
+		case 1:
+			return GradientNoise3D_TEX(PerlinNoiseGradientTexture, Position, bTiling, RepeatSize);
+		case 2:
+			return FastGradientPerlinNoise3D_TEX(PerlinNoise3DTexture, Position);
+		case 3:
+			return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 4:
+			return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 5:
+			return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2.0 - 1.0;
+	}
+	return 0;
+}
+//----------------------------------------------------------
+
+export float noise(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, float3 Position, float Scale, float Quality, float Function, float Turbulence, float Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, float Tiling, float RepeatSize)
+[[
+    anno::description("Noise"),
+    anno::noinline()
+]]
+{
+	Position *= Scale;
+	FilterWidth *= Scale;
+
+	float Out = 0.0f;
+	float OutScale = 1.0f;
+	float InvLevelScale = 1.0f / LevelScale;
+	
+	int iFunction(Function);
+	int iQuality(Quality);
+	int iLevels(Levels);
+	bool bTurbulence(Turbulence);
+	bool bTiling(Tiling);
+	
+	for(int i = 0; i < iLevels; ++i)
+	{
+		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
+		OutScale *= math::saturate(1.0 - FilterWidth);
+
+		if(bTurbulence)
+		{
+			Out += math::abs(Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize)) * OutScale;
+		}
+		else
+		{
+			Out += Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize) * OutScale;
+		}
+
+		Position *= LevelScale;
+		RepeatSize *= LevelScale;
+		OutScale *= InvLevelScale;
+		FilterWidth *= LevelScale;
+	}
+
+	if(!bTurbulence)
+	{
+		// bring -1..1 to 0..1 range
+		Out = Out * 0.5f + 0.5f;
+	}
+
+	// Out is in 0..1 range
+	return math::lerp(OutputMin, OutputMax, Out);
+}
+
+// Material node for noise functions returning a vector value
+// @param LevelScale usually 2 but higher values allow efficient use of few levels
+// @return in user defined range (OutputMin..OutputMax)
+export float4 vector4_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise"),
+    anno::noinline()
+]]
+{
+	float4 result = float4(0,0,0,1);
+	float3 ret = float3(0);
+	int iQuality = int(Quality);
+	int iFunction = int(Function);
+	bool bTiling = Tiling > 0.0;
+	
+	float3x4 Jacobian = JacobianSimplex_ALU(Position, bTiling, TileSize);	// compiled out if not used
+
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch (iFunction)
+	{
+	case 0:	// Cellnoise
+		ret = float3(Rand3DPCG16(int3(math::floor(NoiseTileWrap(Position, bTiling, TileSize))))) / 0xffff;
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 1: // Color noise
+		ret = float3(Jacobian[0].w, Jacobian[1].w, Jacobian[2].w);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 2: // Gradient
+		result = Jacobian[0];
+		break;
+	case 3: // Curl
+		ret = float3(Jacobian[2][1] - Jacobian[1][2], Jacobian[0][2] - Jacobian[2][0], Jacobian[1][0] - Jacobian[0][1]);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 4: // Voronoi
+		result = VoronoiNoise3D_ALU(Position, iQuality, bTiling, TileSize, false);
+		break;
+	}
+	return result;
+}
+
+export float3 vector3_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise float3 version"),
+    anno::noinline()
+]]
+{
+	float4 noise = vector4_noise(Position, Quality, Function, Tiling, TileSize);
+	return float3(noise.x, noise.y, noise.z);
+}
+
+
+// workaround for ue4 fresnel (without supporting for camera vector) : replacing it with 0.0, means facing to the view
+export float fresnel(float exponent [[anno::unused()]], float base_reflect_fraction [[anno::unused()]], float3 normal [[anno::unused()]])
+[[
+    anno::description("Fresnel"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float fresnel_function(float3 normal_vector [[anno::unused()]], float3 camera_vector [[anno::unused()]], 
+                                bool invert_fresnel [[anno::unused()]], float power [[anno::unused()]], 
+                                bool use_cheap_contrast [[anno::unused()]], float cheap_contrast_dark [[anno::unused()]], float cheap_contrast_bright [[anno::unused()]], 
+                                bool clamp_fresnel_dot_product [[anno::unused()]])
+[[
+    anno::description("Fresnel Function"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float3 camera_vector(uniform bool up_z = true)
+[[
+    anno::description("Camera Vector"),
+    anno::noinline()
+]]
+{
+	// assume camera postion is 0,0,0
+	return math::normalize(float3(0) - convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z));
+}
+
+export float pixel_depth()
+[[
+    anno::description("Pixel Depth"),
+    anno::noinline()
+]]
+{
+	return 256.0f;
+}
+
+export float scene_depth()
+[[
+    anno::description("Scene Depth")
+]]
+{
+	return 65500.0f;
+}
+
+export float3 scene_color()
+[[
+    anno::description("Scene Color")
+]]
+{
+	return float3(1.0f);
+}
+
+export float4 vertex_color()
+[[
+    anno::description("Vertex Color"),
+    anno::noinline()
+]]
+{
+	return float4(1.0f);
+}
+
+export float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
+[[
+    anno::description("Vertex Color for float2 PrimVar"),
+    anno::noinline()
+]]
+{
+	// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
+	return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
+}
+
+export float3 camera_position()
+[[
+    anno::description("Camera Position"),
+    anno::noinline()
+]]
+{
+	return float3(1000.0f, 0, 0);
+}
+
+export float3 rotate_about_axis(float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position)
+[[
+    anno::description("Rotates Position about the given axis by the given angle")
+]]
+{
+	// Project Position onto the rotation axis and find the closest point on the axis to Position
+	float3 NormalizedRotationAxis = float3(NormalizedRotationAxisAndAngle.x,NormalizedRotationAxisAndAngle.y,NormalizedRotationAxisAndAngle.z);
+	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxis * math::dot(NormalizedRotationAxis, Position - PositionOnAxis);
+	// Construct orthogonal axes in the plane of the rotation
+	float3 UAxis = Position - ClosestPointOnAxis;
+	float3 VAxis = math::cross(NormalizedRotationAxis, UAxis);
+	float[2] SinCosAngle = math::sincos(NormalizedRotationAxisAndAngle.w);
+	// Rotate using the orthogonal axes
+	float3 R = UAxis * SinCosAngle[1] + VAxis * SinCosAngle[0];
+	// Reconstruct the rotated world space position
+	float3 RotatedPosition = ClosestPointOnAxis + R;
+	// Convert from position to a position offset
+	return RotatedPosition - Position;
+}
+
+export float2 rotate_scale_offset_texcoords(float2 InTexCoords, float4 InRotationScale, float2 InOffset)
+[[
+    anno::description("Returns a float2 texture coordinate after 2x2 transform and offset applied")
+]]
+{
+	return float2(math::dot(InTexCoords, float2(InRotationScale.x, InRotationScale.y)), math::dot(InTexCoords, float2(InRotationScale.z, InRotationScale.w))) + InOffset;
+}
+
+export float3 reflection_custom_world_normal(float3 WorldNormal, bool bNormalizeInputNormal, uniform bool up_z = true)
+[[
+    anno::description("Reflection vector about the specified world space normal")
+]]
+{
+	if (bNormalizeInputNormal)
+	{
+		WorldNormal = math::normalize(WorldNormal);
+	}
+
+	return -camera_vector(up_z) + WorldNormal * math::dot(WorldNormal, camera_vector(up_z)) * 2.0;
+}
+
+export float3 reflection_vector(uniform bool up_z = true)
+[[
+    anno::description("Reflection Vector"),
+    anno::noinline()
+]]
+{
+    float3 normal = convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+	return reflection_custom_world_normal(normal, false, up_z);
+}
+
+export float dither_temporalAA(float AlphaThreshold = 0.5f, float Random = 1.0f [[anno::unused()]])
+[[
+    anno::description("Dither TemporalAA"),
+    anno::noinline()
+]]
+{
+	return AlphaThreshold;
+}
+
+export float3 black_body( float Temp )
+[[
+    anno::description("Black Body"),
+	anno::noinline()
+]]
+{
+	float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
+	float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
+
+	float x = 3*u / ( 2*u - 8*v + 4 );
+	float y = 2*v / ( 2*u - 8*v + 4 );
+	float z = 1 - x - y;
+
+	float Y = 1;
+	float X = Y/y * x;
+	float Z = Y/y * z;
+
+	float3x3 XYZtoRGB = float3x3(
+		float3(3.2404542, -1.5371385, -0.4985314),
+		float3(-0.9692660,  1.8760108,  0.0415560),
+		float3(0.0556434, -0.2040259,  1.0572252)
+	);
+
+	return XYZtoRGB * float3( X, Y, Z ) * math::pow( 0.0004 * Temp, 4 );
+}
+
+export float per_instance_random(uniform texture_2d PerlinNoiseGradientTexture, int NumberInstances)
+[[
+    anno::description("Per Instance Random"),
+	anno::noinline()
+]]
+{
+	float weight = state::object_id() / float(NumberInstances);	
+	return NumberInstances == 0 ? 0.0 : tex::lookup_float4(PerlinNoiseGradientTexture, float2(weight, 1.0 - weight), tex::wrap_repeat, tex::wrap_repeat).x;
+}
+
+//------------------ Hair from UE4 -----------------------
+float3 hair_absorption_to_color(float3 A)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::exp(-math::sqrt(A) * D);
+}
+
+float3 hair_color_to_absorption(float3 C)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::pow(math::log(C) / D, 2.0f);
+}
+
+export float3 get_hair_color_from_melanin(float InMelanin, float InRedness, float3 InDyeColor)
+[[
+    anno::description("Hair Color")
+]]
+{
+	InMelanin = math::saturate(InMelanin);
+	InRedness = math::saturate(InRedness);
+	float Melanin		= -math::log(math::max(1 - InMelanin, 0.0001f));
+	float Eumelanin 	= Melanin * (1 - InRedness);
+	float Pheomelanin = Melanin * InRedness;
+
+	float3 DyeAbsorption = hair_color_to_absorption(math::saturate(InDyeColor));
+	float3 Absorption = Eumelanin * float3(0.506f, 0.841f, 1.653f) + Pheomelanin * float3(0.343f, 0.733f, 1.924f);
+
+	return hair_absorption_to_color(Absorption + DyeAbsorption);
+}
+
+export float3 local_object_bounds_min()
+[[
+    anno::description("Local Object Bounds Min"),
+	anno::noinline()
+]]
+{
+	return float3(0.0);
+}
+
+export float3 local_object_bounds_max()
+[[
+    anno::description("Local Object Bounds Max"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float3 object_bounds()
+[[
+    anno::description("Object Bounds"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float object_radius()
+[[
+    anno::description("Object Radius"),
+	anno::noinline()
+]]
+{
+	return 100.0f;
+}
+
+export float3 object_world_position(uniform bool up_z = true)
+[[
+    anno::description("Object World Position"),
+	anno::noinline()
+]]
+{
+	return convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z)*state::meters_per_scene_unit()*100.0;
+}
+
+export float3 object_orientation()
+[[
+    anno::description("Object Orientation"),
+	anno::noinline()
+]]
+{
+	return float3(0);
+}
+
+export float rcp(float x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float2 rcp(float2 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float3 rcp(float3 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float4 rcp(float4 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export int BitFieldExtractI32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractI32 int"),
+	anno::noinline()
+]]
+{
+	Size &= 3;
+	Offset &= 3;
+
+	if (Size == 0)
+		return 0;
+	else if (Offset + Size < 32)
+		return (Data << (32 - Size - Offset)) >> (32 - Size);
+	else
+		return Data >> Offset;
+}
+
+export int BitFieldExtractI32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractI32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(int(Data), int(Size), int(Offset));
+}
+
+export int BitFieldExtractU32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractU32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export int BitFieldExtractU32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractU32 int"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export float3 EyeAdaptationInverseLookup(float3 LightValue, float Alpha)
+[[
+    anno::description("EyeAdaptationInverseLookup"),
+	anno::noinline()
+]]
+{
+	float Adaptation = 1.0f;
+
+	// When Alpha=0.0, we want to multiply by 1.0. when Alpha = 1.0, we want to multiply by 1/Adaptation.
+	// So the lerped value is:
+	//     LerpLogScale = Lerp(log(1),log(1/Adaptaiton),T)
+	// Which is simplified as:
+	//     LerpLogScale = Lerp(0,-log(Adaptation),T)
+	//     LerpLogScale = -T * logAdaptation;
+
+	float LerpLogScale = -Alpha * math::log(Adaptation);
+	float Scale = math::exp(LerpLogScale);
+	return LightValue * Scale;
+}

scenes/scene_usds/IROS_scenes_aloha_final/object_place1/base/object_usds/grutopia_usd/Table/table/43605fe0f62607d280497e58fa06473f/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/object_place4/base/objaverse_usd/398c1b3b8114409a89eb02f9b42f8064.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_398c1b3b8114409a89eb02f9b42f8064" (
+        prepend payload = @./398c1b3b8114409a89eb02f9b42f8064.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/.collect.mapping.json

@@ -0,0 +1,323 @@
+{
+    "version": "1.0",
+    "file_records": [
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/base.usd",
+            "source_hash": "376396902a7f9eb3311ac4842e792a1b304dd18a",
+            "target_url": "./base.usd",
+            "target_hash": "f8d19b66e9c625102fda70bf68124b288af2f397"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/Downloads/brown_photostudio_02_4k.exr",
+            "source_hash": "95eb12d6410cf16f32489fbffc89dbc7da289664",
+            "target_url": "./Downloads/brown_photostudio_02_4k.exr",
+            "target_hash": "76106cbeedc2e855718fb4528f8edeaedecd4fdc"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/instance.usd",
+            "source_hash": "d07872a8a2968619979e17bcc8337914b96ea246",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/instance.usd",
+            "target_hash": "b497bd83ebc5dd142edfaea584193cd958637414"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/08d23f3cd9254e38a696060a962ebb7f.usd",
+            "source_hash": "f329045643322b0bd3065e8392b64ba29b3a50f8",
+            "target_url": "./object_usds/objaverse_usd/08d23f3cd9254e38a696060a962ebb7f.usd",
+            "target_hash": "1d543f51c857dc0e08eb668591f4785f6afc9b8a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/0acdfc046a5149cc890c992da89b48c0.usd",
+            "source_hash": "85e4676e62e7c4e42a5a600d961151c944a69878",
+            "target_url": "./object_usds/objaverse_usd/0acdfc046a5149cc890c992da89b48c0.usd",
+            "target_hash": "9d4227ccba03b4b50520d27f5b11f5886d57ba21"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/1f9f025d995c4554bcc39b97eed20c7d.usd",
+            "source_hash": "39940c22dd6fa201addc857955ebbfa801c50dbb",
+            "target_url": "./object_usds/objaverse_usd/1f9f025d995c4554bcc39b97eed20c7d.usd",
+            "target_hash": "8801471b9b4d0dcfd2bff00883f14d4939877c48"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/476f8b64886f4edbae88e74f68d065c9.usd",
+            "source_hash": "7dc8fd560105cb91b57aa6f22b54e5a80cc59896",
+            "target_url": "./object_usds/objaverse_usd/476f8b64886f4edbae88e74f68d065c9.usd",
+            "target_hash": "4f20cba6c493a025ee20cfea9a598a77e37a653b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/48a6aed1dff24e57b6836ade47a46ead.usd",
+            "source_hash": "602b0e20f0667a28d531ab446cf55bc4dee189c2",
+            "target_url": "./object_usds/objaverse_usd/48a6aed1dff24e57b6836ade47a46ead.usd",
+            "target_hash": "514be519f82571eb0992489c48dc3865f02f15c7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/5b87502ac41f4eb2b2ba7b0cce6517aa.usd",
+            "source_hash": "da17c2673b4c18931e8e406532ec4994bde896f1",
+            "target_url": "./object_usds/objaverse_usd/5b87502ac41f4eb2b2ba7b0cce6517aa.usd",
+            "target_hash": "f1bd62f54f36312dacaee33caa1b0ecfd78fd3b1"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/63e2323f49db4793bd087e67b20ac350.usd",
+            "source_hash": "0e9edad027f7daa9755a16cb48e6a1fedae0fb72",
+            "target_url": "./object_usds/objaverse_usd/63e2323f49db4793bd087e67b20ac350.usd",
+            "target_hash": "9245e32d3b1ab83fb7402c8626fd9b9ad192444d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/691d0e4cb6a1409ea72d960d0ab144ea.usd",
+            "source_hash": "bc26a857d831ffb5c9eebd9058c927a2840a70d3",
+            "target_url": "./object_usds/objaverse_usd/691d0e4cb6a1409ea72d960d0ab144ea.usd",
+            "target_hash": "99066f3b94de9f0710bc2e4a6e1d9b8dcc6c7829"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/896181392c1f4e2d9316bf2eeafc3042.usd",
+            "source_hash": "e63bbbad412c64730cafff757108a2b82f2dc4ab",
+            "target_url": "./object_usds/objaverse_usd/896181392c1f4e2d9316bf2eeafc3042.usd",
+            "target_hash": "5d5c308ba377ebc31a1823217dfcd660f82b7255"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/8d56e83387b64684ae7a1b4a20040d67.usd",
+            "source_hash": "690692e1103019d05d9de96198e2a2588a771399",
+            "target_url": "./object_usds/objaverse_usd/8d56e83387b64684ae7a1b4a20040d67.usd",
+            "target_hash": "33ecfc166e47797bb50b4fe16cfe9d6ee3468681"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/c7aa636f24e345b3b831271bf7f1fe02.usd",
+            "source_hash": "624547592e099a916f0115c6bf5a989e03f1af0e",
+            "target_url": "./object_usds/objaverse_usd/c7aa636f24e345b3b831271bf7f1fe02.usd",
+            "target_hash": "b9cfa27b483e9c5d6f13f207d56aadd2f2f7619b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/eced95f9f49e4ef9b6f8d576f908bc6b.usd",
+            "source_hash": "e0b373b34043de072c076e8fa070df17f27214ae",
+            "target_url": "./object_usds/objaverse_usd/eced95f9f49e4ef9b6f8d576f908bc6b.usd",
+            "target_hash": "02c5b64afce59100fbb3f33b4a1d8d57166945f6"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/objects/obj_base_glb_09.usd",
+            "source_hash": "54816892a3c6dbeb78591f38d82b33b9e5d9a513",
+            "target_url": "./objects/obj_base_glb_09.usd",
+            "target_hash": "36ee706c1cd85a89dd3bb328108e46605d88626b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture0.jpg",
+            "source_hash": "bad8d4a191d4051302236c2186cde80905d59aef",
+            "target_url": "./object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture0.jpg",
+            "target_hash": "3c45f7d447fec9bcb4efd144508c450a55816534"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture1.jpg",
+            "source_hash": "077182705059d3376dcfaa0a420ecef421548844",
+            "target_url": "./object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture1.jpg",
+            "target_hash": "da5c2af96e004531418c27ba38167ad6f0348364"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture2.png",
+            "source_hash": "74612de6467a8df73dbcc3dc518701d22070cfb5",
+            "target_url": "./object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture2.png",
+            "target_hash": "9317d3bd07b140e50d808c7a8db7f92cff916072"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture3.jpg",
+            "source_hash": "3ee76a860a3603003b323d634c028e7bb2b19351",
+            "target_url": "./object_usds/objaverse_usd/textures/1f9f025d995c4554bcc39b97eed20c7d_texture3.jpg",
+            "target_hash": "528bf0c6fa5fce3bb892d03a2393438a3849d3c8"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/896181392c1f4e2d9316bf2eeafc3042_texture0.jpg",
+            "source_hash": "2dcc741e1ad540b8e13b19de0e8753bd96e1ff56",
+            "target_url": "./object_usds/objaverse_usd/textures/896181392c1f4e2d9316bf2eeafc3042_texture0.jpg",
+            "target_hash": "4cc268b6bf636dfb53b33c0c843d0d75c08ebed1"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_diffuse.png",
+            "source_hash": "0e17e8d340a948966480f783cb33cd31ed098b64",
+            "target_url": "./objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_diffuse.png",
+            "target_hash": "10db33d5f0e70484cdd9f8e8f27b988273004b32"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_metallic-texture_roughness.png",
+            "source_hash": "b764db3c159b7e8854d58ae02679f0db40085145",
+            "target_url": "./objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_metallic-texture_roughness.png",
+            "target_hash": "e42c1205c68ec5ec9a71f74c456be437aa03dda7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_normal.png",
+            "source_hash": "f54d9f085853ffc91d2aa50693c5bb41adcf9f93",
+            "target_url": "./objects/saved/assets/scene_usds/IROS_scenes_collected/scene_drink/repos/RoboTwin/assets/objects/usds/062_plasticbox_base7_converted/textures/texture_normal.png",
+            "target_hash": "ff054d8488d631325830d7d42880a96f1b7e703d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/8d56e83387b64684ae7a1b4a20040d67_texture0.png",
+            "source_hash": "b9e5f150ab69bfd1ef426fc4cb86ff20c09d3899",
+            "target_url": "./object_usds/objaverse_usd/textures/8d56e83387b64684ae7a1b4a20040d67_texture0.png",
+            "target_hash": "2eee7a75f10e1804e2ccdd34bc97a556672ee4c5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/8d56e83387b64684ae7a1b4a20040d67_texture1.png",
+            "source_hash": "75f124c1aca5b2116956df88c1615cc121cfc5c6",
+            "target_url": "./object_usds/objaverse_usd/textures/8d56e83387b64684ae7a1b4a20040d67_texture1.png",
+            "target_hash": "418a8e7ccad1dfeae28d5c8f445015d7f629c381"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/08d23f3cd9254e38a696060a962ebb7f_texture0.jpg",
+            "source_hash": "3e4ea271779842ccdd0538462458a1bd85c0abf7",
+            "target_url": "./object_usds/objaverse_usd/textures/08d23f3cd9254e38a696060a962ebb7f_texture0.jpg",
+            "target_hash": "cc61cef264954c9867e47e6b5b82f8d42601ef4a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/08d23f3cd9254e38a696060a962ebb7f_texture1.jpg",
+            "source_hash": "43bc7629fcd1aa32929748a979a1bd8b213544d7",
+            "target_url": "./object_usds/objaverse_usd/textures/08d23f3cd9254e38a696060a962ebb7f_texture1.jpg",
+            "target_hash": "589395132666d2f290dfaaf4988a5c791a54b048"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture0.png",
+            "source_hash": "6885f29131c1d1fe6dd2a0f72bfef04a31fd1f54",
+            "target_url": "./object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture0.png",
+            "target_hash": "4fbafd8bc09a227c4de80fb3d208d3f819f84be5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture1.png",
+            "source_hash": "1ed48b4d442b1a7e3c7af25744f144bc3af2f4fb",
+            "target_url": "./object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture1.png",
+            "target_hash": "74a37b7317398a7036a33023577615ece49568c2"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture2.png",
+            "source_hash": "b090199c2d56a49d2486e397505d43c8469642cc",
+            "target_url": "./object_usds/objaverse_usd/textures/691d0e4cb6a1409ea72d960d0ab144ea_texture2.png",
+            "target_hash": "4a0d5ab99e6482890db8ca343f60e91df9cc5122"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/eced95f9f49e4ef9b6f8d576f908bc6b_texture0.png",
+            "source_hash": "e1298a84c4a0a26931bc684fc94a1f77a785802c",
+            "target_url": "./object_usds/objaverse_usd/textures/eced95f9f49e4ef9b6f8d576f908bc6b_texture0.png",
+            "target_hash": "1d5582af3e0c8af6fb806e064e1666e8d519632d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/0acdfc046a5149cc890c992da89b48c0_texture0.jpg",
+            "source_hash": "04ba565a487782bc052cc22e8e0e2d450448a787",
+            "target_url": "./object_usds/objaverse_usd/textures/0acdfc046a5149cc890c992da89b48c0_texture0.jpg",
+            "target_hash": "b12dbccb2cca98d80eafca13772abfec9832d3c4"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/5b87502ac41f4eb2b2ba7b0cce6517aa_texture0.png",
+            "source_hash": "8cd96cddf55e9a5531aedcb1df1f2eb00dbf7bbf",
+            "target_url": "./object_usds/objaverse_usd/textures/5b87502ac41f4eb2b2ba7b0cce6517aa_texture0.png",
+            "target_hash": "fabb04b5a55c8c6df6a07919749cea59ffdb0c19"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture0.jpg",
+            "source_hash": "66ca7814003c2ab8d4ec7f8501d4ec912cc739d1",
+            "target_url": "./object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture0.jpg",
+            "target_hash": "1df56e75bc94b6664dfbecc3e2008ecf903d9cf5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture1.png",
+            "source_hash": "9d57a2346733838a3196b5b6640b17f45008215b",
+            "target_url": "./object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture1.png",
+            "target_hash": "1b1f818935c40f7c4adb61e868723d5038ba08fd"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture2.png",
+            "source_hash": "744e15c2df47c6e6f3f28d0dc9c6a44f631eb679",
+            "target_url": "./object_usds/objaverse_usd/textures/476f8b64886f4edbae88e74f68d065c9_texture2.png",
+            "target_hash": "086d949224cd0d12517f15b6ebeec95d7597ca2b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/63e2323f49db4793bd087e67b20ac350_texture0.png",
+            "source_hash": "8e6f5e16474eb5d62c64f8d553fe8e3a8ededcf6",
+            "target_url": "./object_usds/objaverse_usd/textures/63e2323f49db4793bd087e67b20ac350_texture0.png",
+            "target_hash": "3979e45e8a7203ba12518acb2afafc1e650f6d84"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/63e2323f49db4793bd087e67b20ac350_texture1.png",
+            "source_hash": "fa61592e81f1b5fd25e76935d8856739e13405e6",
+            "target_url": "./object_usds/objaverse_usd/textures/63e2323f49db4793bd087e67b20ac350_texture1.png",
+            "target_hash": "7a6fc06789acb4551ae1d355b21b33894bf6c6b7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/5f005b1a5b89690001a5e474_color.png",
+            "source_hash": "1e9722d5118f05ddc61040bd5ac3941fcf8229c5",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/5f005b1a5b89690001a5e474_color.png",
+            "target_hash": "66b42c9272abc38718970b2a13442e0604b15396"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/5f005b1a7d6a630001694eb4_color.png",
+            "source_hash": "4e8bc64ff00f2e35ff12c7b54556e83ed5a0b2ed",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/5f005b1a7d6a630001694eb4_color.png",
+            "target_hash": "c512d1be80898bbc158ee75f43e3013e3d2f4472"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/black.png",
+            "source_hash": "6542e5a67050922e970b1094cc7acdf65c7658bc",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/black.png",
+            "target_hash": "ae64e956611a3a45a40475754a8061c0eda6c1bf"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/normal.png",
+            "source_hash": "f30e1cddaf7deafcff0ebe08d73f2d74a57faf6f",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/normal.png",
+            "target_hash": "b246c14f74ddc4c6416f41ae5527e4512335c0ec"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/white.png",
+            "source_hash": "f19fcb454d486b954631f0fe379d024fb8a11441",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Textures/white.png",
+            "target_hash": "6f3f8fd9c48ac74270405ed6635d7ba3db6ea990"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture0.jpg",
+            "source_hash": "f72a92413835f1393d5630e134a483e202f33741",
+            "target_url": "./object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture0.jpg",
+            "target_hash": "852227483004e8bcb00275e320650921d5812818"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture1.png",
+            "source_hash": "3929176bde7252f2c8f32be4be5f0e80e9a0ea0b",
+            "target_url": "./object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture1.png",
+            "target_hash": "2e334bd523644d70f3edefcf33fcc36005c037ce"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture2.jpg",
+            "source_hash": "6451926db3015969475f884f9607d61352b40e71",
+            "target_url": "./object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture2.jpg",
+            "target_hash": "90712ae3264ed8244590d614818a6b23b6938034"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture3.jpg",
+            "source_hash": "17e5fe26255e5c47c9923a5ddb5c99edf69e8872",
+            "target_url": "./object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture3.jpg",
+            "target_hash": "1a840611ac1825886412828a69cab1274f5b9b72"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture4.png",
+            "source_hash": "b3d626104e3501b9cc23f3bf20246d6ead423bb8",
+            "target_url": "./object_usds/objaverse_usd/textures/48a6aed1dff24e57b6836ade47a46ead_texture4.png",
+            "target_hash": "6094f1e3a039f52e676fd708045d32e4eec83d86"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/objaverse_usd/textures/c7aa636f24e345b3b831271bf7f1fe02_texture0.jpg",
+            "source_hash": "8502b729749aa052b5c3e8f71e89b5c2b0968c38",
+            "target_url": "./object_usds/objaverse_usd/textures/c7aa636f24e345b3b831271bf7f1fe02_texture0.jpg",
+            "target_hash": "c37422383604fa93783f7f4eaa60861f7a6a53a7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Num5df0a8e15974ed0001f1de95.mdl",
+            "source_hash": "37cd5602f27c8bb346fa538680526f908789d86d",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/Num5df0a8e15974ed0001f1de95.mdl",
+            "target_hash": "55cdd7bb054f3041706dde552d8470c4ede1bd63"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/OmniUe4Function.mdl",
+            "source_hash": "22b31cc0015bb18c7ddcb01436add65fbc6227ef",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/OmniUe4Function.mdl",
+            "target_hash": "cd837b08e065dd12e6568e4b7028bb83c4f6694e"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_drink/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/OmniUe4Base.mdl",
+            "source_hash": "5d0fd5dcba283aebbd7768c860eb4effa0027d03",
+            "target_url": "./object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/OmniUe4Base.mdl",
+            "target_hash": "52c2c9c96888ffaf6fe8a5f522fbbdfdda78380f"
+        }
+    ]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/grutopia_usd/Table/table/35565d61cac99576e47beb2a926bbf93/Materials/OmniUe4Function.mdl

@@ -0,0 +1,1413 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+
+//* 1.0.1 - using absolute import paths when importing standard modules
+
+mdl 1.6;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+
+export float3 convert_to_left_hand(float3 vec3, uniform bool up_z = true, uniform bool is_position = true)
+[[
+    anno::description("convert from RH to LH"),
+	anno::noinline()
+]]
+{
+	float4x4 ZupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4x4 YupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4 vec4 = float4(vec3.x, vec3.y, vec3.z, is_position ? 1.0f : 0.0f);
+
+	vec4 = vec4 * (up_z ? ZupConversion : YupConversion);
+
+	return float3(vec4.x, vec4.y, vec4.z);
+}
+
+export float3 transform_vector_from_tangent_to_world(float3 vector, 
+													uniform bool up_z = true, 
+													float3 tangent_u = state::texture_tangent_u(0),
+    												float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from tangent space to world space"),
+    anno::noinline()
+]]
+{
+	/* flip_tangent_v */
+    return  convert_to_left_hand(
+			tangent_u * vector.x - tangent_v * vector.y + state::normal() * vector.z, 
+			up_z, false);
+}
+
+export float3 transform_vector_from_world_to_tangent(float3 vector, 
+													uniform bool up_z = true,
+													float3 tangent_u = state::texture_tangent_u(0),
+													float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from world space to tangent space"),
+    anno::noinline()
+]]
+{
+	float3 vecRH = convert_to_left_hand(vector, up_z, false);
+	/* flip_tangent_v */
+	return 	vecRH.x * float3(tangent_u.x, -tangent_v.x, state::normal().x) +
+        	vecRH.y * float3(tangent_u.y, -tangent_v.y, state::normal().y) +
+        	vecRH.z * float3(tangent_u.z, -tangent_v.z, state::normal().z);
+}
+
+export float4 unpack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Unpack a normal stored in a normal map"),
+    anno::noinline()
+]]
+{
+    float2 normal_xy = float2(texture_sample.x, texture_sample.y);
+
+	normal_xy = normal_xy * float2(2.0,2.0) - float2(1.0,1.0);
+	float normal_z = math::sqrt( math::saturate( 1.0 - math::dot( normal_xy, normal_xy ) ) );
+	return float4( normal_xy.x, normal_xy.y, normal_z, 1.0 );
+}
+
+// for get color value from normal.
+export float4 pack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Pack to color from a normal")
+]]
+{
+    float2 return_xy = float2(texture_sample.x, texture_sample.y);
+
+	return_xy = (return_xy + float2(1.0,1.0)) / float2(2.0,2.0);
+	
+	return float4( return_xy.x, return_xy.y, 0.0, 1.0 );
+}
+
+export float4 greyscale_texture_lookup(
+    float4 texture_sample = float4(0.0, 0.0, 0.0, 1.0)
+    )
+[[
+    anno::description("Sampling a greyscale texture"),
+    anno::noinline()
+]]
+{
+    return float4(texture_sample.x, texture_sample.x, texture_sample.x, texture_sample.x);
+}     
+
+export float3 pixel_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Pixel normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 vertex_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Vertex normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 landscape_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Landscape normal in world space")
+]]
+{
+	float3 normalFromNormalmap = math::floor((::vertex_normal_world_space(up_z) * 0.5 + 0.5) * 255.0) / 255.0 * 2.0 - 1.0;
+	
+	float2 normalXY = float2(normalFromNormalmap.x, normalFromNormalmap.y);
+	return float3(normalXY.x, normalXY.y, math::sqrt(math::saturate(1.0 - math::dot(normalXY, normalXY))));
+}
+
+// Different implementation specific between mdl and hlsl for smoothstep
+export float smoothstep(float a, float b, float l)
+{
+	if (a < b)
+	{
+		return math::smoothstep(a, b, l);
+	}
+	else if (a > b)
+	{
+		return 1.0 - math::smoothstep(b, a, l);
+	}
+	else
+	{
+		return l <= a ? 0.0 : 1.0;
+	}
+}
+
+export float2 smoothstep(float2 a, float2 b, float2 l)
+{
+	return float2(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y));
+}
+
+export float3 smoothstep(float3 a, float3 b, float3 l)
+{
+	return float3(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z));
+}
+
+export float4 smoothstep(float4 a, float4 b, float4 l)
+{
+	return float4(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z), smoothstep(a.w, b.w, l.w));
+}
+
+export float2 smoothstep(float2 a, float2 b, float l)
+{
+	return float2(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l));
+}
+
+export float3 smoothstep(float3 a, float3 b, float l)
+{
+	return float3(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l));
+}
+
+export float4 smoothstep(float4 a, float4 b, float l)
+{
+	return float4(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l), smoothstep(a.w, b.w, l));
+}
+
+export float2 smoothstep(float a, float b, float2 l)
+{
+	return float2(smoothstep(a, b, l.x), smoothstep(a, b, l.y));
+}
+
+export float3 smoothstep(float a, float b, float3 l)
+{
+	return float3(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z));
+}
+
+export float4 smoothstep(float a, float b, float4 l)
+{
+	return float4(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z), smoothstep(a, b, l.w));
+}
+
+//------------------ Random from UE4 -----------------------
+float length2(float3 v)
+{
+	return math::dot(v, v);
+}
+
+float3 GetPerlinNoiseGradientTextureAt(uniform texture_2d PerlinNoiseGradientTexture, float3 v)
+{
+	const float2 ZShear = float2(17.0f, 89.0f);
+
+	float2 OffsetA = v.z * ZShear;
+	float2 TexA = (float2(v.x, v.y) + OffsetA + 0.5f) / 128.0f;
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA.x,1.0-TexA.y),tex::wrap_repeat,tex::wrap_repeat);
+	return float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z) * 2.0 - 1.0;
+}
+
+float3 SkewSimplex(float3 In)
+{
+	return In + math::dot(In, float3(1.0 / 3.0f) );
+}
+float3 UnSkewSimplex(float3 In)
+{
+	return In - math::dot(In, float3(1.0 / 6.0f) );
+}
+
+// 3D random number generator inspired by PCGs (permuted congruential generator)
+// Using a **simple** Feistel cipher in place of the usual xor shift permutation step
+// @param v = 3D integer coordinate
+// @return three elements w/ 16 random bits each (0-0xffff).
+// ~8 ALU operations for result.x    (7 mad, 1 >>)
+// ~10 ALU operations for result.xy  (8 mad, 2 >>)
+// ~12 ALU operations for result.xyz (9 mad, 3 >>)
+
+//TODO: uint3
+int3 Rand3DPCG16(int3 p)
+{
+	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
+	//TODO: uint3
+	int3 v = int3(p);
+
+	// Linear congruential step. These LCG constants are from Numerical Recipies
+	// For additional #'s, PCG would do multiple LCG steps and scramble each on output
+	// So v here is the RNG state
+	v = v * 1664525 + 1013904223;
+
+	// PCG uses xorshift for the final shuffle, but it is expensive (and cheap
+	// versions of xorshift have visible artifacts). Instead, use simple MAD Feistel steps
+	//
+	// Feistel ciphers divide the state into separate parts (usually by bits)
+	// then apply a series of permutation steps one part at a time. The permutations
+	// use a reversible operation (usually ^) to part being updated with the result of
+	// a permutation function on the other parts and the key.
+	//
+	// In this case, I'm using v.x, v.y and v.z as the parts, using + instead of ^ for
+	// the combination function, and just multiplying the other two parts (no key) for 
+	// the permutation function.
+	//
+	// That gives a simple mad per round.
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+
+	// only top 16 bits are well shuffled
+	return v >> 16;
+}
+
+// Wraps noise for tiling texture creation
+// @param v = unwrapped texture parameter
+// @param bTiling = true to tile, false to not tile
+// @param RepeatSize = number of units before repeating
+// @return either original or wrapped coord
+float3 NoiseTileWrap(float3 v,  bool bTiling, float RepeatSize)
+{
+	return bTiling ? (math::frac(v / RepeatSize) * RepeatSize) : v;
+}
+
+// Evaluate polynomial to get smooth transitions for Perlin noise
+// only needed by Perlin functions in this file
+// scalar(per component): 2 add, 5 mul
+float4 PerlinRamp(float4 t)
+{
+	return t * t * t * (t * (t * 6 - 15) + 10); 
+}
+
+// Blum-Blum-Shub-inspired pseudo random number generator
+// http://www.umbc.edu/~olano/papers/mNoise.pdf
+// real BBS uses ((s*s) mod M) with bignums and M as the product of two huge Blum primes
+// instead, we use a single prime M just small enough not to overflow
+// note that the above paper used 61, which fits in a half, but is unusably bad
+// @param Integer valued floating point seed
+// @return random number in range [0,1)
+// ~8 ALU operations (5 *, 3 frac)
+float RandBBSfloat(float seed)
+{
+	float BBS_PRIME24 = 4093.0;
+	float s = math::frac(seed / BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	return s;
+}
+
+// Modified noise gradient term
+// @param seed - random seed for integer lattice position
+// @param offset - [-1,1] offset of evaluation point from lattice point
+// @return gradient direction (xyz) and contribution (w) from this lattice point
+float4 MGradient(int seed, float3 offset)
+{
+	//TODO uint
+	int rand = Rand3DPCG16(int3(seed,0,0)).x;
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1.0 / 0x4000, 1.0 / 0x2000, 1.0 / 0x1000);
+	float3 direction = float3(int3(rand, rand, rand) & MGradientMask) * MGradientScale - 1;
+	return float4(direction.x, direction.y, direction.z, math::dot(direction, offset));
+}
+
+// compute Perlin and related noise corner seed values
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = true to return seed values for a repeating noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @param seed000-seed111 = hash function seeds for the eight corners
+// @return fractional part of v
+struct SeedValue
+{
+	float3 fv = float3(0);
+	float seed000 = 0;
+	float seed001 = 0;
+	float seed010 = 0;
+	float seed011 = 0;
+	float seed100 = 0;
+	float seed101 = 0;
+	float seed110 = 0;
+	float seed111 = 0;
+};
+
+SeedValue NoiseSeeds(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds;
+	seeds.fv = math::frac(v);
+	float3 iv = math::floor(v);
+
+	const float3 primes = float3(19, 47, 101);
+
+	if (bTiling)
+	{	// can't algebraically combine with primes
+		seeds.seed000 = math::dot(primes, NoiseTileWrap(iv, true, RepeatSize));
+		seeds.seed100 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 0), true, RepeatSize));
+		seeds.seed010 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 0), true, RepeatSize));
+		seeds.seed110 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 0), true, RepeatSize));
+		seeds.seed001 = math::dot(primes, NoiseTileWrap(iv + float3(0, 0, 1), true, RepeatSize));
+		seeds.seed101 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 1), true, RepeatSize));
+		seeds.seed011 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 1), true, RepeatSize));
+		seeds.seed111 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 1), true, RepeatSize));
+	}
+	else
+	{	// get to combine offsets with multiplication by primes in this case
+		seeds.seed000 = math::dot(iv, primes);
+		seeds.seed100 = seeds.seed000 + primes.x;
+		seeds.seed010 = seeds.seed000 + primes.y;
+		seeds.seed110 = seeds.seed100 + primes.y;
+		seeds.seed001 = seeds.seed000 + primes.z;
+		seeds.seed101 = seeds.seed100 + primes.z;
+		seeds.seed011 = seeds.seed010 + primes.z;
+		seeds.seed111 = seeds.seed110 + primes.z;
+	}
+
+	return seeds;
+}
+
+struct SimplexWeights
+{
+	float4 Result = float4(0);
+	float3 PosA = float3(0);
+	float3 PosB = float3(0);
+	float3 PosC = float3(0);
+	float3 PosD = float3(0);
+};
+
+// Computed weights and sample positions for simplex interpolation
+// @return float4(a,b,c, d) Barycentric coordinate defined as Filtered = Tex(PosA) * a + Tex(PosB) * b + Tex(PosC) * c + Tex(PosD) * d
+SimplexWeights ComputeSimplexWeights3D(float3 OrthogonalPos)
+{
+	SimplexWeights weights;
+	float3 OrthogonalPosFloor = math::floor(OrthogonalPos);
+
+	weights.PosA = OrthogonalPosFloor;
+	weights.PosB = weights.PosA + float3(1, 1, 1);
+
+	OrthogonalPos -= OrthogonalPosFloor;
+
+	float Largest = math::max(OrthogonalPos.x, math::max(OrthogonalPos.y, OrthogonalPos.z));
+	float Smallest = math::min(OrthogonalPos.x, math::min(OrthogonalPos.y, OrthogonalPos.z));
+
+	weights.PosC = weights.PosA + float3(Largest == OrthogonalPos.x, Largest == OrthogonalPos.y, Largest == OrthogonalPos.z);
+	weights.PosD = weights.PosA + float3(Smallest != OrthogonalPos.x, Smallest != OrthogonalPos.y, Smallest != OrthogonalPos.z);
+
+	float RG = OrthogonalPos.x - OrthogonalPos.y;
+	float RB = OrthogonalPos.x - OrthogonalPos.z;
+	float GB = OrthogonalPos.y - OrthogonalPos.z;
+
+	weights.Result.z = 
+		  math::min(math::max(0, RG), math::max(0, RB))		// X
+		+ math::min(math::max(0, -RG), math::max(0, GB))		// Y
+		+ math::min(math::max(0, -RB), math::max(0, -GB));	// Z
+	
+	weights.Result.w = 
+		  math::min(math::max(0, -RG), math::max(0, -RB))		// X
+		+ math::min(math::max(0, RG), math::max(0, -GB))		// Y
+		+ math::min(math::max(0, RB), math::max(0, GB));		// Z
+
+	weights.Result.y = Smallest;
+	weights.Result.x = 1.0f - weights.Result.y - weights.Result.z - weights.Result.w;
+
+	return weights;
+}
+
+// filtered 3D gradient simple noise (few texture lookups, high quality)
+// @param v >0
+// @return random number in the range -1 .. 1
+float SimplexNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 EvalPos)
+{
+	float3 OrthogonalPos = SkewSimplex(EvalPos);
+
+	SimplexWeights Weights = ComputeSimplexWeights3D(OrthogonalPos);
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 32 bit)
+	float3 A = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosA);
+	float3 B = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosB);
+	float3 C = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosC);
+	float3 D = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosD);
+	
+	Weights.PosA = UnSkewSimplex(Weights.PosA);
+	Weights.PosB = UnSkewSimplex(Weights.PosB);
+	Weights.PosC = UnSkewSimplex(Weights.PosC);
+	Weights.PosD = UnSkewSimplex(Weights.PosD);
+
+	float DistanceWeight;
+
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosA));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float a = math::dot(A, EvalPos - Weights.PosA) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosB));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float b = math::dot(B, EvalPos - Weights.PosB) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosC));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float c = math::dot(C, EvalPos - Weights.PosC) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosD));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float d = math::dot(D, EvalPos - Weights.PosD) * DistanceWeight;
+
+	return 32 * (a + b + c + d);
+}
+
+// filtered 3D noise, can be optimized
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 v, bool bTiling, float RepeatSize)
+{
+	bTiling = true;
+	float3 fv = math::frac(v);
+	float3 iv0 = NoiseTileWrap(math::floor(v), bTiling, RepeatSize);
+	float3 iv1 = NoiseTileWrap(iv0 + 1, bTiling, RepeatSize);
+
+	const int2 ZShear = int2(17, 89);
+	
+	float2 OffsetA = iv0.z * ZShear;
+	float2 OffsetB = OffsetA + ZShear;	// non-tiling, use relative offset
+	if (bTiling)						// tiling, have to compute from wrapped coordinates
+	{
+		OffsetB = iv1.z * ZShear;
+	}
+
+	// Texture size scale factor
+	float ts = 1 / 128.0f;
+
+	// texture coordinates for iv0.xy, as offset for both z slices
+	float2 TexA0 = (float2(iv0.x, iv0.y) + OffsetA + 0.5f) * ts;
+	float2 TexB0 = (float2(iv0.x, iv0.y) + OffsetB + 0.5f) * ts;
+
+	// texture coordinates for iv1.xy, as offset for both z slices
+	float2 TexA1 = TexA0 + ts;	// for non-tiling, can compute relative to existing coordinates
+	float2 TexB1 = TexB0 + ts;
+	if (bTiling)				// for tiling, need to compute from wrapped coordinates
+	{
+		TexA1 = (float2(iv1.x, iv1.y) + OffsetA + 0.5f) * ts;
+		TexB1 = (float2(iv1.x, iv1.y) + OffsetB + 0.5f) * ts;
+	}
+
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 8, 16 or 32 bit)
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 A = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 B = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 C = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 D = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 E = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 F = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 G = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 H = PerlinNoiseColor * 2 - 1;
+
+	float a = math::dot(A, fv - float3(0, 0, 0));
+	float b = math::dot(B, fv - float3(1, 0, 0));
+	float c = math::dot(C, fv - float3(0, 1, 0));
+	float d = math::dot(D, fv - float3(1, 1, 0));
+	float e = math::dot(E, fv - float3(0, 0, 1));
+	float f = math::dot(F, fv - float3(1, 0, 1));
+	float g = math::dot(G, fv - float3(0, 1, 1));
+	float h = math::dot(H, fv - float3(1, 1, 1));
+
+	float4 Weights = PerlinRamp(math::frac(float4(fv.x, fv.y, fv.z, 0)));
+	
+	float i = math::lerp(math::lerp(a, b, Weights.x), math::lerp(c, d, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(e, f, Weights.x), math::lerp(g, h, Weights.x), Weights.y);
+
+	return math::lerp(i, j, Weights.z);
+}
+
+// @return random number in the range -1 .. 1
+// scalar: 6 frac, 31 mul/mad, 15 add, 
+float FastGradientPerlinNoise3D_TEX(uniform texture_3d PerlinNoise3DTexture, float3 xyz)
+{
+	// needs to be the same value when creating the PerlinNoise3D texture
+	float Extent = 16;
+
+	// last texel replicated and needed for filtering
+	// scalar: 3 frac, 6 mul
+	xyz = math::frac(xyz / (Extent - 1)) * (Extent - 1);
+
+	// scalar: 3 frac
+	float3 uvw = math::frac(xyz);
+	// = floor(xyz);
+	// scalar: 3 add
+	float3 p0 = xyz - uvw;
+//	float3 f = math::pow(uvw, 2) * 3.0f - math::pow(uvw, 3) * 2.0f;	// original perlin hermite (ok when used without bump mapping)
+	// scalar: 2*3 add 5*3 mul
+	float4 pr = PerlinRamp(float4(uvw.x, uvw.y, uvw.z, 0));
+	float3 f = float3(pr.x, pr.y, pr.z);	// new, better with continues second derivative for bump mapping
+	// scalar: 3 add
+	float3 p = p0 + f;
+	// scalar: 3 mad
+	// TODO: need reverse???
+	float4 NoiseSample = tex::lookup_float4(PerlinNoise3DTexture, p / Extent + 0.5f / Extent);	// +0.5f to get rid of bilinear offset
+
+	// reconstruct from 8bit (using mad with 2 constants and dot4 was same instruction count)
+	// scalar: 4 mad, 3 mul, 3 add 
+	float3 n = float3(NoiseSample.x, NoiseSample.y, NoiseSample.z) * 255.0f / 127.0f - 1.0f;
+	float d = NoiseSample.w * 255.f - 127;
+	return math::dot(xyz, n) - d;
+}
+
+// Perlin-style "Modified Noise"
+// http://www.umbc.edu/~olano/papers/index.html#mNoise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = MGradient(int(seeds.seed000), seeds.fv - float3(0, 0, 0)).w;
+	float rand100 = MGradient(int(seeds.seed100), seeds.fv - float3(1, 0, 0)).w;
+	float rand010 = MGradient(int(seeds.seed010), seeds.fv - float3(0, 1, 0)).w;
+	float rand110 = MGradient(int(seeds.seed110), seeds.fv - float3(1, 1, 0)).w;
+	float rand001 = MGradient(int(seeds.seed001), seeds.fv - float3(0, 0, 1)).w;
+	float rand101 = MGradient(int(seeds.seed101), seeds.fv - float3(1, 0, 1)).w;
+	float rand011 = MGradient(int(seeds.seed011), seeds.fv - float3(0, 1, 1)).w;
+	float rand111 = MGradient(int(seeds.seed111), seeds.fv - float3(1, 1, 1)).w;
+
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D value noise - used to be incorrectly called Perlin noise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float ValueNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = RandBBSfloat(seeds.seed000) * 2 - 1;
+	float rand100 = RandBBSfloat(seeds.seed100) * 2 - 1;
+	float rand010 = RandBBSfloat(seeds.seed010) * 2 - 1;
+	float rand110 = RandBBSfloat(seeds.seed110) * 2 - 1;
+	float rand001 = RandBBSfloat(seeds.seed001) * 2 - 1;
+	float rand101 = RandBBSfloat(seeds.seed101) * 2 - 1;
+	float rand011 = RandBBSfloat(seeds.seed011) * 2 - 1;
+	float rand111 = RandBBSfloat(seeds.seed111) * 2 - 1;
+	
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+	
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D jitter offset within a voronoi noise cell
+// @param pos - integer lattice corner
+// @return random offsets vector
+float3 VoronoiCornerSample(float3 pos, int Quality)
+{
+	// random values in [-0.5, 0.5]
+	float3 noise = float3(Rand3DPCG16(int3(pos))) / 0xffff - 0.5;
+
+	// quality level 1 or 2: searches a 2x2x2 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 2x2x2 search
+	if (Quality <= 2)
+	{
+		return math::normalize(noise) * 0.2588;
+	}
+
+	// quality level 3: searches a 3x3x3 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 3x3x3 search
+	if (Quality == 3)
+	{
+		return math::normalize(noise) * 0.3090;
+	}
+
+	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
+	return noise;
+}
+
+// compare previous best with a new candidate
+// not producing point locations makes it easier for compiler to eliminate calculations when they're not needed
+// @param minval = location and distance of best candidate seed point before the new one
+// @param candidate = candidate seed point
+// @param offset = 3D offset to new candidate seed point
+// @param bDistanceOnly = if true, only set maxval.w with distance, otherwise maxval.w is distance and maxval.xyz is position
+// @return position (if bDistanceOnly is false) and distance to closest seed point so far
+float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
+{
+	if (bDistanceOnly)
+	{
+		return float4(0, 0, 0, math::min(minval.w, math::dot(offset, offset)));
+	}
+	else
+	{
+		float newdist = math::dot(offset, offset);
+		return newdist > minval.w ? minval : float4(candidate.x, candidate.y, candidate.z, newdist);
+	}
+}
+
+// 220 instruction Worley noise
+float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
+{
+	float3 fv = math::frac(v),  fv2 = math::frac(v + 0.5);
+	float3 iv = math::floor(v), iv2 = math::floor(v + 0.5);
+
+	// with initial minimum distance = infinity (or at least bigger than 4), first min is optimized away
+	float4 mindist = float4(0,0,0,100);
+	float3 p, offset;
+
+	// quality level 3: do a 3x3x3 search
+	if (Quality == 3)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = -1; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = -1; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = -1; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// everybody else searches a base 2x2x2 neighborhood
+	else
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = 0; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// quality level 2, do extra set of points, offset by half a cell
+					if (Quality == 2)
+					{
+						// 467 is just an offset to a different area in the random number field to avoid similar neighbor artifacts
+						p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize) + 467, Quality);
+						mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+					}
+				}
+			}
+		}
+	}
+
+	// quality level 4: add extra sets of four cells in each direction
+	if (Quality >= 4)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;	
+		for (offset_x = -1; offset_x <= 2; offset_x += 3)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					// along x axis
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along y axis
+					p = float3(offset.y, offset.z, offset.x) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.y, offset.z, offset.x), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along z axis
+					p = float3(offset.z, offset.x, offset.y) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.z, offset.x, offset.y), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// transform squared distance to real distance
+	return float4(mindist.x, mindist.y, mindist.z, math::sqrt(mindist.w));
+}
+
+// Coordinates for corners of a Simplex tetrahedron
+// Based on McEwan et al., Efficient computation of noise in GLSL, JGT 2011
+// @param v = 3D noise argument
+// @return 4 corner locations
+float4x3 SimplexCorners(float3 v)
+{
+	// find base corner by skewing to tetrahedral space and back
+	float3 tet = math::floor(v + v.x/3 + v.y/3 + v.z/3);
+	float3 base = tet - tet.x/6 - tet.y/6 - tet.z/6;
+	float3 f = v - base;
+
+	// Find offsets to other corners (McEwan did this in tetrahedral space,
+	// but since skew is along x=y=z axis, this works in Euclidean space too.)
+	float3 g = math::step(float3(f.y,f.z,f.x), float3(f.x,f.y,f.z)), h = 1 - float3(g.z, g.x, g.y);
+	float3 a1 = math::min(g, h) - 1.0 / 6.0, a2 = math::max(g, h) - 1.0 / 3.0;
+
+	// four corners
+	return float4x3(base, base + a1, base + a2, base + 0.5);
+}
+
+// Improved smoothing function for simplex noise
+// @param f = fractional distance to four tetrahedral corners
+// @return weight for each corner
+float4 SimplexSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	return (1 * scale + s*(-3 * scale + s*(3 * scale - s*scale)));
+}
+
+// Derivative of simplex noise smoothing function
+// @param f = fractional distanc eto four tetrahedral corners
+// @return derivative of smoothing function for each corner by x, y and z
+float3x4 SimplexDSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	s = -12 * scale + s*(24 * scale - s * 12 * scale);
+
+	return float3x4(
+		s * float4(f[0][0], f[1][0], f[2][0], f[3][0]),
+		s * float4(f[0][1], f[1][1], f[2][1], f[3][1]),
+		s * float4(f[0][2], f[1][2], f[2][2], f[3][2]));
+}
+
+// Simplex noise and its Jacobian derivative
+// @param v = 3D noise argument
+// @param bTiling = whether to repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension, must be a multiple of 3
+// @return float3x3 Jacobian in J[*].xyz, vector noise in J[*].w
+//     J[0].w, J[1].w, J[2].w is a Perlin-style simplex noise with vector output, e.g. (Nx, Ny, Nz)
+//     J[i].x is X derivative of the i'th component of the noise so J[2].x is dNz/dx
+// You can use this to compute the noise, gradient, curl, or divergence:
+//   float3x4 J = JacobianSimplex_ALU(...);
+//   float3 VNoise = float3(J[0].w, J[1].w, J[2].w);	// 3D noise
+//   float3 Grad = J[0].xyz;							// gradient of J[0].w
+//   float3 Curl = float3(J[1][2]-J[2][1], J[2][0]-J[0][2], J[0][1]-J[1][2]);
+//   float Div = J[0][0]+J[1][1]+J[2][2];
+// All of these are confirmed to compile out all unneeded terms.
+// So Grad of X doesn't compute Y or Z components, and VNoise doesn't do any of the derivative computation.
+float3x4 JacobianSimplex_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1. / 0x4000, 1. / 0x2000, 1. / 0x1000);
+
+	// corners of tetrahedron
+	float4x3 T = SimplexCorners(v);
+	// TODO: uint3
+	int3 rand = int3(0);
+	float4x3 gvec0 = float4x3(1.0);
+	float4x3 gvec1 = float4x3(1.0);
+	float4x3 gvec2 = float4x3(1.0);
+	float4x3 fv = float4x3(1.0);
+	float3x4 grad = float3x4(1.0);
+
+	// processing of tetrahedral vertices, unrolled
+	// to compute gradient at each corner
+	fv[0] = v - T[0];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[0] + 0.5, bTiling, RepeatSize))));
+	gvec0[0] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[0] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[0] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][0] = math::dot(gvec0[0], fv[0]);
+	grad[1][0] = math::dot(gvec1[0], fv[0]);
+	grad[2][0] = math::dot(gvec2[0], fv[0]);
+
+	fv[1] = v - T[1];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[1] + 0.5, bTiling, RepeatSize))));
+	gvec0[1] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][1] = math::dot(gvec0[1], fv[1]);
+	grad[1][1] = math::dot(gvec1[1], fv[1]);
+	grad[2][1] = math::dot(gvec2[1], fv[1]);
+
+	fv[2] = v - T[2];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[2] + 0.5, bTiling, RepeatSize))));
+	gvec0[2] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[2] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[2] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][2] = math::dot(gvec0[2], fv[2]);
+	grad[1][2] = math::dot(gvec1[2], fv[2]);
+	grad[2][2] = math::dot(gvec2[2], fv[2]);
+
+	fv[3] = v - T[3];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[3] + 0.5, bTiling, RepeatSize))));
+	gvec0[3] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[3] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[3] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][3] = math::dot(gvec0[3], fv[3]);
+	grad[1][3] = math::dot(gvec1[3], fv[3]);
+	grad[2][3] = math::dot(gvec2[3], fv[3]);
+
+	// blend gradients
+	float4 sv = SimplexSmooth(fv);
+	float3x4 ds = SimplexDSmooth(fv);
+
+	float3x4 jacobian = float3x4(1.0);
+	float3 vec0 = gvec0*sv + grad[0]*ds; // NOTE: mdl is column major, convert from UE4 (row major)
+	jacobian[0] = float4(vec0.x, vec0.y, vec0.z, math::dot(sv, grad[0]));
+	float3 vec1 = gvec1*sv + grad[1]*ds;
+	jacobian[1] = float4(vec1.x, vec1.y, vec1.z, math::dot(sv, grad[1]));
+	float3 vec2 = gvec2*sv + grad[2]*ds;
+	jacobian[2] = float4(vec2.x, vec2.y, vec2.z, math::dot(sv, grad[2]));
+
+	return jacobian;
+}
+
+// While RepeatSize is a float here, the expectation is that it would be largely integer values coming in from the UI. The downstream logic assumes
+// floats for all called functions (NoiseTileWrap) and this prevents any float-to-int conversion errors from automatic type conversion.
+float Noise3D_Multiplexer(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, int Function, float3 Position, int Quality, bool bTiling, float RepeatSize)
+{
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch(Function)
+	{
+		case 0:
+			return SimplexNoise3D_TEX(PerlinNoiseGradientTexture, Position);
+		case 1:
+			return GradientNoise3D_TEX(PerlinNoiseGradientTexture, Position, bTiling, RepeatSize);
+		case 2:
+			return FastGradientPerlinNoise3D_TEX(PerlinNoise3DTexture, Position);
+		case 3:
+			return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 4:
+			return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 5:
+			return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2.0 - 1.0;
+	}
+	return 0;
+}
+//----------------------------------------------------------
+
+export float noise(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, float3 Position, float Scale, float Quality, float Function, float Turbulence, float Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, float Tiling, float RepeatSize)
+[[
+    anno::description("Noise"),
+    anno::noinline()
+]]
+{
+	Position *= Scale;
+	FilterWidth *= Scale;
+
+	float Out = 0.0f;
+	float OutScale = 1.0f;
+	float InvLevelScale = 1.0f / LevelScale;
+	
+	int iFunction(Function);
+	int iQuality(Quality);
+	int iLevels(Levels);
+	bool bTurbulence(Turbulence);
+	bool bTiling(Tiling);
+	
+	for(int i = 0; i < iLevels; ++i)
+	{
+		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
+		OutScale *= math::saturate(1.0 - FilterWidth);
+
+		if(bTurbulence)
+		{
+			Out += math::abs(Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize)) * OutScale;
+		}
+		else
+		{
+			Out += Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize) * OutScale;
+		}
+
+		Position *= LevelScale;
+		RepeatSize *= LevelScale;
+		OutScale *= InvLevelScale;
+		FilterWidth *= LevelScale;
+	}
+
+	if(!bTurbulence)
+	{
+		// bring -1..1 to 0..1 range
+		Out = Out * 0.5f + 0.5f;
+	}
+
+	// Out is in 0..1 range
+	return math::lerp(OutputMin, OutputMax, Out);
+}
+
+// Material node for noise functions returning a vector value
+// @param LevelScale usually 2 but higher values allow efficient use of few levels
+// @return in user defined range (OutputMin..OutputMax)
+export float4 vector4_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise"),
+    anno::noinline()
+]]
+{
+	float4 result = float4(0,0,0,1);
+	float3 ret = float3(0);
+	int iQuality = int(Quality);
+	int iFunction = int(Function);
+	bool bTiling = Tiling > 0.0;
+	
+	float3x4 Jacobian = JacobianSimplex_ALU(Position, bTiling, TileSize);	// compiled out if not used
+
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch (iFunction)
+	{
+	case 0:	// Cellnoise
+		ret = float3(Rand3DPCG16(int3(math::floor(NoiseTileWrap(Position, bTiling, TileSize))))) / 0xffff;
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 1: // Color noise
+		ret = float3(Jacobian[0].w, Jacobian[1].w, Jacobian[2].w);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 2: // Gradient
+		result = Jacobian[0];
+		break;
+	case 3: // Curl
+		ret = float3(Jacobian[2][1] - Jacobian[1][2], Jacobian[0][2] - Jacobian[2][0], Jacobian[1][0] - Jacobian[0][1]);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 4: // Voronoi
+		result = VoronoiNoise3D_ALU(Position, iQuality, bTiling, TileSize, false);
+		break;
+	}
+	return result;
+}
+
+export float3 vector3_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise float3 version"),
+    anno::noinline()
+]]
+{
+	float4 noise = vector4_noise(Position, Quality, Function, Tiling, TileSize);
+	return float3(noise.x, noise.y, noise.z);
+}
+
+
+// workaround for ue4 fresnel (without supporting for camera vector) : replacing it with 0.0, means facing to the view
+export float fresnel(float exponent [[anno::unused()]], float base_reflect_fraction [[anno::unused()]], float3 normal [[anno::unused()]])
+[[
+    anno::description("Fresnel"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float fresnel_function(float3 normal_vector [[anno::unused()]], float3 camera_vector [[anno::unused()]], 
+                                bool invert_fresnel [[anno::unused()]], float power [[anno::unused()]], 
+                                bool use_cheap_contrast [[anno::unused()]], float cheap_contrast_dark [[anno::unused()]], float cheap_contrast_bright [[anno::unused()]], 
+                                bool clamp_fresnel_dot_product [[anno::unused()]])
+[[
+    anno::description("Fresnel Function"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float3 camera_vector(uniform bool up_z = true)
+[[
+    anno::description("Camera Vector"),
+    anno::noinline()
+]]
+{
+	// assume camera postion is 0,0,0
+	return math::normalize(float3(0) - convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z));
+}
+
+export float pixel_depth()
+[[
+    anno::description("Pixel Depth"),
+    anno::noinline()
+]]
+{
+	return 256.0f;
+}
+
+export float scene_depth()
+[[
+    anno::description("Scene Depth")
+]]
+{
+	return 65500.0f;
+}
+
+export float3 scene_color()
+[[
+    anno::description("Scene Color")
+]]
+{
+	return float3(1.0f);
+}
+
+export float4 vertex_color()
+[[
+    anno::description("Vertex Color"),
+    anno::noinline()
+]]
+{
+	return float4(1.0f);
+}
+
+export float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
+[[
+    anno::description("Vertex Color for float2 PrimVar"),
+    anno::noinline()
+]]
+{
+	// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
+	return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
+}
+
+export float3 camera_position()
+[[
+    anno::description("Camera Position"),
+    anno::noinline()
+]]
+{
+	return float3(1000.0f, 0, 0);
+}
+
+export float3 rotate_about_axis(float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position)
+[[
+    anno::description("Rotates Position about the given axis by the given angle")
+]]
+{
+	// Project Position onto the rotation axis and find the closest point on the axis to Position
+	float3 NormalizedRotationAxis = float3(NormalizedRotationAxisAndAngle.x,NormalizedRotationAxisAndAngle.y,NormalizedRotationAxisAndAngle.z);
+	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxis * math::dot(NormalizedRotationAxis, Position - PositionOnAxis);
+	// Construct orthogonal axes in the plane of the rotation
+	float3 UAxis = Position - ClosestPointOnAxis;
+	float3 VAxis = math::cross(NormalizedRotationAxis, UAxis);
+	float[2] SinCosAngle = math::sincos(NormalizedRotationAxisAndAngle.w);
+	// Rotate using the orthogonal axes
+	float3 R = UAxis * SinCosAngle[1] + VAxis * SinCosAngle[0];
+	// Reconstruct the rotated world space position
+	float3 RotatedPosition = ClosestPointOnAxis + R;
+	// Convert from position to a position offset
+	return RotatedPosition - Position;
+}
+
+export float2 rotate_scale_offset_texcoords(float2 InTexCoords, float4 InRotationScale, float2 InOffset)
+[[
+    anno::description("Returns a float2 texture coordinate after 2x2 transform and offset applied")
+]]
+{
+	return float2(math::dot(InTexCoords, float2(InRotationScale.x, InRotationScale.y)), math::dot(InTexCoords, float2(InRotationScale.z, InRotationScale.w))) + InOffset;
+}
+
+export float3 reflection_custom_world_normal(float3 WorldNormal, bool bNormalizeInputNormal, uniform bool up_z = true)
+[[
+    anno::description("Reflection vector about the specified world space normal")
+]]
+{
+	if (bNormalizeInputNormal)
+	{
+		WorldNormal = math::normalize(WorldNormal);
+	}
+
+	return -camera_vector(up_z) + WorldNormal * math::dot(WorldNormal, camera_vector(up_z)) * 2.0;
+}
+
+export float3 reflection_vector(uniform bool up_z = true)
+[[
+    anno::description("Reflection Vector"),
+    anno::noinline()
+]]
+{
+    float3 normal = convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+	return reflection_custom_world_normal(normal, false, up_z);
+}
+
+export float dither_temporalAA(float AlphaThreshold = 0.5f, float Random = 1.0f [[anno::unused()]])
+[[
+    anno::description("Dither TemporalAA"),
+    anno::noinline()
+]]
+{
+	return AlphaThreshold;
+}
+
+export float3 black_body( float Temp )
+[[
+    anno::description("Black Body"),
+	anno::noinline()
+]]
+{
+	float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
+	float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
+
+	float x = 3*u / ( 2*u - 8*v + 4 );
+	float y = 2*v / ( 2*u - 8*v + 4 );
+	float z = 1 - x - y;
+
+	float Y = 1;
+	float X = Y/y * x;
+	float Z = Y/y * z;
+
+	float3x3 XYZtoRGB = float3x3(
+		float3(3.2404542, -1.5371385, -0.4985314),
+		float3(-0.9692660,  1.8760108,  0.0415560),
+		float3(0.0556434, -0.2040259,  1.0572252)
+	);
+
+	return XYZtoRGB * float3( X, Y, Z ) * math::pow( 0.0004 * Temp, 4 );
+}
+
+export float per_instance_random(uniform texture_2d PerlinNoiseGradientTexture, int NumberInstances)
+[[
+    anno::description("Per Instance Random"),
+	anno::noinline()
+]]
+{
+	float weight = state::object_id() / float(NumberInstances);	
+	return NumberInstances == 0 ? 0.0 : tex::lookup_float4(PerlinNoiseGradientTexture, float2(weight, 1.0 - weight), tex::wrap_repeat, tex::wrap_repeat).x;
+}
+
+//------------------ Hair from UE4 -----------------------
+float3 hair_absorption_to_color(float3 A)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::exp(-math::sqrt(A) * D);
+}
+
+float3 hair_color_to_absorption(float3 C)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::pow(math::log(C) / D, 2.0f);
+}
+
+export float3 get_hair_color_from_melanin(float InMelanin, float InRedness, float3 InDyeColor)
+[[
+    anno::description("Hair Color")
+]]
+{
+	InMelanin = math::saturate(InMelanin);
+	InRedness = math::saturate(InRedness);
+	float Melanin		= -math::log(math::max(1 - InMelanin, 0.0001f));
+	float Eumelanin 	= Melanin * (1 - InRedness);
+	float Pheomelanin = Melanin * InRedness;
+
+	float3 DyeAbsorption = hair_color_to_absorption(math::saturate(InDyeColor));
+	float3 Absorption = Eumelanin * float3(0.506f, 0.841f, 1.653f) + Pheomelanin * float3(0.343f, 0.733f, 1.924f);
+
+	return hair_absorption_to_color(Absorption + DyeAbsorption);
+}
+
+export float3 local_object_bounds_min()
+[[
+    anno::description("Local Object Bounds Min"),
+	anno::noinline()
+]]
+{
+	return float3(0.0);
+}
+
+export float3 local_object_bounds_max()
+[[
+    anno::description("Local Object Bounds Max"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float3 object_bounds()
+[[
+    anno::description("Object Bounds"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float object_radius()
+[[
+    anno::description("Object Radius"),
+	anno::noinline()
+]]
+{
+	return 100.0f;
+}
+
+export float3 object_world_position(uniform bool up_z = true)
+[[
+    anno::description("Object World Position"),
+	anno::noinline()
+]]
+{
+	return convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z)*state::meters_per_scene_unit()*100.0;
+}
+
+export float3 object_orientation()
+[[
+    anno::description("Object Orientation"),
+	anno::noinline()
+]]
+{
+	return float3(0);
+}
+
+export float rcp(float x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float2 rcp(float2 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float3 rcp(float3 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float4 rcp(float4 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export int BitFieldExtractI32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractI32 int"),
+	anno::noinline()
+]]
+{
+	Size &= 3;
+	Offset &= 3;
+
+	if (Size == 0)
+		return 0;
+	else if (Offset + Size < 32)
+		return (Data << (32 - Size - Offset)) >> (32 - Size);
+	else
+		return Data >> Offset;
+}
+
+export int BitFieldExtractI32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractI32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(int(Data), int(Size), int(Offset));
+}
+
+export int BitFieldExtractU32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractU32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export int BitFieldExtractU32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractU32 int"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export float3 EyeAdaptationInverseLookup(float3 LightValue, float Alpha)
+[[
+    anno::description("EyeAdaptationInverseLookup"),
+	anno::noinline()
+]]
+{
+	float Adaptation = 1.0f;
+
+	// When Alpha=0.0, we want to multiply by 1.0. when Alpha = 1.0, we want to multiply by 1/Adaptation.
+	// So the lerped value is:
+	//     LerpLogScale = Lerp(log(1),log(1/Adaptaiton),T)
+	// Which is simplified as:
+	//     LerpLogScale = Lerp(0,-log(Adaptation),T)
+	//     LerpLogScale = -T * logAdaptation;
+
+	float LerpLogScale = -Alpha * math::log(Adaptation);
+	float Scale = math::exp(LerpLogScale);
+	return LightValue * Scale;
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/08d23f3cd9254e38a696060a962ebb7f.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_08d23f3cd9254e38a696060a962ebb7f" (
+        prepend payload = @./08d23f3cd9254e38a696060a962ebb7f.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/0acdfc046a5149cc890c992da89b48c0.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_0acdfc046a5149cc890c992da89b48c0" (
+        prepend payload = @./0acdfc046a5149cc890c992da89b48c0.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/1f9f025d995c4554bcc39b97eed20c7d.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_1f9f025d995c4554bcc39b97eed20c7d" (
+        prepend payload = @./1f9f025d995c4554bcc39b97eed20c7d.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/476f8b64886f4edbae88e74f68d065c9.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_476f8b64886f4edbae88e74f68d065c9" (
+        prepend payload = @./476f8b64886f4edbae88e74f68d065c9.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/48a6aed1dff24e57b6836ade47a46ead.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_48a6aed1dff24e57b6836ade47a46ead" (
+        prepend payload = @./48a6aed1dff24e57b6836ade47a46ead.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/5b87502ac41f4eb2b2ba7b0cce6517aa.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_5b87502ac41f4eb2b2ba7b0cce6517aa" (
+        prepend payload = @./5b87502ac41f4eb2b2ba7b0cce6517aa.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/63e2323f49db4793bd087e67b20ac350.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_63e2323f49db4793bd087e67b20ac350" (
+        prepend payload = @./63e2323f49db4793bd087e67b20ac350.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/691d0e4cb6a1409ea72d960d0ab144ea.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_691d0e4cb6a1409ea72d960d0ab144ea" (
+        prepend payload = @./691d0e4cb6a1409ea72d960d0ab144ea.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/896181392c1f4e2d9316bf2eeafc3042.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_896181392c1f4e2d9316bf2eeafc3042" (
+        prepend payload = @./896181392c1f4e2d9316bf2eeafc3042.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/8d56e83387b64684ae7a1b4a20040d67.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_8d56e83387b64684ae7a1b4a20040d67" (
+        prepend payload = @./8d56e83387b64684ae7a1b4a20040d67.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/c7aa636f24e345b3b831271bf7f1fe02.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_c7aa636f24e345b3b831271bf7f1fe02" (
+        prepend payload = @./c7aa636f24e345b3b831271bf7f1fe02.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_drink/base/object_usds/objaverse_usd/eced95f9f49e4ef9b6f8d576f908bc6b.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_eced95f9f49e4ef9b6f8d576f908bc6b" (
+        prepend payload = @./eced95f9f49e4ef9b6f8d576f908bc6b.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/.collect.mapping.json

@@ -0,0 +1,263 @@
+{
+    "version": "1.0",
+    "file_records": [
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base.usd",
+            "source_hash": "abb6fa325c880c087596c8ef24456289c32c7565",
+            "target_url": "./base.usd",
+            "target_hash": "ed0f40a087b3651c567bcc71f6bdb54f49e2f100"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/brown_photostudio_02_4k.exr",
+            "source_hash": "26edc4ea55ed199916d66d890e4097c7f0175957",
+            "target_url": "./Downloads/brown_photostudio_02_4k.exr",
+            "target_hash": "6a971fac36fae4ea817618c601b5ea6507ac0a75"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/kitchen/Kitchen_KnifeHolders001.usd",
+            "source_hash": "9ce4e2adb4f97995a9770479be48632c7f7995c9",
+            "target_url": "./Downloads/kitchen/Kitchen_KnifeHolders001.usd",
+            "target_hash": "a074d028125bdb19aebd8cacd80ac408554deca3"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/kitchen/Kitchen_Shelf001.usd",
+            "source_hash": "cfdb2092c9a62b4031f4610979f3c78de1a948e8",
+            "target_url": "./Downloads/kitchen/Kitchen_Shelf001.usd",
+            "target_hash": "2c64f1380528c6e94b63def6e2768f3e990e5b4c"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/kitchen/SM_P_Flavour_02.usd",
+            "source_hash": "37db97c739826f7219d14862595d658fba330326",
+            "target_url": "./Downloads/kitchen/SM_P_Flavour_02.usd",
+            "target_hash": "fc9013aed679569c9fa825aef2d92a5828c2a724"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/instance.usd",
+            "source_hash": "71e3bd9ef0c0e48059720ab8cf37793ea7c7f191",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/instance.usd",
+            "target_hash": "85496b0cb87b52d10d5fe33c23fd3ded28530dbf"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_beef.usd",
+            "source_hash": "16bdf048d692eaeac55b0eb6ea588df90595e7cd",
+            "target_url": "./scene_sandwich/obj_beef.usd",
+            "target_hash": "4099caecfdc954dd62965cfe6387d865c69be4a8"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board1.usd",
+            "source_hash": "99a5f78c16b29c4d2299f04e116b23f08fad00c3",
+            "target_url": "./scene_sandwich/obj_board1.usd",
+            "target_hash": "6c24e7a2f502e1fb6669923530ebdf1a1332478f"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board2.usd",
+            "source_hash": "3460437d662bed30a51843e5164b8003562e1e70",
+            "target_url": "./scene_sandwich/obj_board2.usd",
+            "target_hash": "c19873d448d97e3f1f6ce18bbb21f27a3f793204"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board3.usd",
+            "source_hash": "4a92d56ea75f207f06ce7a58aa7754da0cd74b90",
+            "target_url": "./scene_sandwich/obj_board3.usd",
+            "target_hash": "bcb2beae7ca8d69108a25e43e395e0ba809a58b6"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board4.usd",
+            "source_hash": "91876cfa40165789636e60bb4f9427399c70bb09",
+            "target_url": "./scene_sandwich/obj_board4.usd",
+            "target_hash": "faddfe5a2b510b9bce6ee56acf3326c5b4d072d7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board5.usd",
+            "source_hash": "34d7e1e83e6d21483b0ceb35bdbe4949f0668501",
+            "target_url": "./scene_sandwich/obj_board5.usd",
+            "target_hash": "42d5874e77a34860d0740aa98b9229cc191f2ceb"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board6.usd",
+            "source_hash": "067c050a4db89104fc5e9e87e8a9b4fe1a214486",
+            "target_url": "./scene_sandwich/obj_board6.usd",
+            "target_hash": "3862d847a33f67ee910d900cff15f87faf360d51"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board7.usd",
+            "source_hash": "b7c2a7efc7606bc92b7f9b2153e63998dd29b20d",
+            "target_url": "./scene_sandwich/obj_board7.usd",
+            "target_hash": "4823e9dd32f3c1dba6cb77a4655ee7b496e3fe73"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_board8.usd",
+            "source_hash": "8063cd5f76e60fe2193ee209e1ef0beb1b1f47a9",
+            "target_url": "./scene_sandwich/obj_board8.usd",
+            "target_hash": "86593c9c939dfb1b7e42982a1fbcd9e4f93bcd9d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_bread2.usd",
+            "source_hash": "a2374d4334ebba77a4816d9324da8181ace08cda",
+            "target_url": "./scene_sandwich/obj_bread2.usd",
+            "target_hash": "5fcf3de21a0b240e46e224e5258b23d665de4dd9"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_bread4.usd",
+            "source_hash": "6fdf2a3f5ef2dd4efe157f446acc976dff6e0f79",
+            "target_url": "./scene_sandwich/obj_bread4.usd",
+            "target_hash": "55d48761409f3a2c2bedbfee890a903a93571895"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_lettuce.usd",
+            "source_hash": "89f3ff8bae87fae1a810a6275642398643a72540",
+            "target_url": "./scene_sandwich/obj_lettuce.usd",
+            "target_hash": "408262fdd34fc9873c3fb25b5f8ccef38dd7162a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/obj_plate.usd",
+            "source_hash": "b279153d65a72e6c98a23d0e1f9796db6d1e47ac",
+            "target_url": "./scene_sandwich/obj_plate.usd",
+            "target_hash": "8ecbe0dd5a2b8ecba0e2f16f8fb9911434ef3be2"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_diffuse.png",
+            "source_hash": "4a652a43eee48b52632f32ebc7e47dd4e8912ddd",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_diffuse.png",
+            "target_hash": "0d94585960660e3d62edf48262b7a2dd3d5415f4"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_metallic-texture_roughness.png",
+            "source_hash": "e25340345a037b07b7b968ba4e8ae01319989c28",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_metallic-texture_roughness.png",
+            "target_hash": "389b8378eb3ee167a55f225f16331071a50a9038"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_normal.png",
+            "source_hash": "da9a6ededdd5dbf6ab6ee1b39d649b5b8160c369",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/104_board_base3_converted/textures/texture_normal.png",
+            "target_hash": "7035ea720380b4856e393b24f0b6be1c476228de"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_diffuse.png",
+            "source_hash": "d9e477e99362e2547f8ee9a357aaf8c5c8550594",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_diffuse.png",
+            "target_hash": "4e3f84b0386c66158e7ca14fbeac0e59ca5dc392"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_metallic-texture_roughness.png",
+            "source_hash": "3a7aa45cafd576ffb41eba2681ea8afc3265ac7f",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_metallic-texture_roughness.png",
+            "target_hash": "60caa588fa6cdf436ba9acf014cf993fa977f3bd"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_normal.png",
+            "source_hash": "b3694920bfe1604317c04b243d619c815a514a15",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/075_bread_base5_converted/textures/texture_normal.png",
+            "target_hash": "dac91a29a63f8a44e4e4934d4122554112bb8dd8"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/Downloads/lettuce/lettuce0/textures/baked_mesh_5085ce69_tex0.png",
+            "source_hash": "c2e9e778b8c337e45fea921b61765191a1565074",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/Downloads/lettuce/lettuce0/textures/baked_mesh_5085ce69_tex0.png",
+            "target_hash": "060aaba36b6ea401a7b84e349b7aa3f5b06f0496"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_0.png",
+            "source_hash": "e63bb28be2e75cdda238600d551a44768b380e89",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_0.png",
+            "target_hash": "f9b31f17e2716836d9f0f9c424cf19396ab6d092"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_1.png",
+            "source_hash": "7b89c29307d0e896031082946f81a21aa98f236a",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_1.png",
+            "target_hash": "6dfdd5617ef8fb4a8443e6973dd4f551e905c193"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_2.png",
+            "source_hash": "11964ff1a364cd7b828223f103906de338899535",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/repos/RoboTwin/assets/objects/usds/003_plate_base0_converted/textures/Image_2.png",
+            "target_hash": "b09605299771defb71b92d1d75d89e43d3d3705a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/Lightwheel_KitchenRoom/Kitchen_Other/texture/T_knifeHolders001_BC.png",
+            "source_hash": "8a7026b5a115d264c4d80ccf7aa3e9de72ca6018",
+            "target_url": "./Downloads/Lightwheel_KitchenRoom/Kitchen_Other/texture/T_knifeHolders001_BC.png",
+            "target_hash": "463c6b080d3eecb10e7ecbfc933ec395d0bc77b3"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-022.JPG",
+            "source_hash": "6f3fc4f1eab72ad0969119368416b05065511c1f",
+            "target_url": "./Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-022.JPG",
+            "target_hash": "e41f606741b90b869bfcf28778b9e9c4cb34dbb6"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-023.JPG",
+            "source_hash": "bda3172b71d6ee7e332432acfbedb5af5d767e9d",
+            "target_url": "./Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-023.JPG",
+            "target_hash": "2287dc5bda6f72dc5a89e93a101996cbe4f045b4"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-024.JPG",
+            "source_hash": "c0e4a90f073a303bf873a34e6bc3c536e0154a68",
+            "target_url": "./Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-024.JPG",
+            "target_hash": "95f8dce1762f734a666e57ceadc2c2f2125e29af"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-025.JPG",
+            "source_hash": "b197c5371a6c081796c5b1f15b1fbdf1406a361a",
+            "target_url": "./Downloads/Lightwheel_KitchenRoom/Kitchen_Other/textures/19913701-files-025.JPG",
+            "target_hash": "bc1ebdbd570936f134413291e60beae88b36f787"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/Downloads/beef/beef0/textures/baked_mesh_4aebee43_tex0.png",
+            "source_hash": "caf6acee443bb0a7751a0c284a8c764bcf751d7f",
+            "target_url": "./scene_sandwich/saved/assets/scene_usds/IROS_scenes_collected/scene_sandwich/Downloads/beef/beef0/textures/baked_mesh_4aebee43_tex0.png",
+            "target_hash": "46a45c7b7f1f06bdedf180d34c07b15fda67fbdb"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/65139b1302ca6000018df43e_color.png",
+            "source_hash": "ae875d6a3f05d9eed3440562ecf5e8c06da49419",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/65139b1302ca6000018df43e_color.png",
+            "target_hash": "b070c10f7b2bca8e1135a4a02d40123c04f43a7f"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/65139b1329931a0001abc2f6_color.png",
+            "source_hash": "b87d41526bc9e16e2d9e456f4de54eda4a9f3ef9",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/65139b1329931a0001abc2f6_color.png",
+            "target_hash": "bce990f83767b232fbf46c88a2eec04230f0e5e2"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/black.png",
+            "source_hash": "3a18adb577d6ccff8b42107dc1e10f19243edc8d",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/black.png",
+            "target_hash": "8d2eed6aa9405b5327a5f8ff660c395be8f6f95b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/normal.png",
+            "source_hash": "be65f222be2ccec2b7fb0ce9ad98a776553d0b45",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/normal.png",
+            "target_hash": "c354b4994f6e27001e9653bbc168c1cd7cbcc6ad"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/white.png",
+            "source_hash": "0d677f1df42bce56877c47e7b7bd8c2b0bea7bea",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Textures/white.png",
+            "target_hash": "8a8bb2dd1362e0d4221c65571638caf9a83773a1"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Num5acb437a3cf8ab2e120078b0.mdl",
+            "source_hash": "b0f2d596df7055c3ac5cf80f6434fc2b1027ae32",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Num5acb437a3cf8ab2e120078b0.mdl",
+            "target_hash": "123944a286e4ad70486393fcb01f2c1d77ba78e5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Function.mdl",
+            "source_hash": "9d303b90a4bd9efe4d5bf95086ad722230a556ef",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Function.mdl",
+            "target_hash": "8d86b4cb6ee1bdff83a92ce95d0229883af1bacf"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_sandwich/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Base.mdl",
+            "source_hash": "b3e9eaec9349cae7d5f6316b658298b461f0b932",
+            "target_url": "./object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Base.mdl",
+            "target_hash": "e09f053f4d3bc78271100a22266ac854ef88e246"
+        }
+    ]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/Downloads/kitchen/Kitchen_KnifeHolders001.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_Kitchen_KnifeHolders001" (
+        prepend payload = @./Kitchen_KnifeHolders001.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/Downloads/kitchen/Kitchen_Shelf001.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_Kitchen_Shelf001" (
+        prepend payload = @./Kitchen_Shelf001.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/Downloads/kitchen/SM_P_Flavour_02.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_SM_P_Flavour_02" (
+        prepend payload = @./SM_P_Flavour_02.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/Num5acb437a3cf8ab2e120078b0.mdl

@@ -0,0 +1,284 @@
+mdl 1.6;
+
+import ::math::*;
+import ::state::*;
+import ::tex::*;
+import ::anno::*;
+using OmniUe4Function import *;
+using OmniUe4Base import *;
+
+export annotation sampler_color();
+export annotation sampler_normal();
+export annotation sampler_grayscale();
+export annotation sampler_alpha();
+export annotation sampler_masks();
+export annotation sampler_distancefield();
+export annotation dither_masked_off();
+export annotation world_space_normal();
+
+export material Num5acb437a3cf8ab2e120078b0(
+	uniform texture_2d Normal_Tex = texture_2d("./Textures/normal.png",::tex::gamma_linear)
+	[[
+		anno::display_name("Normal_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Normal"),
+		sampler_normal()
+	]],
+	float4 Normal_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Normal_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Normal")
+	]],
+	float EmissiveIntensity = 0.0
+	[[
+		anno::display_name("EmissiveIntensity"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsEmissiveTex = 0.0
+	[[
+		anno::display_name("IsEmissiveTex"),
+		anno::in_group("EmissiveColor")
+	]],
+	float4 Emissive_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Emissive_Color"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	uniform texture_2d Emissive_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Emissive_Tex"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor"),
+		sampler_color()
+	]],
+	float4 Emissive_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Emissive_UVA"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsBaseColorTex = 0.0
+	[[
+		anno::display_name("IsBaseColorTex"),
+		anno::in_group("BaseColor")
+	]],
+	float4 BaseColor_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("BaseColor_Color"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	uniform texture_2d BaseColor_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("BaseColor_Tex"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor"),
+		sampler_color()
+	]],
+	float4 BaseColor_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("BaseColor_UVA"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	float IsMetallicTex = 0.0
+	[[
+		anno::display_name("IsMetallicTex"),
+		anno::in_group("Metallic")
+	]],
+	float4 Metallic_Color = float4(0.0,0.0,0.0,1.0)
+	[[
+		anno::display_name("Metallic_Color"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	uniform texture_2d Metallic_Tex = texture_2d("./Textures/black.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Metallic_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Metallic"),
+		sampler_color()
+	]],
+	float4 Metallic_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Metallic_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	float IsSpecularTex = 0.0
+	[[
+		anno::display_name("IsSpecularTex"),
+		anno::in_group("Specular")
+	]],
+	float4 Specular_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Specular_Color"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	uniform texture_2d Specular_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Specular_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Specular"),
+		sampler_color()
+	]],
+	float4 Specular_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Specular_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	float IsGlossTex = 0.0
+	[[
+		anno::display_name("IsGlossTex"),
+		anno::in_group("Roughness")
+	]],
+	float4 Gloss_Color = float4(0.1,0.1,0.1,1.0)
+	[[
+		anno::display_name("Gloss_Color"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	uniform texture_2d Gloss_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Gloss_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Roughness"),
+		sampler_color()
+	]],
+	float4 Gloss_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Gloss_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	float PolygonOffset = 0.0
+	[[
+		anno::display_name("PolygonOffset"),
+		anno::ui_order(32),
+		anno::in_group("WorldPosition")
+	]],
+	int MaxTexCoordIndex = 3
+	[[
+		anno::hidden()
+	]])
+ = 
+	let {
+	float3 Local82 = ::camera_position();
+	float3 Local83 = (Local82 - (::convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), true)*state::meters_per_scene_unit()*100.0));
+	float Local84 = math::dot(Local83, Local83);
+	float Local85 = math::sqrt(Local84);
+	float3 Local86 = (Local83 / Local85);
+	float3 Local87 = (Local86 * PolygonOffset);
+
+	float3 WorldPositionOffset_mdl = Local87;
+	float2 CustomizedUV0_mdl = float2(state::texture_coordinate(math::min(0,MaxTexCoordIndex)).x,1.0-state::texture_coordinate(math::min(0,MaxTexCoordIndex)).y);
+
+	float2 Local0 = (float2(0.5,0.5) * -1.0);
+	float Local1 = (CustomizedUV0_mdl.x * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).x);
+	float Local2 = (CustomizedUV0_mdl.y * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).y);
+	float2 Local3 = (Local0 + float2(Local1,Local2));
+	float Local4 = (3.141592 * -2.0);
+	float Local5 = (float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).z / Local4);
+	float Local6 = (Local5 * 6.283185);
+	float Local7 = math::cos(Local6);
+	float Local8 = math::sin(Local6);
+	float Local9 = (Local8 * -1.0);
+	float Local10 = math::dot(Local3, float2(Local7,Local9));
+	float Local11 = math::dot(Local3, float2(Local8,Local7));
+	float2 Local12 = (float2(0.5,0.5) + float2(Local10,Local11));
+	float4 Local13 = ::unpack_normal_map(tex::lookup_float4(Normal_Tex,float2(Local12.x,1.0-Local12.y),tex::wrap_repeat,tex::wrap_repeat));
+	float3 Local14 = ((math::abs(1.0 - 1.0) > 0.00001) ? (float3(0.0,0.0,0.0)) : float3(Local13.x,Local13.y,Local13.z));
+
+	float3 Normal_mdl = Local14;
+
+	float Local15 = (CustomizedUV0_mdl.x * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).x);
+	float Local16 = (CustomizedUV0_mdl.y * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).y);
+	float2 Local17 = (Local0 + float2(Local15,Local16));
+	float Local18 = (float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).z / Local4);
+	float Local19 = (Local18 * 6.283185);
+	float Local20 = math::cos(Local19);
+	float Local21 = math::sin(Local19);
+	float Local22 = (Local21 * -1.0);
+	float Local23 = math::dot(Local17, float2(Local20,Local22));
+	float Local24 = math::dot(Local17, float2(Local21,Local20));
+	float2 Local25 = (float2(0.5,0.5) + float2(Local23,Local24));
+	float4 Local26 = tex::lookup_float4(Emissive_Tex,float2(Local25.x,1.0-Local25.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local27 = ((math::abs(IsEmissiveTex - 1.0) > 0.00001) ? (float3(Emissive_Color.x,Emissive_Color.y,Emissive_Color.z)) : float3(Local26.x,Local26.y,Local26.z));
+	float3 Local28 = (EmissiveIntensity * Local27);
+	float Local29 = (CustomizedUV0_mdl.x * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).x);
+	float Local30 = (CustomizedUV0_mdl.y * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).y);
+	float2 Local31 = (Local0 + float2(Local29,Local30));
+	float Local32 = (float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).z / Local4);
+	float Local33 = (Local32 * 6.283185);
+	float Local34 = math::cos(Local33);
+	float Local35 = math::sin(Local33);
+	float Local36 = (Local35 * -1.0);
+	float Local37 = math::dot(Local31, float2(Local34,Local36));
+	float Local38 = math::dot(Local31, float2(Local35,Local34));
+	float2 Local39 = (float2(0.5,0.5) + float2(Local37,Local38));
+	float4 Local40 = tex::lookup_float4(BaseColor_Tex,float2(Local39.x,1.0-Local39.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local41 = ((math::abs(IsBaseColorTex - 1.0) > 0.00001) ? (float3(BaseColor_Color.x,BaseColor_Color.y,BaseColor_Color.z)) : float3(Local40.x,Local40.y,Local40.z));
+	float Local42 = (CustomizedUV0_mdl.x * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).x);
+	float Local43 = (CustomizedUV0_mdl.y * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).y);
+	float2 Local44 = (Local0 + float2(Local42,Local43));
+	float Local45 = (float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).z / Local4);
+	float Local46 = (Local45 * 6.283185);
+	float Local47 = math::cos(Local46);
+	float Local48 = math::sin(Local46);
+	float Local49 = (Local48 * -1.0);
+	float Local50 = math::dot(Local44, float2(Local47,Local49));
+	float Local51 = math::dot(Local44, float2(Local48,Local47));
+	float2 Local52 = (float2(0.5,0.5) + float2(Local50,Local51));
+	float4 Local53 = tex::lookup_float4(Metallic_Tex,float2(Local52.x,1.0-Local52.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local54 = ((math::abs(IsMetallicTex - 1.0) > 0.00001) ? (float3(Metallic_Color.x,Metallic_Color.y,Metallic_Color.z)) : float3(Local53.x,Local53.y,Local53.z));
+	float Local55 = (CustomizedUV0_mdl.x * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).x);
+	float Local56 = (CustomizedUV0_mdl.y * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).y);
+	float2 Local57 = (Local0 + float2(Local55,Local56));
+	float Local58 = (float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).z / Local4);
+	float Local59 = (Local58 * 6.283185);
+	float Local60 = math::cos(Local59);
+	float Local61 = math::sin(Local59);
+	float Local62 = (Local61 * -1.0);
+	float Local63 = math::dot(Local57, float2(Local60,Local62));
+	float Local64 = math::dot(Local57, float2(Local61,Local60));
+	float2 Local65 = (float2(0.5,0.5) + float2(Local63,Local64));
+	float4 Local66 = tex::lookup_float4(Specular_Tex,float2(Local65.x,1.0-Local65.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local67 = ((math::abs(IsSpecularTex - 1.0) > 0.00001) ? (float3(Specular_Color.x,Specular_Color.y,Specular_Color.z)) : float3(Local66.x,Local66.y,Local66.z));
+	float Local68 = (CustomizedUV0_mdl.x * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).x);
+	float Local69 = (CustomizedUV0_mdl.y * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).y);
+	float2 Local70 = (Local0 + float2(Local68,Local69));
+	float Local71 = (float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).z / Local4);
+	float Local72 = (Local71 * 6.283185);
+	float Local73 = math::cos(Local72);
+	float Local74 = math::sin(Local72);
+	float Local75 = (Local74 * -1.0);
+	float Local76 = math::dot(Local70, float2(Local73,Local75));
+	float Local77 = math::dot(Local70, float2(Local74,Local73));
+	float2 Local78 = (float2(0.5,0.5) + float2(Local76,Local77));
+	float4 Local79 = tex::lookup_float4(Gloss_Tex,float2(Local78.x,1.0-Local78.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local80 = ((math::abs(IsGlossTex - 1.0) > 0.00001) ? (float3(Gloss_Color.x,Gloss_Color.y,Gloss_Color.z)) : float3(Local79.x,Local79.y,Local79.z));
+	float3 Local81 = (1.0 - Local80);
+
+	float3 EmissiveColor_mdl = Local28;
+	float OpacityMask_mdl = 1.0;
+	float3 BaseColor_mdl = Local41;
+	float Metallic_mdl = Local54.x;
+	float Specular_mdl = Local67.x;
+	float Roughness_mdl = Local81.x;
+
+	} in
+		::OmniUe4Base(
+			base_color: BaseColor_mdl,
+			metallic: Metallic_mdl,
+			roughness: Roughness_mdl,
+			specular: Specular_mdl,
+			normal: Normal_mdl,
+			opacity: OpacityMask_mdl,
+			emissive_color: EmissiveColor_mdl,
+			displacement: WorldPositionOffset_mdl,
+			two_sided: false);

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Base.mdl

@@ -0,0 +1,224 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+ 
+//* 1.0.0 - first version
+//* 1.0.1 - merge unlit template
+//* 1.0.2 - Fix EDF in the back side: the EDF contained in surface is only used for the front side and not for the back side
+//* 1.0.3 - UE4 normal mapping: Geometry normal shouldn't be changed
+//* 1.0.4 - using absolute import paths when importing standard modules
+
+mdl 1.3;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+float emissive_multiplier()
+[[
+    anno::description("the multiplier to convert UE4 emissive to raw data"),
+    anno::noinline()
+]]
+{
+    return 20.0f * 128.0f;
+}
+
+float3 tangent_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in tangent space"),
+    anno::noinline()
+]]
+{
+    return math::normalize(
+        tangent_u * normal.x - /* flip_tangent_v */
+        tangent_v * normal.y +
+        state::normal() * (normal.z));
+}
+
+float3 world_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in world space"),
+    anno::noinline()
+]]
+{
+    return tangent_space_normal(
+        math::normalize(
+        normal.x * float3(tangent_u.x, tangent_v.x, state::normal().x) -
+        normal.y * float3(tangent_u.y, tangent_v.y, state::normal().y) +
+        normal.z * float3(tangent_u.z, tangent_v.z, state::normal().z)),
+        tangent_u,
+        tangent_v
+    );
+}
+
+export material OmniUe4Base(
+   float3 base_color = float3(0.0, 0.0, 0.0),
+   float metallic = 0.0,
+   float roughness = 0.5,
+   float specular = 0.5,
+   float3 normal = float3(0.0,0.0,1.0),
+   float clearcoat_weight = 0.0,
+   float clearcoat_roughness = 0.0,
+   float3 clearcoat_normal = float3(0.0,0.0,1.0),
+   uniform bool enable_opacity = true,
+   float opacity = 1.0,
+   float3 emissive_color = float3(0.0, 0.0, 0.0),
+   float3 displacement = float3(0.0),
+   uniform bool is_tangent_space_normal = true,
+   uniform bool two_sided = false,
+   uniform bool is_unlit = false
+)
+[[
+	anno::display_name("Omni UE4 Base"),
+	anno::description("Omni UE4 Base, supports UE4 default lit and clearcoat shading model"),
+	anno::version( 1, 0, 0),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "UE4", "omniverse", "lit", "clearcoat", "generic"))
+]]
+ = let {     
+   color final_base_color = math::saturate(base_color);
+   float final_metallic = math::saturate(metallic);
+   float final_roughness = math::saturate(roughness);
+   float final_specular = math::saturate(specular);
+   color final_emissive_color = math::max(emissive_color, 0.0f) * emissive_multiplier(); /*factor for converting ue4 emissive to raw value*/
+   float final_clearcoat_weight = math::saturate(clearcoat_weight);
+   float final_clearcoat_roughness = math::saturate(clearcoat_roughness);
+   float3 final_normal = math::normalize(normal);
+   float3 final_clearcoat_normal = math::normalize(clearcoat_normal);
+
+   // - compute final roughness by squaring the "roughness" parameter
+   float alpha = final_roughness * final_roughness;
+   // reduce the reflectivity at grazing angles to avoid "dark edges" for high roughness due to the layering
+   float grazing_refl = math::max((1.0 - final_roughness), 0.0);
+
+	float3 the_normal =  is_unlit ? state::normal() : 
+							(is_tangent_space_normal ? 
+                            tangent_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(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::custom_curve_layer(
+       weight: final_specular,
+       normal_reflectivity: 0.08,
+       grazing_reflectivity: grazing_refl,
+       layer: df::microfacet_ggx_smith_bsdf(roughness_u: alpha),
+       base: df::diffuse_reflection_bsdf(tint: final_base_color),
+       normal: the_normal);
+
+   // the metallic component doesn't have a diffuse component, it's only glossy
+   // base_color is applied to tint it
+   bsdf metallic_component = df::microfacet_ggx_smith_bsdf(tint: final_base_color, roughness_u: alpha);
+
+   // final BSDF is a linear blend between dielectric and metallic component
+   bsdf dielectric_metal_mix =
+       df::normalized_mix(
+           components:
+               df::bsdf_component[](
+                   df::bsdf_component(
+                       component: metallic_component,
+                       weight: final_metallic),
+                   df::bsdf_component(
+                       component: dielectric_component,
+                       weight: 1.0-final_metallic)
+               )
+       );
+
+   // clearcoat layer
+   float clearcoat_grazing_refl = math::max((1.0 - final_clearcoat_roughness), 0.0);
+   float clearcoat_alpha = final_clearcoat_roughness * final_clearcoat_roughness;
+
+   float3 the_clearcoat_normal = is_tangent_space_normal ? tangent_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            );
+
+
+   bsdf clearcoat =
+       df::custom_curve_layer(
+           base: df::weighted_layer(
+               layer: dielectric_metal_mix,
+               weight: 1.0,
+               normal: final_clearcoat_weight == 0.0 ? state::normal() : the_normal
+           ),
+           layer: df::microfacet_ggx_smith_bsdf(
+               roughness_u: clearcoat_alpha,
+               tint: color(1.0)
+           ),
+           normal_reflectivity: 0.04,
+           grazing_reflectivity: clearcoat_grazing_refl,
+           normal: the_clearcoat_normal,
+           weight: final_clearcoat_weight
+       );
+   bsdf surface = is_unlit ? bsdf() : clearcoat;
+} 
+in material(
+   thin_walled: two_sided, // Graphene?
+   surface: material_surface(
+       scattering: surface,
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   backface: material_surface(
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   geometry: material_geometry(
+       displacement: displacement,
+       normal: final_clearcoat_weight == 0.0 ? the_normal : state::normal(),
+       cutout_opacity: enable_opacity ? opacity : 1.0
+   )
+);

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/Materials/OmniUe4Function.mdl

@@ -0,0 +1,1413 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+
+//* 1.0.1 - using absolute import paths when importing standard modules
+
+mdl 1.6;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+
+export float3 convert_to_left_hand(float3 vec3, uniform bool up_z = true, uniform bool is_position = true)
+[[
+    anno::description("convert from RH to LH"),
+	anno::noinline()
+]]
+{
+	float4x4 ZupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4x4 YupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4 vec4 = float4(vec3.x, vec3.y, vec3.z, is_position ? 1.0f : 0.0f);
+
+	vec4 = vec4 * (up_z ? ZupConversion : YupConversion);
+
+	return float3(vec4.x, vec4.y, vec4.z);
+}
+
+export float3 transform_vector_from_tangent_to_world(float3 vector, 
+													uniform bool up_z = true, 
+													float3 tangent_u = state::texture_tangent_u(0),
+    												float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from tangent space to world space"),
+    anno::noinline()
+]]
+{
+	/* flip_tangent_v */
+    return  convert_to_left_hand(
+			tangent_u * vector.x - tangent_v * vector.y + state::normal() * vector.z, 
+			up_z, false);
+}
+
+export float3 transform_vector_from_world_to_tangent(float3 vector, 
+													uniform bool up_z = true,
+													float3 tangent_u = state::texture_tangent_u(0),
+													float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from world space to tangent space"),
+    anno::noinline()
+]]
+{
+	float3 vecRH = convert_to_left_hand(vector, up_z, false);
+	/* flip_tangent_v */
+	return 	vecRH.x * float3(tangent_u.x, -tangent_v.x, state::normal().x) +
+        	vecRH.y * float3(tangent_u.y, -tangent_v.y, state::normal().y) +
+        	vecRH.z * float3(tangent_u.z, -tangent_v.z, state::normal().z);
+}
+
+export float4 unpack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Unpack a normal stored in a normal map"),
+    anno::noinline()
+]]
+{
+    float2 normal_xy = float2(texture_sample.x, texture_sample.y);
+
+	normal_xy = normal_xy * float2(2.0,2.0) - float2(1.0,1.0);
+	float normal_z = math::sqrt( math::saturate( 1.0 - math::dot( normal_xy, normal_xy ) ) );
+	return float4( normal_xy.x, normal_xy.y, normal_z, 1.0 );
+}
+
+// for get color value from normal.
+export float4 pack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Pack to color from a normal")
+]]
+{
+    float2 return_xy = float2(texture_sample.x, texture_sample.y);
+
+	return_xy = (return_xy + float2(1.0,1.0)) / float2(2.0,2.0);
+	
+	return float4( return_xy.x, return_xy.y, 0.0, 1.0 );
+}
+
+export float4 greyscale_texture_lookup(
+    float4 texture_sample = float4(0.0, 0.0, 0.0, 1.0)
+    )
+[[
+    anno::description("Sampling a greyscale texture"),
+    anno::noinline()
+]]
+{
+    return float4(texture_sample.x, texture_sample.x, texture_sample.x, texture_sample.x);
+}     
+
+export float3 pixel_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Pixel normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 vertex_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Vertex normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 landscape_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Landscape normal in world space")
+]]
+{
+	float3 normalFromNormalmap = math::floor((::vertex_normal_world_space(up_z) * 0.5 + 0.5) * 255.0) / 255.0 * 2.0 - 1.0;
+	
+	float2 normalXY = float2(normalFromNormalmap.x, normalFromNormalmap.y);
+	return float3(normalXY.x, normalXY.y, math::sqrt(math::saturate(1.0 - math::dot(normalXY, normalXY))));
+}
+
+// Different implementation specific between mdl and hlsl for smoothstep
+export float smoothstep(float a, float b, float l)
+{
+	if (a < b)
+	{
+		return math::smoothstep(a, b, l);
+	}
+	else if (a > b)
+	{
+		return 1.0 - math::smoothstep(b, a, l);
+	}
+	else
+	{
+		return l <= a ? 0.0 : 1.0;
+	}
+}
+
+export float2 smoothstep(float2 a, float2 b, float2 l)
+{
+	return float2(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y));
+}
+
+export float3 smoothstep(float3 a, float3 b, float3 l)
+{
+	return float3(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z));
+}
+
+export float4 smoothstep(float4 a, float4 b, float4 l)
+{
+	return float4(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z), smoothstep(a.w, b.w, l.w));
+}
+
+export float2 smoothstep(float2 a, float2 b, float l)
+{
+	return float2(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l));
+}
+
+export float3 smoothstep(float3 a, float3 b, float l)
+{
+	return float3(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l));
+}
+
+export float4 smoothstep(float4 a, float4 b, float l)
+{
+	return float4(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l), smoothstep(a.w, b.w, l));
+}
+
+export float2 smoothstep(float a, float b, float2 l)
+{
+	return float2(smoothstep(a, b, l.x), smoothstep(a, b, l.y));
+}
+
+export float3 smoothstep(float a, float b, float3 l)
+{
+	return float3(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z));
+}
+
+export float4 smoothstep(float a, float b, float4 l)
+{
+	return float4(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z), smoothstep(a, b, l.w));
+}
+
+//------------------ Random from UE4 -----------------------
+float length2(float3 v)
+{
+	return math::dot(v, v);
+}
+
+float3 GetPerlinNoiseGradientTextureAt(uniform texture_2d PerlinNoiseGradientTexture, float3 v)
+{
+	const float2 ZShear = float2(17.0f, 89.0f);
+
+	float2 OffsetA = v.z * ZShear;
+	float2 TexA = (float2(v.x, v.y) + OffsetA + 0.5f) / 128.0f;
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA.x,1.0-TexA.y),tex::wrap_repeat,tex::wrap_repeat);
+	return float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z) * 2.0 - 1.0;
+}
+
+float3 SkewSimplex(float3 In)
+{
+	return In + math::dot(In, float3(1.0 / 3.0f) );
+}
+float3 UnSkewSimplex(float3 In)
+{
+	return In - math::dot(In, float3(1.0 / 6.0f) );
+}
+
+// 3D random number generator inspired by PCGs (permuted congruential generator)
+// Using a **simple** Feistel cipher in place of the usual xor shift permutation step
+// @param v = 3D integer coordinate
+// @return three elements w/ 16 random bits each (0-0xffff).
+// ~8 ALU operations for result.x    (7 mad, 1 >>)
+// ~10 ALU operations for result.xy  (8 mad, 2 >>)
+// ~12 ALU operations for result.xyz (9 mad, 3 >>)
+
+//TODO: uint3
+int3 Rand3DPCG16(int3 p)
+{
+	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
+	//TODO: uint3
+	int3 v = int3(p);
+
+	// Linear congruential step. These LCG constants are from Numerical Recipies
+	// For additional #'s, PCG would do multiple LCG steps and scramble each on output
+	// So v here is the RNG state
+	v = v * 1664525 + 1013904223;
+
+	// PCG uses xorshift for the final shuffle, but it is expensive (and cheap
+	// versions of xorshift have visible artifacts). Instead, use simple MAD Feistel steps
+	//
+	// Feistel ciphers divide the state into separate parts (usually by bits)
+	// then apply a series of permutation steps one part at a time. The permutations
+	// use a reversible operation (usually ^) to part being updated with the result of
+	// a permutation function on the other parts and the key.
+	//
+	// In this case, I'm using v.x, v.y and v.z as the parts, using + instead of ^ for
+	// the combination function, and just multiplying the other two parts (no key) for 
+	// the permutation function.
+	//
+	// That gives a simple mad per round.
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+
+	// only top 16 bits are well shuffled
+	return v >> 16;
+}
+
+// Wraps noise for tiling texture creation
+// @param v = unwrapped texture parameter
+// @param bTiling = true to tile, false to not tile
+// @param RepeatSize = number of units before repeating
+// @return either original or wrapped coord
+float3 NoiseTileWrap(float3 v,  bool bTiling, float RepeatSize)
+{
+	return bTiling ? (math::frac(v / RepeatSize) * RepeatSize) : v;
+}
+
+// Evaluate polynomial to get smooth transitions for Perlin noise
+// only needed by Perlin functions in this file
+// scalar(per component): 2 add, 5 mul
+float4 PerlinRamp(float4 t)
+{
+	return t * t * t * (t * (t * 6 - 15) + 10); 
+}
+
+// Blum-Blum-Shub-inspired pseudo random number generator
+// http://www.umbc.edu/~olano/papers/mNoise.pdf
+// real BBS uses ((s*s) mod M) with bignums and M as the product of two huge Blum primes
+// instead, we use a single prime M just small enough not to overflow
+// note that the above paper used 61, which fits in a half, but is unusably bad
+// @param Integer valued floating point seed
+// @return random number in range [0,1)
+// ~8 ALU operations (5 *, 3 frac)
+float RandBBSfloat(float seed)
+{
+	float BBS_PRIME24 = 4093.0;
+	float s = math::frac(seed / BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	return s;
+}
+
+// Modified noise gradient term
+// @param seed - random seed for integer lattice position
+// @param offset - [-1,1] offset of evaluation point from lattice point
+// @return gradient direction (xyz) and contribution (w) from this lattice point
+float4 MGradient(int seed, float3 offset)
+{
+	//TODO uint
+	int rand = Rand3DPCG16(int3(seed,0,0)).x;
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1.0 / 0x4000, 1.0 / 0x2000, 1.0 / 0x1000);
+	float3 direction = float3(int3(rand, rand, rand) & MGradientMask) * MGradientScale - 1;
+	return float4(direction.x, direction.y, direction.z, math::dot(direction, offset));
+}
+
+// compute Perlin and related noise corner seed values
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = true to return seed values for a repeating noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @param seed000-seed111 = hash function seeds for the eight corners
+// @return fractional part of v
+struct SeedValue
+{
+	float3 fv = float3(0);
+	float seed000 = 0;
+	float seed001 = 0;
+	float seed010 = 0;
+	float seed011 = 0;
+	float seed100 = 0;
+	float seed101 = 0;
+	float seed110 = 0;
+	float seed111 = 0;
+};
+
+SeedValue NoiseSeeds(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds;
+	seeds.fv = math::frac(v);
+	float3 iv = math::floor(v);
+
+	const float3 primes = float3(19, 47, 101);
+
+	if (bTiling)
+	{	// can't algebraically combine with primes
+		seeds.seed000 = math::dot(primes, NoiseTileWrap(iv, true, RepeatSize));
+		seeds.seed100 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 0), true, RepeatSize));
+		seeds.seed010 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 0), true, RepeatSize));
+		seeds.seed110 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 0), true, RepeatSize));
+		seeds.seed001 = math::dot(primes, NoiseTileWrap(iv + float3(0, 0, 1), true, RepeatSize));
+		seeds.seed101 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 1), true, RepeatSize));
+		seeds.seed011 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 1), true, RepeatSize));
+		seeds.seed111 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 1), true, RepeatSize));
+	}
+	else
+	{	// get to combine offsets with multiplication by primes in this case
+		seeds.seed000 = math::dot(iv, primes);
+		seeds.seed100 = seeds.seed000 + primes.x;
+		seeds.seed010 = seeds.seed000 + primes.y;
+		seeds.seed110 = seeds.seed100 + primes.y;
+		seeds.seed001 = seeds.seed000 + primes.z;
+		seeds.seed101 = seeds.seed100 + primes.z;
+		seeds.seed011 = seeds.seed010 + primes.z;
+		seeds.seed111 = seeds.seed110 + primes.z;
+	}
+
+	return seeds;
+}
+
+struct SimplexWeights
+{
+	float4 Result = float4(0);
+	float3 PosA = float3(0);
+	float3 PosB = float3(0);
+	float3 PosC = float3(0);
+	float3 PosD = float3(0);
+};
+
+// Computed weights and sample positions for simplex interpolation
+// @return float4(a,b,c, d) Barycentric coordinate defined as Filtered = Tex(PosA) * a + Tex(PosB) * b + Tex(PosC) * c + Tex(PosD) * d
+SimplexWeights ComputeSimplexWeights3D(float3 OrthogonalPos)
+{
+	SimplexWeights weights;
+	float3 OrthogonalPosFloor = math::floor(OrthogonalPos);
+
+	weights.PosA = OrthogonalPosFloor;
+	weights.PosB = weights.PosA + float3(1, 1, 1);
+
+	OrthogonalPos -= OrthogonalPosFloor;
+
+	float Largest = math::max(OrthogonalPos.x, math::max(OrthogonalPos.y, OrthogonalPos.z));
+	float Smallest = math::min(OrthogonalPos.x, math::min(OrthogonalPos.y, OrthogonalPos.z));
+
+	weights.PosC = weights.PosA + float3(Largest == OrthogonalPos.x, Largest == OrthogonalPos.y, Largest == OrthogonalPos.z);
+	weights.PosD = weights.PosA + float3(Smallest != OrthogonalPos.x, Smallest != OrthogonalPos.y, Smallest != OrthogonalPos.z);
+
+	float RG = OrthogonalPos.x - OrthogonalPos.y;
+	float RB = OrthogonalPos.x - OrthogonalPos.z;
+	float GB = OrthogonalPos.y - OrthogonalPos.z;
+
+	weights.Result.z = 
+		  math::min(math::max(0, RG), math::max(0, RB))		// X
+		+ math::min(math::max(0, -RG), math::max(0, GB))		// Y
+		+ math::min(math::max(0, -RB), math::max(0, -GB));	// Z
+	
+	weights.Result.w = 
+		  math::min(math::max(0, -RG), math::max(0, -RB))		// X
+		+ math::min(math::max(0, RG), math::max(0, -GB))		// Y
+		+ math::min(math::max(0, RB), math::max(0, GB));		// Z
+
+	weights.Result.y = Smallest;
+	weights.Result.x = 1.0f - weights.Result.y - weights.Result.z - weights.Result.w;
+
+	return weights;
+}
+
+// filtered 3D gradient simple noise (few texture lookups, high quality)
+// @param v >0
+// @return random number in the range -1 .. 1
+float SimplexNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 EvalPos)
+{
+	float3 OrthogonalPos = SkewSimplex(EvalPos);
+
+	SimplexWeights Weights = ComputeSimplexWeights3D(OrthogonalPos);
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 32 bit)
+	float3 A = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosA);
+	float3 B = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosB);
+	float3 C = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosC);
+	float3 D = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosD);
+	
+	Weights.PosA = UnSkewSimplex(Weights.PosA);
+	Weights.PosB = UnSkewSimplex(Weights.PosB);
+	Weights.PosC = UnSkewSimplex(Weights.PosC);
+	Weights.PosD = UnSkewSimplex(Weights.PosD);
+
+	float DistanceWeight;
+
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosA));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float a = math::dot(A, EvalPos - Weights.PosA) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosB));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float b = math::dot(B, EvalPos - Weights.PosB) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosC));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float c = math::dot(C, EvalPos - Weights.PosC) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosD));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float d = math::dot(D, EvalPos - Weights.PosD) * DistanceWeight;
+
+	return 32 * (a + b + c + d);
+}
+
+// filtered 3D noise, can be optimized
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 v, bool bTiling, float RepeatSize)
+{
+	bTiling = true;
+	float3 fv = math::frac(v);
+	float3 iv0 = NoiseTileWrap(math::floor(v), bTiling, RepeatSize);
+	float3 iv1 = NoiseTileWrap(iv0 + 1, bTiling, RepeatSize);
+
+	const int2 ZShear = int2(17, 89);
+	
+	float2 OffsetA = iv0.z * ZShear;
+	float2 OffsetB = OffsetA + ZShear;	// non-tiling, use relative offset
+	if (bTiling)						// tiling, have to compute from wrapped coordinates
+	{
+		OffsetB = iv1.z * ZShear;
+	}
+
+	// Texture size scale factor
+	float ts = 1 / 128.0f;
+
+	// texture coordinates for iv0.xy, as offset for both z slices
+	float2 TexA0 = (float2(iv0.x, iv0.y) + OffsetA + 0.5f) * ts;
+	float2 TexB0 = (float2(iv0.x, iv0.y) + OffsetB + 0.5f) * ts;
+
+	// texture coordinates for iv1.xy, as offset for both z slices
+	float2 TexA1 = TexA0 + ts;	// for non-tiling, can compute relative to existing coordinates
+	float2 TexB1 = TexB0 + ts;
+	if (bTiling)				// for tiling, need to compute from wrapped coordinates
+	{
+		TexA1 = (float2(iv1.x, iv1.y) + OffsetA + 0.5f) * ts;
+		TexB1 = (float2(iv1.x, iv1.y) + OffsetB + 0.5f) * ts;
+	}
+
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 8, 16 or 32 bit)
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 A = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 B = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 C = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 D = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 E = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 F = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 G = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 H = PerlinNoiseColor * 2 - 1;
+
+	float a = math::dot(A, fv - float3(0, 0, 0));
+	float b = math::dot(B, fv - float3(1, 0, 0));
+	float c = math::dot(C, fv - float3(0, 1, 0));
+	float d = math::dot(D, fv - float3(1, 1, 0));
+	float e = math::dot(E, fv - float3(0, 0, 1));
+	float f = math::dot(F, fv - float3(1, 0, 1));
+	float g = math::dot(G, fv - float3(0, 1, 1));
+	float h = math::dot(H, fv - float3(1, 1, 1));
+
+	float4 Weights = PerlinRamp(math::frac(float4(fv.x, fv.y, fv.z, 0)));
+	
+	float i = math::lerp(math::lerp(a, b, Weights.x), math::lerp(c, d, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(e, f, Weights.x), math::lerp(g, h, Weights.x), Weights.y);
+
+	return math::lerp(i, j, Weights.z);
+}
+
+// @return random number in the range -1 .. 1
+// scalar: 6 frac, 31 mul/mad, 15 add, 
+float FastGradientPerlinNoise3D_TEX(uniform texture_3d PerlinNoise3DTexture, float3 xyz)
+{
+	// needs to be the same value when creating the PerlinNoise3D texture
+	float Extent = 16;
+
+	// last texel replicated and needed for filtering
+	// scalar: 3 frac, 6 mul
+	xyz = math::frac(xyz / (Extent - 1)) * (Extent - 1);
+
+	// scalar: 3 frac
+	float3 uvw = math::frac(xyz);
+	// = floor(xyz);
+	// scalar: 3 add
+	float3 p0 = xyz - uvw;
+//	float3 f = math::pow(uvw, 2) * 3.0f - math::pow(uvw, 3) * 2.0f;	// original perlin hermite (ok when used without bump mapping)
+	// scalar: 2*3 add 5*3 mul
+	float4 pr = PerlinRamp(float4(uvw.x, uvw.y, uvw.z, 0));
+	float3 f = float3(pr.x, pr.y, pr.z);	// new, better with continues second derivative for bump mapping
+	// scalar: 3 add
+	float3 p = p0 + f;
+	// scalar: 3 mad
+	// TODO: need reverse???
+	float4 NoiseSample = tex::lookup_float4(PerlinNoise3DTexture, p / Extent + 0.5f / Extent);	// +0.5f to get rid of bilinear offset
+
+	// reconstruct from 8bit (using mad with 2 constants and dot4 was same instruction count)
+	// scalar: 4 mad, 3 mul, 3 add 
+	float3 n = float3(NoiseSample.x, NoiseSample.y, NoiseSample.z) * 255.0f / 127.0f - 1.0f;
+	float d = NoiseSample.w * 255.f - 127;
+	return math::dot(xyz, n) - d;
+}
+
+// Perlin-style "Modified Noise"
+// http://www.umbc.edu/~olano/papers/index.html#mNoise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = MGradient(int(seeds.seed000), seeds.fv - float3(0, 0, 0)).w;
+	float rand100 = MGradient(int(seeds.seed100), seeds.fv - float3(1, 0, 0)).w;
+	float rand010 = MGradient(int(seeds.seed010), seeds.fv - float3(0, 1, 0)).w;
+	float rand110 = MGradient(int(seeds.seed110), seeds.fv - float3(1, 1, 0)).w;
+	float rand001 = MGradient(int(seeds.seed001), seeds.fv - float3(0, 0, 1)).w;
+	float rand101 = MGradient(int(seeds.seed101), seeds.fv - float3(1, 0, 1)).w;
+	float rand011 = MGradient(int(seeds.seed011), seeds.fv - float3(0, 1, 1)).w;
+	float rand111 = MGradient(int(seeds.seed111), seeds.fv - float3(1, 1, 1)).w;
+
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D value noise - used to be incorrectly called Perlin noise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float ValueNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = RandBBSfloat(seeds.seed000) * 2 - 1;
+	float rand100 = RandBBSfloat(seeds.seed100) * 2 - 1;
+	float rand010 = RandBBSfloat(seeds.seed010) * 2 - 1;
+	float rand110 = RandBBSfloat(seeds.seed110) * 2 - 1;
+	float rand001 = RandBBSfloat(seeds.seed001) * 2 - 1;
+	float rand101 = RandBBSfloat(seeds.seed101) * 2 - 1;
+	float rand011 = RandBBSfloat(seeds.seed011) * 2 - 1;
+	float rand111 = RandBBSfloat(seeds.seed111) * 2 - 1;
+	
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+	
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D jitter offset within a voronoi noise cell
+// @param pos - integer lattice corner
+// @return random offsets vector
+float3 VoronoiCornerSample(float3 pos, int Quality)
+{
+	// random values in [-0.5, 0.5]
+	float3 noise = float3(Rand3DPCG16(int3(pos))) / 0xffff - 0.5;
+
+	// quality level 1 or 2: searches a 2x2x2 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 2x2x2 search
+	if (Quality <= 2)
+	{
+		return math::normalize(noise) * 0.2588;
+	}
+
+	// quality level 3: searches a 3x3x3 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 3x3x3 search
+	if (Quality == 3)
+	{
+		return math::normalize(noise) * 0.3090;
+	}
+
+	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
+	return noise;
+}
+
+// compare previous best with a new candidate
+// not producing point locations makes it easier for compiler to eliminate calculations when they're not needed
+// @param minval = location and distance of best candidate seed point before the new one
+// @param candidate = candidate seed point
+// @param offset = 3D offset to new candidate seed point
+// @param bDistanceOnly = if true, only set maxval.w with distance, otherwise maxval.w is distance and maxval.xyz is position
+// @return position (if bDistanceOnly is false) and distance to closest seed point so far
+float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
+{
+	if (bDistanceOnly)
+	{
+		return float4(0, 0, 0, math::min(minval.w, math::dot(offset, offset)));
+	}
+	else
+	{
+		float newdist = math::dot(offset, offset);
+		return newdist > minval.w ? minval : float4(candidate.x, candidate.y, candidate.z, newdist);
+	}
+}
+
+// 220 instruction Worley noise
+float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
+{
+	float3 fv = math::frac(v),  fv2 = math::frac(v + 0.5);
+	float3 iv = math::floor(v), iv2 = math::floor(v + 0.5);
+
+	// with initial minimum distance = infinity (or at least bigger than 4), first min is optimized away
+	float4 mindist = float4(0,0,0,100);
+	float3 p, offset;
+
+	// quality level 3: do a 3x3x3 search
+	if (Quality == 3)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = -1; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = -1; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = -1; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// everybody else searches a base 2x2x2 neighborhood
+	else
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = 0; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// quality level 2, do extra set of points, offset by half a cell
+					if (Quality == 2)
+					{
+						// 467 is just an offset to a different area in the random number field to avoid similar neighbor artifacts
+						p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize) + 467, Quality);
+						mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+					}
+				}
+			}
+		}
+	}
+
+	// quality level 4: add extra sets of four cells in each direction
+	if (Quality >= 4)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;	
+		for (offset_x = -1; offset_x <= 2; offset_x += 3)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					// along x axis
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along y axis
+					p = float3(offset.y, offset.z, offset.x) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.y, offset.z, offset.x), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along z axis
+					p = float3(offset.z, offset.x, offset.y) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.z, offset.x, offset.y), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// transform squared distance to real distance
+	return float4(mindist.x, mindist.y, mindist.z, math::sqrt(mindist.w));
+}
+
+// Coordinates for corners of a Simplex tetrahedron
+// Based on McEwan et al., Efficient computation of noise in GLSL, JGT 2011
+// @param v = 3D noise argument
+// @return 4 corner locations
+float4x3 SimplexCorners(float3 v)
+{
+	// find base corner by skewing to tetrahedral space and back
+	float3 tet = math::floor(v + v.x/3 + v.y/3 + v.z/3);
+	float3 base = tet - tet.x/6 - tet.y/6 - tet.z/6;
+	float3 f = v - base;
+
+	// Find offsets to other corners (McEwan did this in tetrahedral space,
+	// but since skew is along x=y=z axis, this works in Euclidean space too.)
+	float3 g = math::step(float3(f.y,f.z,f.x), float3(f.x,f.y,f.z)), h = 1 - float3(g.z, g.x, g.y);
+	float3 a1 = math::min(g, h) - 1.0 / 6.0, a2 = math::max(g, h) - 1.0 / 3.0;
+
+	// four corners
+	return float4x3(base, base + a1, base + a2, base + 0.5);
+}
+
+// Improved smoothing function for simplex noise
+// @param f = fractional distance to four tetrahedral corners
+// @return weight for each corner
+float4 SimplexSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	return (1 * scale + s*(-3 * scale + s*(3 * scale - s*scale)));
+}
+
+// Derivative of simplex noise smoothing function
+// @param f = fractional distanc eto four tetrahedral corners
+// @return derivative of smoothing function for each corner by x, y and z
+float3x4 SimplexDSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	s = -12 * scale + s*(24 * scale - s * 12 * scale);
+
+	return float3x4(
+		s * float4(f[0][0], f[1][0], f[2][0], f[3][0]),
+		s * float4(f[0][1], f[1][1], f[2][1], f[3][1]),
+		s * float4(f[0][2], f[1][2], f[2][2], f[3][2]));
+}
+
+// Simplex noise and its Jacobian derivative
+// @param v = 3D noise argument
+// @param bTiling = whether to repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension, must be a multiple of 3
+// @return float3x3 Jacobian in J[*].xyz, vector noise in J[*].w
+//     J[0].w, J[1].w, J[2].w is a Perlin-style simplex noise with vector output, e.g. (Nx, Ny, Nz)
+//     J[i].x is X derivative of the i'th component of the noise so J[2].x is dNz/dx
+// You can use this to compute the noise, gradient, curl, or divergence:
+//   float3x4 J = JacobianSimplex_ALU(...);
+//   float3 VNoise = float3(J[0].w, J[1].w, J[2].w);	// 3D noise
+//   float3 Grad = J[0].xyz;							// gradient of J[0].w
+//   float3 Curl = float3(J[1][2]-J[2][1], J[2][0]-J[0][2], J[0][1]-J[1][2]);
+//   float Div = J[0][0]+J[1][1]+J[2][2];
+// All of these are confirmed to compile out all unneeded terms.
+// So Grad of X doesn't compute Y or Z components, and VNoise doesn't do any of the derivative computation.
+float3x4 JacobianSimplex_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1. / 0x4000, 1. / 0x2000, 1. / 0x1000);
+
+	// corners of tetrahedron
+	float4x3 T = SimplexCorners(v);
+	// TODO: uint3
+	int3 rand = int3(0);
+	float4x3 gvec0 = float4x3(1.0);
+	float4x3 gvec1 = float4x3(1.0);
+	float4x3 gvec2 = float4x3(1.0);
+	float4x3 fv = float4x3(1.0);
+	float3x4 grad = float3x4(1.0);
+
+	// processing of tetrahedral vertices, unrolled
+	// to compute gradient at each corner
+	fv[0] = v - T[0];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[0] + 0.5, bTiling, RepeatSize))));
+	gvec0[0] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[0] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[0] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][0] = math::dot(gvec0[0], fv[0]);
+	grad[1][0] = math::dot(gvec1[0], fv[0]);
+	grad[2][0] = math::dot(gvec2[0], fv[0]);
+
+	fv[1] = v - T[1];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[1] + 0.5, bTiling, RepeatSize))));
+	gvec0[1] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][1] = math::dot(gvec0[1], fv[1]);
+	grad[1][1] = math::dot(gvec1[1], fv[1]);
+	grad[2][1] = math::dot(gvec2[1], fv[1]);
+
+	fv[2] = v - T[2];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[2] + 0.5, bTiling, RepeatSize))));
+	gvec0[2] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[2] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[2] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][2] = math::dot(gvec0[2], fv[2]);
+	grad[1][2] = math::dot(gvec1[2], fv[2]);
+	grad[2][2] = math::dot(gvec2[2], fv[2]);
+
+	fv[3] = v - T[3];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[3] + 0.5, bTiling, RepeatSize))));
+	gvec0[3] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[3] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[3] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][3] = math::dot(gvec0[3], fv[3]);
+	grad[1][3] = math::dot(gvec1[3], fv[3]);
+	grad[2][3] = math::dot(gvec2[3], fv[3]);
+
+	// blend gradients
+	float4 sv = SimplexSmooth(fv);
+	float3x4 ds = SimplexDSmooth(fv);
+
+	float3x4 jacobian = float3x4(1.0);
+	float3 vec0 = gvec0*sv + grad[0]*ds; // NOTE: mdl is column major, convert from UE4 (row major)
+	jacobian[0] = float4(vec0.x, vec0.y, vec0.z, math::dot(sv, grad[0]));
+	float3 vec1 = gvec1*sv + grad[1]*ds;
+	jacobian[1] = float4(vec1.x, vec1.y, vec1.z, math::dot(sv, grad[1]));
+	float3 vec2 = gvec2*sv + grad[2]*ds;
+	jacobian[2] = float4(vec2.x, vec2.y, vec2.z, math::dot(sv, grad[2]));
+
+	return jacobian;
+}
+
+// While RepeatSize is a float here, the expectation is that it would be largely integer values coming in from the UI. The downstream logic assumes
+// floats for all called functions (NoiseTileWrap) and this prevents any float-to-int conversion errors from automatic type conversion.
+float Noise3D_Multiplexer(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, int Function, float3 Position, int Quality, bool bTiling, float RepeatSize)
+{
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch(Function)
+	{
+		case 0:
+			return SimplexNoise3D_TEX(PerlinNoiseGradientTexture, Position);
+		case 1:
+			return GradientNoise3D_TEX(PerlinNoiseGradientTexture, Position, bTiling, RepeatSize);
+		case 2:
+			return FastGradientPerlinNoise3D_TEX(PerlinNoise3DTexture, Position);
+		case 3:
+			return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 4:
+			return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 5:
+			return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2.0 - 1.0;
+	}
+	return 0;
+}
+//----------------------------------------------------------
+
+export float noise(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, float3 Position, float Scale, float Quality, float Function, float Turbulence, float Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, float Tiling, float RepeatSize)
+[[
+    anno::description("Noise"),
+    anno::noinline()
+]]
+{
+	Position *= Scale;
+	FilterWidth *= Scale;
+
+	float Out = 0.0f;
+	float OutScale = 1.0f;
+	float InvLevelScale = 1.0f / LevelScale;
+	
+	int iFunction(Function);
+	int iQuality(Quality);
+	int iLevels(Levels);
+	bool bTurbulence(Turbulence);
+	bool bTiling(Tiling);
+	
+	for(int i = 0; i < iLevels; ++i)
+	{
+		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
+		OutScale *= math::saturate(1.0 - FilterWidth);
+
+		if(bTurbulence)
+		{
+			Out += math::abs(Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize)) * OutScale;
+		}
+		else
+		{
+			Out += Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize) * OutScale;
+		}
+
+		Position *= LevelScale;
+		RepeatSize *= LevelScale;
+		OutScale *= InvLevelScale;
+		FilterWidth *= LevelScale;
+	}
+
+	if(!bTurbulence)
+	{
+		// bring -1..1 to 0..1 range
+		Out = Out * 0.5f + 0.5f;
+	}
+
+	// Out is in 0..1 range
+	return math::lerp(OutputMin, OutputMax, Out);
+}
+
+// Material node for noise functions returning a vector value
+// @param LevelScale usually 2 but higher values allow efficient use of few levels
+// @return in user defined range (OutputMin..OutputMax)
+export float4 vector4_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise"),
+    anno::noinline()
+]]
+{
+	float4 result = float4(0,0,0,1);
+	float3 ret = float3(0);
+	int iQuality = int(Quality);
+	int iFunction = int(Function);
+	bool bTiling = Tiling > 0.0;
+	
+	float3x4 Jacobian = JacobianSimplex_ALU(Position, bTiling, TileSize);	// compiled out if not used
+
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch (iFunction)
+	{
+	case 0:	// Cellnoise
+		ret = float3(Rand3DPCG16(int3(math::floor(NoiseTileWrap(Position, bTiling, TileSize))))) / 0xffff;
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 1: // Color noise
+		ret = float3(Jacobian[0].w, Jacobian[1].w, Jacobian[2].w);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 2: // Gradient
+		result = Jacobian[0];
+		break;
+	case 3: // Curl
+		ret = float3(Jacobian[2][1] - Jacobian[1][2], Jacobian[0][2] - Jacobian[2][0], Jacobian[1][0] - Jacobian[0][1]);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 4: // Voronoi
+		result = VoronoiNoise3D_ALU(Position, iQuality, bTiling, TileSize, false);
+		break;
+	}
+	return result;
+}
+
+export float3 vector3_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise float3 version"),
+    anno::noinline()
+]]
+{
+	float4 noise = vector4_noise(Position, Quality, Function, Tiling, TileSize);
+	return float3(noise.x, noise.y, noise.z);
+}
+
+
+// workaround for ue4 fresnel (without supporting for camera vector) : replacing it with 0.0, means facing to the view
+export float fresnel(float exponent [[anno::unused()]], float base_reflect_fraction [[anno::unused()]], float3 normal [[anno::unused()]])
+[[
+    anno::description("Fresnel"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float fresnel_function(float3 normal_vector [[anno::unused()]], float3 camera_vector [[anno::unused()]], 
+                                bool invert_fresnel [[anno::unused()]], float power [[anno::unused()]], 
+                                bool use_cheap_contrast [[anno::unused()]], float cheap_contrast_dark [[anno::unused()]], float cheap_contrast_bright [[anno::unused()]], 
+                                bool clamp_fresnel_dot_product [[anno::unused()]])
+[[
+    anno::description("Fresnel Function"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float3 camera_vector(uniform bool up_z = true)
+[[
+    anno::description("Camera Vector"),
+    anno::noinline()
+]]
+{
+	// assume camera postion is 0,0,0
+	return math::normalize(float3(0) - convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z));
+}
+
+export float pixel_depth()
+[[
+    anno::description("Pixel Depth"),
+    anno::noinline()
+]]
+{
+	return 256.0f;
+}
+
+export float scene_depth()
+[[
+    anno::description("Scene Depth")
+]]
+{
+	return 65500.0f;
+}
+
+export float3 scene_color()
+[[
+    anno::description("Scene Color")
+]]
+{
+	return float3(1.0f);
+}
+
+export float4 vertex_color()
+[[
+    anno::description("Vertex Color"),
+    anno::noinline()
+]]
+{
+	return float4(1.0f);
+}
+
+export float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
+[[
+    anno::description("Vertex Color for float2 PrimVar"),
+    anno::noinline()
+]]
+{
+	// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
+	return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
+}
+
+export float3 camera_position()
+[[
+    anno::description("Camera Position"),
+    anno::noinline()
+]]
+{
+	return float3(1000.0f, 0, 0);
+}
+
+export float3 rotate_about_axis(float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position)
+[[
+    anno::description("Rotates Position about the given axis by the given angle")
+]]
+{
+	// Project Position onto the rotation axis and find the closest point on the axis to Position
+	float3 NormalizedRotationAxis = float3(NormalizedRotationAxisAndAngle.x,NormalizedRotationAxisAndAngle.y,NormalizedRotationAxisAndAngle.z);
+	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxis * math::dot(NormalizedRotationAxis, Position - PositionOnAxis);
+	// Construct orthogonal axes in the plane of the rotation
+	float3 UAxis = Position - ClosestPointOnAxis;
+	float3 VAxis = math::cross(NormalizedRotationAxis, UAxis);
+	float[2] SinCosAngle = math::sincos(NormalizedRotationAxisAndAngle.w);
+	// Rotate using the orthogonal axes
+	float3 R = UAxis * SinCosAngle[1] + VAxis * SinCosAngle[0];
+	// Reconstruct the rotated world space position
+	float3 RotatedPosition = ClosestPointOnAxis + R;
+	// Convert from position to a position offset
+	return RotatedPosition - Position;
+}
+
+export float2 rotate_scale_offset_texcoords(float2 InTexCoords, float4 InRotationScale, float2 InOffset)
+[[
+    anno::description("Returns a float2 texture coordinate after 2x2 transform and offset applied")
+]]
+{
+	return float2(math::dot(InTexCoords, float2(InRotationScale.x, InRotationScale.y)), math::dot(InTexCoords, float2(InRotationScale.z, InRotationScale.w))) + InOffset;
+}
+
+export float3 reflection_custom_world_normal(float3 WorldNormal, bool bNormalizeInputNormal, uniform bool up_z = true)
+[[
+    anno::description("Reflection vector about the specified world space normal")
+]]
+{
+	if (bNormalizeInputNormal)
+	{
+		WorldNormal = math::normalize(WorldNormal);
+	}
+
+	return -camera_vector(up_z) + WorldNormal * math::dot(WorldNormal, camera_vector(up_z)) * 2.0;
+}
+
+export float3 reflection_vector(uniform bool up_z = true)
+[[
+    anno::description("Reflection Vector"),
+    anno::noinline()
+]]
+{
+    float3 normal = convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+	return reflection_custom_world_normal(normal, false, up_z);
+}
+
+export float dither_temporalAA(float AlphaThreshold = 0.5f, float Random = 1.0f [[anno::unused()]])
+[[
+    anno::description("Dither TemporalAA"),
+    anno::noinline()
+]]
+{
+	return AlphaThreshold;
+}
+
+export float3 black_body( float Temp )
+[[
+    anno::description("Black Body"),
+	anno::noinline()
+]]
+{
+	float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
+	float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
+
+	float x = 3*u / ( 2*u - 8*v + 4 );
+	float y = 2*v / ( 2*u - 8*v + 4 );
+	float z = 1 - x - y;
+
+	float Y = 1;
+	float X = Y/y * x;
+	float Z = Y/y * z;
+
+	float3x3 XYZtoRGB = float3x3(
+		float3(3.2404542, -1.5371385, -0.4985314),
+		float3(-0.9692660,  1.8760108,  0.0415560),
+		float3(0.0556434, -0.2040259,  1.0572252)
+	);
+
+	return XYZtoRGB * float3( X, Y, Z ) * math::pow( 0.0004 * Temp, 4 );
+}
+
+export float per_instance_random(uniform texture_2d PerlinNoiseGradientTexture, int NumberInstances)
+[[
+    anno::description("Per Instance Random"),
+	anno::noinline()
+]]
+{
+	float weight = state::object_id() / float(NumberInstances);	
+	return NumberInstances == 0 ? 0.0 : tex::lookup_float4(PerlinNoiseGradientTexture, float2(weight, 1.0 - weight), tex::wrap_repeat, tex::wrap_repeat).x;
+}
+
+//------------------ Hair from UE4 -----------------------
+float3 hair_absorption_to_color(float3 A)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::exp(-math::sqrt(A) * D);
+}
+
+float3 hair_color_to_absorption(float3 C)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::pow(math::log(C) / D, 2.0f);
+}
+
+export float3 get_hair_color_from_melanin(float InMelanin, float InRedness, float3 InDyeColor)
+[[
+    anno::description("Hair Color")
+]]
+{
+	InMelanin = math::saturate(InMelanin);
+	InRedness = math::saturate(InRedness);
+	float Melanin		= -math::log(math::max(1 - InMelanin, 0.0001f));
+	float Eumelanin 	= Melanin * (1 - InRedness);
+	float Pheomelanin = Melanin * InRedness;
+
+	float3 DyeAbsorption = hair_color_to_absorption(math::saturate(InDyeColor));
+	float3 Absorption = Eumelanin * float3(0.506f, 0.841f, 1.653f) + Pheomelanin * float3(0.343f, 0.733f, 1.924f);
+
+	return hair_absorption_to_color(Absorption + DyeAbsorption);
+}
+
+export float3 local_object_bounds_min()
+[[
+    anno::description("Local Object Bounds Min"),
+	anno::noinline()
+]]
+{
+	return float3(0.0);
+}
+
+export float3 local_object_bounds_max()
+[[
+    anno::description("Local Object Bounds Max"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float3 object_bounds()
+[[
+    anno::description("Object Bounds"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float object_radius()
+[[
+    anno::description("Object Radius"),
+	anno::noinline()
+]]
+{
+	return 100.0f;
+}
+
+export float3 object_world_position(uniform bool up_z = true)
+[[
+    anno::description("Object World Position"),
+	anno::noinline()
+]]
+{
+	return convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z)*state::meters_per_scene_unit()*100.0;
+}
+
+export float3 object_orientation()
+[[
+    anno::description("Object Orientation"),
+	anno::noinline()
+]]
+{
+	return float3(0);
+}
+
+export float rcp(float x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float2 rcp(float2 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float3 rcp(float3 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float4 rcp(float4 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export int BitFieldExtractI32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractI32 int"),
+	anno::noinline()
+]]
+{
+	Size &= 3;
+	Offset &= 3;
+
+	if (Size == 0)
+		return 0;
+	else if (Offset + Size < 32)
+		return (Data << (32 - Size - Offset)) >> (32 - Size);
+	else
+		return Data >> Offset;
+}
+
+export int BitFieldExtractI32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractI32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(int(Data), int(Size), int(Offset));
+}
+
+export int BitFieldExtractU32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractU32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export int BitFieldExtractU32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractU32 int"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export float3 EyeAdaptationInverseLookup(float3 LightValue, float Alpha)
+[[
+    anno::description("EyeAdaptationInverseLookup"),
+	anno::noinline()
+]]
+{
+	float Adaptation = 1.0f;
+
+	// When Alpha=0.0, we want to multiply by 1.0. when Alpha = 1.0, we want to multiply by 1/Adaptation.
+	// So the lerped value is:
+	//     LerpLogScale = Lerp(log(1),log(1/Adaptaiton),T)
+	// Which is simplified as:
+	//     LerpLogScale = Lerp(0,-log(Adaptation),T)
+	//     LerpLogScale = -T * logAdaptation;
+
+	float LerpLogScale = -Alpha * math::log(Adaptation);
+	float Scale = math::exp(LerpLogScale);
+	return LightValue * Scale;
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/object_usds/grutopia_usd/Table/table/ae45ecafe08effd3f62b54a1d360d593/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_sandwich/base/scene_sandwich/obj_board4.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_obj_board4" (
+        prepend payload = @./obj_board4.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/.collect.mapping.json

@@ -0,0 +1,275 @@
+{
+    "version": "1.0",
+    "file_records": [
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/base.usd",
+            "source_hash": "7a332908c9cd0bee9924ac73afb176cfd8af9632",
+            "target_url": "./base.usd",
+            "target_hash": "62b762c83e4958b56d2faf971680fe4e553e4bd7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/Downloads/brown_photostudio_02_4k.exr",
+            "source_hash": "b6beb1413814503087cf87594235ea6d8624621f",
+            "target_url": "./Downloads/brown_photostudio_02_4k.exr",
+            "target_hash": "21c42fc9c23392065b43580029be4e3e444b7a2e"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/instance.usd",
+            "source_hash": "a72fdc3469b8d75e7f3dce65285087bc0611049b",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/instance.usd",
+            "target_hash": "b11ff7c45085bd6570f5ea9b32014edebd908726"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/2b70993763034bef8587d3730c7ca8ff.usd",
+            "source_hash": "cc2f3a6cb1940abcc512cf8003e27fbec5683a1b",
+            "target_url": "./object_usds/objaverse_usd/2b70993763034bef8587d3730c7ca8ff.usd",
+            "target_hash": "ffad339f1c4a34ee69ebc0f098638a638a63f998"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/2cda50e73f69438598eabf8259e27cb7.usd",
+            "source_hash": "7942cc5c5799149211b9a5e9393a9677ffae20dc",
+            "target_url": "./object_usds/objaverse_usd/2cda50e73f69438598eabf8259e27cb7.usd",
+            "target_hash": "2ff82f70f9a74467240aba5da7979f9634140529"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/30f8ba058e1f4e288f5a2ddcba924c3f.usd",
+            "source_hash": "11580d38824335c13f406f835c55b69ace9a8ac9",
+            "target_url": "./object_usds/objaverse_usd/30f8ba058e1f4e288f5a2ddcba924c3f.usd",
+            "target_hash": "1496254464868acdb827879c8ab63fcd07809f73"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/cf2af4b2b8c6420da69ba8d8f73744bc.usd",
+            "source_hash": "d3cf379358c42897640671bf09bc11290f753d72",
+            "target_url": "./object_usds/objaverse_usd/cf2af4b2b8c6420da69ba8d8f73744bc.usd",
+            "target_hash": "ffb92a5e1f08bbd714898c994adb2f2d3e1139aa"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/scene_waste/obj_badbin.usd",
+            "source_hash": "dd9a8f71ecdc3389c406d40dffd77721b70e67f3",
+            "target_url": "./scene_waste/obj_badbin.usd",
+            "target_hash": "4721c64d8fc2009928becf9a937ac1b1dbc2a693"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/scene_waste/obj_goodbin.usd",
+            "source_hash": "4b55dd5fb96f9a14535bd3b86339ad66da9fd5b9",
+            "target_url": "./scene_waste/obj_goodbin.usd",
+            "target_hash": "8867e96ff7dfed5155af4f5011d358319f976947"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_BaseColor.png",
+            "source_hash": "9142f6b0574e735dd7472db86d9415d26b77382f",
+            "target_url": "./scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_BaseColor.png",
+            "target_hash": "56128b05813fda7cc0a1cbb250a0d5869cf56335"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_Metallic-DefaultMaterial_Roughness.png",
+            "source_hash": "251dcdf77555aeb1342c0dd7c254573c674af261",
+            "target_url": "./scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_Metallic-DefaultMaterial_Roughness.png",
+            "target_hash": "dc2b82e8aa83c09a8ddf54d297c47f3b8427b03a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_Normal.png",
+            "source_hash": "d09eedfcc66c6350f987d3a1e17b2a0665941acf",
+            "target_url": "./scene_waste/saved/assets/scene_usds/IROS_scenes_collected/scene_waste/repos/RoboTwin/assets/objects/usds/011_dustbin_base0_converted/textures/DefaultMaterial_Normal.png",
+            "target_hash": "256a691588e5efe87cd0c395ee727e67e247a18a"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture0.png",
+            "source_hash": "f4ea8e62644037e3c8c863807d18f1bbd53bf626",
+            "target_url": "./object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture0.png",
+            "target_hash": "f6c6c86e52948f18b27c5b2e658b19db26c3e902"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture1.png",
+            "source_hash": "1b0fb3c4ebfa6377875fe8b880ef2f7cf2de856e",
+            "target_url": "./object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture1.png",
+            "target_hash": "eceaf131cb9face836bf406b347ecc883328f12b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture2.png",
+            "source_hash": "1e9d35292cde1b943e2a7f9f777f7e8e9a8574a3",
+            "target_url": "./object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture2.png",
+            "target_hash": "31a21c508774e78acd4d8d09b730cd0f35042235"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture3.png",
+            "source_hash": "f6fef6f8517a2fe0ca6089321f01869f205cab36",
+            "target_url": "./object_usds/objaverse_usd/textures/2b70993763034bef8587d3730c7ca8ff_texture3.png",
+            "target_hash": "601fe3a99115074f5552ca6f7f245654e3ac0658"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60090c4ad849e10001fbaec3_color.png",
+            "source_hash": "a0d31d0b429d9bfe91c5a4449be945d84442b098",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60090c4ad849e10001fbaec3_color.png",
+            "target_hash": "75af4a24f59446d69bf28e846b644cba7ce86970"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60090c4ad849e10001fbaec3_metallic.png",
+            "source_hash": "854c76e7a509daa225f93de5b22ae7e4c0e0af64",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60090c4ad849e10001fbaec3_metallic.png",
+            "target_hash": "e9851b4a5bb7913b6b61029e5bc40691096bb248"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60f102a500e3a30001d518c5_color.png",
+            "source_hash": "3fc5f322590d5c8b6496f473baf3d0c4715b8d78",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/60f102a500e3a30001d518c5_color.png",
+            "target_hash": "05ca929437cee4f5d96c3ba229125609d1824edb"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/black.png",
+            "source_hash": "231bf4246d70f903fcb3eac63d53ebe011425bac",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/black.png",
+            "target_hash": "748c791bd642fc3fd67af23c1d55c97a5da46f47"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/normal.png",
+            "source_hash": "4b3df3caa24a0172e2aca13a2f3d73a8624d8f71",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/normal.png",
+            "target_hash": "03549b0537dc966a5e0386f75f88784bbf3fb8a6"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/white.png",
+            "source_hash": "190f2242a3184409ef609954e7a2a8e407fc2792",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Textures/white.png",
+            "target_hash": "74ceb4127b6e5182c2a1422e4b43eef5caae69af"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/30f8ba058e1f4e288f5a2ddcba924c3f_texture0.jpg",
+            "source_hash": "c48d63450b02d8587352e3062836105454aab124",
+            "target_url": "./object_usds/objaverse_usd/textures/30f8ba058e1f4e288f5a2ddcba924c3f_texture0.jpg",
+            "target_hash": "a4f040c528742c13f12e44b65587c8b761aafc0d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture0.jpg",
+            "source_hash": "b7a0405c1296ab924c01623cf02b8bd12612076e",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture0.jpg",
+            "target_hash": "fba9dbc5f440891769ffd1f151f8282ae121181e"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture1.jpg",
+            "source_hash": "fb2111621b3f9850a6958f676c15192a6fd0fef1",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture1.jpg",
+            "target_hash": "76c86a63699385a574aae439d8c123ce927eeeb5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture10.png",
+            "source_hash": "e0c30ced981f61b6049eb93d71fb13ac6e8c0f49",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture10.png",
+            "target_hash": "8b828d42a2e885e218759a638ebccc1ea2221c24"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture11.png",
+            "source_hash": "02ac152c426689a3e4de9ba677a1c88d29ba3e28",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture11.png",
+            "target_hash": "8cd88abb5d1274ad16f73cb39045092484cdf226"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture12.jpg",
+            "source_hash": "f797c61ac0689558c679bd5ad6a7b0eb9f577369",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture12.jpg",
+            "target_hash": "060b47f4ec8922f6bf6790d92ead817af92bc933"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture13.jpg",
+            "source_hash": "4bedf4b64e03e9ff84b9a4a1c3913454b2b3a660",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture13.jpg",
+            "target_hash": "7b380184e026a687377115d79d5ace9fa6f5abf7"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture14.png",
+            "source_hash": "31123acf1546928b72d76d4bb9a8c3de745b1b91",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture14.png",
+            "target_hash": "3c6c8661ecaf3b021480ae7b00da457dd3c9ec68"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture15.jpg",
+            "source_hash": "f52dd0696a1dd267d7141ad586704b721308ab9b",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture15.jpg",
+            "target_hash": "9281acf2e816a1a7fefd75fea61535cc6dd31fc6"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture16.jpg",
+            "source_hash": "1485c1b492af2eb4380e290ee18973ae65483e11",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture16.jpg",
+            "target_hash": "ff23589d659f4c9f856e44ac9d2fe81aa379c83e"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture17.png",
+            "source_hash": "1bd6fc7d046166161e76cd4421854d0ff415f84d",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture17.png",
+            "target_hash": "030a1b222793ae7685bbdcc7b945903554243df5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture18.png",
+            "source_hash": "40256d4eb6bc1ff96307a058fed182a4f13f1c1f",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture18.png",
+            "target_hash": "8422394c5bc6b869722d52955fc1bc4a25f212f1"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture2.png",
+            "source_hash": "a46e27a59f5c5308458552431fd4920b15d90fe3",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture2.png",
+            "target_hash": "ec4bd8f0c8eccde4a087f271270d4c5c723bee0f"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture3.jpg",
+            "source_hash": "dda26652b8fa561932c4411638d1fa6a7a4a5640",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture3.jpg",
+            "target_hash": "7cf9130bfb5b08c3dc9f5617cd7ce497e470577f"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture4.jpg",
+            "source_hash": "effb8f7a42aaf5409460019aa7f1ee37d63cbfba",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture4.jpg",
+            "target_hash": "334e8356562679091b8ea9d414e6a870bb81f92b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture5.png",
+            "source_hash": "7855029a782ed6607158d14693c68d5354b964da",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture5.png",
+            "target_hash": "8391c032fffb18891dbd8fab5767688a25b3baf9"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture6.jpg",
+            "source_hash": "c1df213ba25e1c760e6702a69a9fc0c7c442a317",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture6.jpg",
+            "target_hash": "f0389822aab350c19bab43fdd5df8a19a293133b"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture7.png",
+            "source_hash": "e18595e1efdb691388619b0694ad502275e6b8f9",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture7.png",
+            "target_hash": "49df6a29705d44f57108a879721fd48ee9c518e0"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture8.jpg",
+            "source_hash": "8065c3fc96e47977751f8bf318fcf95130f34765",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture8.jpg",
+            "target_hash": "c0eaa72383802a4cb430f202bd7a29d3a98291c4"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture9.jpg",
+            "source_hash": "788d268a6010a5a028a5d3c6fe4cb5ba1ca8043a",
+            "target_url": "./object_usds/objaverse_usd/textures/cf2af4b2b8c6420da69ba8d8f73744bc_texture9.jpg",
+            "target_hash": "0fb261d468d380ef75cb4028b097d2e2ab54db3d"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Num595f215bc6dce910dd2f0f2d.mdl",
+            "source_hash": "ef56b768a9d22f65b7becab33e54a5123e65ce25",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Num595f215bc6dce910dd2f0f2d.mdl",
+            "target_hash": "849a901aa294b0038ef4d2c10f92624521340dcd"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Function.mdl",
+            "source_hash": "3422f8ac624e6429ea98461f3de3b06c401425bf",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Function.mdl",
+            "target_hash": "01dedfdad6e3fd0cc0f8279eb4ca2e981dd374d5"
+        },
+        {
+            "source_url": "/mnt/data/gaoning/GenManip-Sim/saved/assets/scene_usds/IROS_scenes_aloha_final/scene_waste/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Base.mdl",
+            "source_hash": "002961ad702659c84ae1e35062ecc8a77b702b37",
+            "target_url": "./object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Base.mdl",
+            "target_hash": "0ac8a615892446336f7b6a8cac6a50c9d9dd6e28"
+        }
+    ]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/Num595f215bc6dce910dd2f0f2d.mdl

@@ -0,0 +1,284 @@
+mdl 1.6;
+
+import ::math::*;
+import ::state::*;
+import ::tex::*;
+import ::anno::*;
+using OmniUe4Function import *;
+using OmniUe4Base import *;
+
+export annotation sampler_color();
+export annotation sampler_normal();
+export annotation sampler_grayscale();
+export annotation sampler_alpha();
+export annotation sampler_masks();
+export annotation sampler_distancefield();
+export annotation dither_masked_off();
+export annotation world_space_normal();
+
+export material Num595f215bc6dce910dd2f0f2d(
+	uniform texture_2d Normal_Tex = texture_2d("./Textures/normal.png",::tex::gamma_linear)
+	[[
+		anno::display_name("Normal_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Normal"),
+		sampler_normal()
+	]],
+	float4 Normal_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Normal_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Normal")
+	]],
+	float EmissiveIntensity = 0.0
+	[[
+		anno::display_name("EmissiveIntensity"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsEmissiveTex = 0.0
+	[[
+		anno::display_name("IsEmissiveTex"),
+		anno::in_group("EmissiveColor")
+	]],
+	float4 Emissive_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Emissive_Color"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	uniform texture_2d Emissive_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Emissive_Tex"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor"),
+		sampler_color()
+	]],
+	float4 Emissive_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Emissive_UVA"),
+		anno::ui_order(32),
+		anno::in_group("EmissiveColor")
+	]],
+	float IsBaseColorTex = 0.0
+	[[
+		anno::display_name("IsBaseColorTex"),
+		anno::in_group("BaseColor")
+	]],
+	float4 BaseColor_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("BaseColor_Color"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	uniform texture_2d BaseColor_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("BaseColor_Tex"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor"),
+		sampler_color()
+	]],
+	float4 BaseColor_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("BaseColor_UVA"),
+		anno::ui_order(32),
+		anno::in_group("BaseColor")
+	]],
+	float IsMetallicTex = 0.0
+	[[
+		anno::display_name("IsMetallicTex"),
+		anno::in_group("Metallic")
+	]],
+	float4 Metallic_Color = float4(0.0,0.0,0.0,1.0)
+	[[
+		anno::display_name("Metallic_Color"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	uniform texture_2d Metallic_Tex = texture_2d("./Textures/black.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Metallic_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Metallic"),
+		sampler_color()
+	]],
+	float4 Metallic_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Metallic_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Metallic")
+	]],
+	float IsSpecularTex = 0.0
+	[[
+		anno::display_name("IsSpecularTex"),
+		anno::in_group("Specular")
+	]],
+	float4 Specular_Color = float4(1.0,1.0,1.0,1.0)
+	[[
+		anno::display_name("Specular_Color"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	uniform texture_2d Specular_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Specular_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Specular"),
+		sampler_color()
+	]],
+	float4 Specular_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Specular_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Specular")
+	]],
+	float IsGlossTex = 0.0
+	[[
+		anno::display_name("IsGlossTex"),
+		anno::in_group("Roughness")
+	]],
+	float4 Gloss_Color = float4(0.1,0.1,0.1,1.0)
+	[[
+		anno::display_name("Gloss_Color"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	uniform texture_2d Gloss_Tex = texture_2d("./Textures/white.png",::tex::gamma_srgb)
+	[[
+		anno::display_name("Gloss_Tex"),
+		anno::ui_order(32),
+		anno::in_group("Roughness"),
+		sampler_color()
+	]],
+	float4 Gloss_UVA = float4(1.0,1.0,0.0,0.0)
+	[[
+		anno::display_name("Gloss_UVA"),
+		anno::ui_order(32),
+		anno::in_group("Roughness")
+	]],
+	float PolygonOffset = 0.0
+	[[
+		anno::display_name("PolygonOffset"),
+		anno::ui_order(32),
+		anno::in_group("WorldPosition")
+	]],
+	int MaxTexCoordIndex = 3
+	[[
+		anno::hidden()
+	]])
+ = 
+	let {
+	float3 Local82 = ::camera_position();
+	float3 Local83 = (Local82 - (::convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), true)*state::meters_per_scene_unit()*100.0));
+	float Local84 = math::dot(Local83, Local83);
+	float Local85 = math::sqrt(Local84);
+	float3 Local86 = (Local83 / Local85);
+	float3 Local87 = (Local86 * PolygonOffset);
+
+	float3 WorldPositionOffset_mdl = Local87;
+	float2 CustomizedUV0_mdl = float2(state::texture_coordinate(math::min(0,MaxTexCoordIndex)).x,1.0-state::texture_coordinate(math::min(0,MaxTexCoordIndex)).y);
+
+	float2 Local0 = (float2(0.5,0.5) * -1.0);
+	float Local1 = (CustomizedUV0_mdl.x * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).x);
+	float Local2 = (CustomizedUV0_mdl.y * float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).y);
+	float2 Local3 = (Local0 + float2(Local1,Local2));
+	float Local4 = (3.141592 * -2.0);
+	float Local5 = (float3(Normal_UVA.x,Normal_UVA.y,Normal_UVA.z).z / Local4);
+	float Local6 = (Local5 * 6.283185);
+	float Local7 = math::cos(Local6);
+	float Local8 = math::sin(Local6);
+	float Local9 = (Local8 * -1.0);
+	float Local10 = math::dot(Local3, float2(Local7,Local9));
+	float Local11 = math::dot(Local3, float2(Local8,Local7));
+	float2 Local12 = (float2(0.5,0.5) + float2(Local10,Local11));
+	float4 Local13 = ::unpack_normal_map(tex::lookup_float4(Normal_Tex,float2(Local12.x,1.0-Local12.y),tex::wrap_repeat,tex::wrap_repeat));
+	float3 Local14 = ((math::abs(1.0 - 1.0) > 0.00001) ? (float3(0.0,0.0,0.0)) : float3(Local13.x,Local13.y,Local13.z));
+
+	float3 Normal_mdl = Local14;
+
+	float Local15 = (CustomizedUV0_mdl.x * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).x);
+	float Local16 = (CustomizedUV0_mdl.y * float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).y);
+	float2 Local17 = (Local0 + float2(Local15,Local16));
+	float Local18 = (float3(Emissive_UVA.x,Emissive_UVA.y,Emissive_UVA.z).z / Local4);
+	float Local19 = (Local18 * 6.283185);
+	float Local20 = math::cos(Local19);
+	float Local21 = math::sin(Local19);
+	float Local22 = (Local21 * -1.0);
+	float Local23 = math::dot(Local17, float2(Local20,Local22));
+	float Local24 = math::dot(Local17, float2(Local21,Local20));
+	float2 Local25 = (float2(0.5,0.5) + float2(Local23,Local24));
+	float4 Local26 = tex::lookup_float4(Emissive_Tex,float2(Local25.x,1.0-Local25.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local27 = ((math::abs(IsEmissiveTex - 1.0) > 0.00001) ? (float3(Emissive_Color.x,Emissive_Color.y,Emissive_Color.z)) : float3(Local26.x,Local26.y,Local26.z));
+	float3 Local28 = (EmissiveIntensity * Local27);
+	float Local29 = (CustomizedUV0_mdl.x * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).x);
+	float Local30 = (CustomizedUV0_mdl.y * float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).y);
+	float2 Local31 = (Local0 + float2(Local29,Local30));
+	float Local32 = (float3(BaseColor_UVA.x,BaseColor_UVA.y,BaseColor_UVA.z).z / Local4);
+	float Local33 = (Local32 * 6.283185);
+	float Local34 = math::cos(Local33);
+	float Local35 = math::sin(Local33);
+	float Local36 = (Local35 * -1.0);
+	float Local37 = math::dot(Local31, float2(Local34,Local36));
+	float Local38 = math::dot(Local31, float2(Local35,Local34));
+	float2 Local39 = (float2(0.5,0.5) + float2(Local37,Local38));
+	float4 Local40 = tex::lookup_float4(BaseColor_Tex,float2(Local39.x,1.0-Local39.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local41 = ((math::abs(IsBaseColorTex - 1.0) > 0.00001) ? (float3(BaseColor_Color.x,BaseColor_Color.y,BaseColor_Color.z)) : float3(Local40.x,Local40.y,Local40.z));
+	float Local42 = (CustomizedUV0_mdl.x * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).x);
+	float Local43 = (CustomizedUV0_mdl.y * float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).y);
+	float2 Local44 = (Local0 + float2(Local42,Local43));
+	float Local45 = (float3(Metallic_UVA.x,Metallic_UVA.y,Metallic_UVA.z).z / Local4);
+	float Local46 = (Local45 * 6.283185);
+	float Local47 = math::cos(Local46);
+	float Local48 = math::sin(Local46);
+	float Local49 = (Local48 * -1.0);
+	float Local50 = math::dot(Local44, float2(Local47,Local49));
+	float Local51 = math::dot(Local44, float2(Local48,Local47));
+	float2 Local52 = (float2(0.5,0.5) + float2(Local50,Local51));
+	float4 Local53 = tex::lookup_float4(Metallic_Tex,float2(Local52.x,1.0-Local52.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local54 = ((math::abs(IsMetallicTex - 1.0) > 0.00001) ? (float3(Metallic_Color.x,Metallic_Color.y,Metallic_Color.z)) : float3(Local53.x,Local53.y,Local53.z));
+	float Local55 = (CustomizedUV0_mdl.x * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).x);
+	float Local56 = (CustomizedUV0_mdl.y * float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).y);
+	float2 Local57 = (Local0 + float2(Local55,Local56));
+	float Local58 = (float3(Specular_UVA.x,Specular_UVA.y,Specular_UVA.z).z / Local4);
+	float Local59 = (Local58 * 6.283185);
+	float Local60 = math::cos(Local59);
+	float Local61 = math::sin(Local59);
+	float Local62 = (Local61 * -1.0);
+	float Local63 = math::dot(Local57, float2(Local60,Local62));
+	float Local64 = math::dot(Local57, float2(Local61,Local60));
+	float2 Local65 = (float2(0.5,0.5) + float2(Local63,Local64));
+	float4 Local66 = tex::lookup_float4(Specular_Tex,float2(Local65.x,1.0-Local65.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local67 = ((math::abs(IsSpecularTex - 1.0) > 0.00001) ? (float3(Specular_Color.x,Specular_Color.y,Specular_Color.z)) : float3(Local66.x,Local66.y,Local66.z));
+	float Local68 = (CustomizedUV0_mdl.x * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).x);
+	float Local69 = (CustomizedUV0_mdl.y * float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).y);
+	float2 Local70 = (Local0 + float2(Local68,Local69));
+	float Local71 = (float3(Gloss_UVA.x,Gloss_UVA.y,Gloss_UVA.z).z / Local4);
+	float Local72 = (Local71 * 6.283185);
+	float Local73 = math::cos(Local72);
+	float Local74 = math::sin(Local72);
+	float Local75 = (Local74 * -1.0);
+	float Local76 = math::dot(Local70, float2(Local73,Local75));
+	float Local77 = math::dot(Local70, float2(Local74,Local73));
+	float2 Local78 = (float2(0.5,0.5) + float2(Local76,Local77));
+	float4 Local79 = tex::lookup_float4(Gloss_Tex,float2(Local78.x,1.0-Local78.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 Local80 = ((math::abs(IsGlossTex - 1.0) > 0.00001) ? (float3(Gloss_Color.x,Gloss_Color.y,Gloss_Color.z)) : float3(Local79.x,Local79.y,Local79.z));
+	float3 Local81 = (1.0 - Local80);
+
+	float3 EmissiveColor_mdl = Local28;
+	float OpacityMask_mdl = 1.0;
+	float3 BaseColor_mdl = Local41;
+	float Metallic_mdl = Local54.x;
+	float Specular_mdl = Local67.x;
+	float Roughness_mdl = Local81.x;
+
+	} in
+		::OmniUe4Base(
+			base_color: BaseColor_mdl,
+			metallic: Metallic_mdl,
+			roughness: Roughness_mdl,
+			specular: Specular_mdl,
+			normal: Normal_mdl,
+			opacity: OpacityMask_mdl,
+			emissive_color: EmissiveColor_mdl,
+			displacement: WorldPositionOffset_mdl,
+			two_sided: false);

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Base.mdl

@@ -0,0 +1,224 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+ 
+//* 1.0.0 - first version
+//* 1.0.1 - merge unlit template
+//* 1.0.2 - Fix EDF in the back side: the EDF contained in surface is only used for the front side and not for the back side
+//* 1.0.3 - UE4 normal mapping: Geometry normal shouldn't be changed
+//* 1.0.4 - using absolute import paths when importing standard modules
+
+mdl 1.3;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+float emissive_multiplier()
+[[
+    anno::description("the multiplier to convert UE4 emissive to raw data"),
+    anno::noinline()
+]]
+{
+    return 20.0f * 128.0f;
+}
+
+float3 tangent_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in tangent space"),
+    anno::noinline()
+]]
+{
+    return math::normalize(
+        tangent_u * normal.x - /* flip_tangent_v */
+        tangent_v * normal.y +
+        state::normal() * (normal.z));
+}
+
+float3 world_space_normal(
+    float3 normal = float3(0.0,0.0,1.0),
+    float3 tangent_u = state::texture_tangent_u(0),
+    float3 tangent_v = state::texture_tangent_v(0)
+)
+[[
+    anno::description("Interprets the vector in world space"),
+    anno::noinline()
+]]
+{
+    return tangent_space_normal(
+        math::normalize(
+        normal.x * float3(tangent_u.x, tangent_v.x, state::normal().x) -
+        normal.y * float3(tangent_u.y, tangent_v.y, state::normal().y) +
+        normal.z * float3(tangent_u.z, tangent_v.z, state::normal().z)),
+        tangent_u,
+        tangent_v
+    );
+}
+
+export material OmniUe4Base(
+   float3 base_color = float3(0.0, 0.0, 0.0),
+   float metallic = 0.0,
+   float roughness = 0.5,
+   float specular = 0.5,
+   float3 normal = float3(0.0,0.0,1.0),
+   float clearcoat_weight = 0.0,
+   float clearcoat_roughness = 0.0,
+   float3 clearcoat_normal = float3(0.0,0.0,1.0),
+   uniform bool enable_opacity = true,
+   float opacity = 1.0,
+   float3 emissive_color = float3(0.0, 0.0, 0.0),
+   float3 displacement = float3(0.0),
+   uniform bool is_tangent_space_normal = true,
+   uniform bool two_sided = false,
+   uniform bool is_unlit = false
+)
+[[
+	anno::display_name("Omni UE4 Base"),
+	anno::description("Omni UE4 Base, supports UE4 default lit and clearcoat shading model"),
+	anno::version( 1, 0, 0),
+	anno::author("NVIDIA CORPORATION"), 
+	anno::key_words(string[]("omni", "UE4", "omniverse", "lit", "clearcoat", "generic"))
+]]
+ = let {     
+   color final_base_color = math::saturate(base_color);
+   float final_metallic = math::saturate(metallic);
+   float final_roughness = math::saturate(roughness);
+   float final_specular = math::saturate(specular);
+   color final_emissive_color = math::max(emissive_color, 0.0f) * emissive_multiplier(); /*factor for converting ue4 emissive to raw value*/
+   float final_clearcoat_weight = math::saturate(clearcoat_weight);
+   float final_clearcoat_roughness = math::saturate(clearcoat_roughness);
+   float3 final_normal = math::normalize(normal);
+   float3 final_clearcoat_normal = math::normalize(clearcoat_normal);
+
+   // - compute final roughness by squaring the "roughness" parameter
+   float alpha = final_roughness * final_roughness;
+   // reduce the reflectivity at grazing angles to avoid "dark edges" for high roughness due to the layering
+   float grazing_refl = math::max((1.0 - final_roughness), 0.0);
+
+	float3 the_normal =  is_unlit ? state::normal() : 
+							(is_tangent_space_normal ? 
+                            tangent_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(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::custom_curve_layer(
+       weight: final_specular,
+       normal_reflectivity: 0.08,
+       grazing_reflectivity: grazing_refl,
+       layer: df::microfacet_ggx_smith_bsdf(roughness_u: alpha),
+       base: df::diffuse_reflection_bsdf(tint: final_base_color),
+       normal: the_normal);
+
+   // the metallic component doesn't have a diffuse component, it's only glossy
+   // base_color is applied to tint it
+   bsdf metallic_component = df::microfacet_ggx_smith_bsdf(tint: final_base_color, roughness_u: alpha);
+
+   // final BSDF is a linear blend between dielectric and metallic component
+   bsdf dielectric_metal_mix =
+       df::normalized_mix(
+           components:
+               df::bsdf_component[](
+                   df::bsdf_component(
+                       component: metallic_component,
+                       weight: final_metallic),
+                   df::bsdf_component(
+                       component: dielectric_component,
+                       weight: 1.0-final_metallic)
+               )
+       );
+
+   // clearcoat layer
+   float clearcoat_grazing_refl = math::max((1.0 - final_clearcoat_roughness), 0.0);
+   float clearcoat_alpha = final_clearcoat_roughness * final_clearcoat_roughness;
+
+   float3 the_clearcoat_normal = is_tangent_space_normal ? tangent_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            ) : world_space_normal(
+                                            normal:         final_clearcoat_normal,
+                                            tangent_u:      state::texture_tangent_u(0),
+                                            tangent_v:      state::texture_tangent_v(0)
+                            );
+
+
+   bsdf clearcoat =
+       df::custom_curve_layer(
+           base: df::weighted_layer(
+               layer: dielectric_metal_mix,
+               weight: 1.0,
+               normal: final_clearcoat_weight == 0.0 ? state::normal() : the_normal
+           ),
+           layer: df::microfacet_ggx_smith_bsdf(
+               roughness_u: clearcoat_alpha,
+               tint: color(1.0)
+           ),
+           normal_reflectivity: 0.04,
+           grazing_reflectivity: clearcoat_grazing_refl,
+           normal: the_clearcoat_normal,
+           weight: final_clearcoat_weight
+       );
+   bsdf surface = is_unlit ? bsdf() : clearcoat;
+} 
+in material(
+   thin_walled: two_sided, // Graphene?
+   surface: material_surface(
+       scattering: surface,
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   backface: material_surface(
+       emission:
+            material_emission (
+                emission:  df::diffuse_edf (),
+                intensity: final_emissive_color
+                )
+       ),
+   geometry: material_geometry(
+       displacement: displacement,
+       normal: final_clearcoat_weight == 0.0 ? the_normal : state::normal(),
+       cutout_opacity: enable_opacity ? opacity : 1.0
+   )
+);

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/Materials/OmniUe4Function.mdl

@@ -0,0 +1,1413 @@
+/***************************************************************************************************
+ * Copyright 2020 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************************/
+
+//* 1.0.1 - using absolute import paths when importing standard modules
+
+mdl 1.6;
+
+import ::df::*;
+import ::state::*;
+import ::math::*;
+import ::tex::*;
+import ::anno::*;
+
+
+export float3 convert_to_left_hand(float3 vec3, uniform bool up_z = true, uniform bool is_position = true)
+[[
+    anno::description("convert from RH to LH"),
+	anno::noinline()
+]]
+{
+	float4x4 ZupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, -1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4x4 YupConversion = float4x4(
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f,
+		0.0f, 1.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 1.0f
+	);
+
+	float4 vec4 = float4(vec3.x, vec3.y, vec3.z, is_position ? 1.0f : 0.0f);
+
+	vec4 = vec4 * (up_z ? ZupConversion : YupConversion);
+
+	return float3(vec4.x, vec4.y, vec4.z);
+}
+
+export float3 transform_vector_from_tangent_to_world(float3 vector, 
+													uniform bool up_z = true, 
+													float3 tangent_u = state::texture_tangent_u(0),
+    												float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from tangent space to world space"),
+    anno::noinline()
+]]
+{
+	/* flip_tangent_v */
+    return  convert_to_left_hand(
+			tangent_u * vector.x - tangent_v * vector.y + state::normal() * vector.z, 
+			up_z, false);
+}
+
+export float3 transform_vector_from_world_to_tangent(float3 vector, 
+													uniform bool up_z = true,
+													float3 tangent_u = state::texture_tangent_u(0),
+													float3 tangent_v = state::texture_tangent_v(0))
+[[
+    anno::description("Transform vector from world space to tangent space"),
+    anno::noinline()
+]]
+{
+	float3 vecRH = convert_to_left_hand(vector, up_z, false);
+	/* flip_tangent_v */
+	return 	vecRH.x * float3(tangent_u.x, -tangent_v.x, state::normal().x) +
+        	vecRH.y * float3(tangent_u.y, -tangent_v.y, state::normal().y) +
+        	vecRH.z * float3(tangent_u.z, -tangent_v.z, state::normal().z);
+}
+
+export float4 unpack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Unpack a normal stored in a normal map"),
+    anno::noinline()
+]]
+{
+    float2 normal_xy = float2(texture_sample.x, texture_sample.y);
+
+	normal_xy = normal_xy * float2(2.0,2.0) - float2(1.0,1.0);
+	float normal_z = math::sqrt( math::saturate( 1.0 - math::dot( normal_xy, normal_xy ) ) );
+	return float4( normal_xy.x, normal_xy.y, normal_z, 1.0 );
+}
+
+// for get color value from normal.
+export float4 pack_normal_map(
+    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
+    )
+[[
+    anno::description("Pack to color from a normal")
+]]
+{
+    float2 return_xy = float2(texture_sample.x, texture_sample.y);
+
+	return_xy = (return_xy + float2(1.0,1.0)) / float2(2.0,2.0);
+	
+	return float4( return_xy.x, return_xy.y, 0.0, 1.0 );
+}
+
+export float4 greyscale_texture_lookup(
+    float4 texture_sample = float4(0.0, 0.0, 0.0, 1.0)
+    )
+[[
+    anno::description("Sampling a greyscale texture"),
+    anno::noinline()
+]]
+{
+    return float4(texture_sample.x, texture_sample.x, texture_sample.x, texture_sample.x);
+}     
+
+export float3 pixel_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Pixel normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 vertex_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Vertex normal in world space"),
+    anno::noinline()
+]]
+{
+    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+}
+
+export float3 landscape_normal_world_space(uniform bool up_z = true)
+[[
+    anno::description("Landscape normal in world space")
+]]
+{
+	float3 normalFromNormalmap = math::floor((::vertex_normal_world_space(up_z) * 0.5 + 0.5) * 255.0) / 255.0 * 2.0 - 1.0;
+	
+	float2 normalXY = float2(normalFromNormalmap.x, normalFromNormalmap.y);
+	return float3(normalXY.x, normalXY.y, math::sqrt(math::saturate(1.0 - math::dot(normalXY, normalXY))));
+}
+
+// Different implementation specific between mdl and hlsl for smoothstep
+export float smoothstep(float a, float b, float l)
+{
+	if (a < b)
+	{
+		return math::smoothstep(a, b, l);
+	}
+	else if (a > b)
+	{
+		return 1.0 - math::smoothstep(b, a, l);
+	}
+	else
+	{
+		return l <= a ? 0.0 : 1.0;
+	}
+}
+
+export float2 smoothstep(float2 a, float2 b, float2 l)
+{
+	return float2(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y));
+}
+
+export float3 smoothstep(float3 a, float3 b, float3 l)
+{
+	return float3(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z));
+}
+
+export float4 smoothstep(float4 a, float4 b, float4 l)
+{
+	return float4(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z), smoothstep(a.w, b.w, l.w));
+}
+
+export float2 smoothstep(float2 a, float2 b, float l)
+{
+	return float2(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l));
+}
+
+export float3 smoothstep(float3 a, float3 b, float l)
+{
+	return float3(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l));
+}
+
+export float4 smoothstep(float4 a, float4 b, float l)
+{
+	return float4(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l), smoothstep(a.w, b.w, l));
+}
+
+export float2 smoothstep(float a, float b, float2 l)
+{
+	return float2(smoothstep(a, b, l.x), smoothstep(a, b, l.y));
+}
+
+export float3 smoothstep(float a, float b, float3 l)
+{
+	return float3(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z));
+}
+
+export float4 smoothstep(float a, float b, float4 l)
+{
+	return float4(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z), smoothstep(a, b, l.w));
+}
+
+//------------------ Random from UE4 -----------------------
+float length2(float3 v)
+{
+	return math::dot(v, v);
+}
+
+float3 GetPerlinNoiseGradientTextureAt(uniform texture_2d PerlinNoiseGradientTexture, float3 v)
+{
+	const float2 ZShear = float2(17.0f, 89.0f);
+
+	float2 OffsetA = v.z * ZShear;
+	float2 TexA = (float2(v.x, v.y) + OffsetA + 0.5f) / 128.0f;
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA.x,1.0-TexA.y),tex::wrap_repeat,tex::wrap_repeat);
+	return float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z) * 2.0 - 1.0;
+}
+
+float3 SkewSimplex(float3 In)
+{
+	return In + math::dot(In, float3(1.0 / 3.0f) );
+}
+float3 UnSkewSimplex(float3 In)
+{
+	return In - math::dot(In, float3(1.0 / 6.0f) );
+}
+
+// 3D random number generator inspired by PCGs (permuted congruential generator)
+// Using a **simple** Feistel cipher in place of the usual xor shift permutation step
+// @param v = 3D integer coordinate
+// @return three elements w/ 16 random bits each (0-0xffff).
+// ~8 ALU operations for result.x    (7 mad, 1 >>)
+// ~10 ALU operations for result.xy  (8 mad, 2 >>)
+// ~12 ALU operations for result.xyz (9 mad, 3 >>)
+
+//TODO: uint3
+int3 Rand3DPCG16(int3 p)
+{
+	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
+	//TODO: uint3
+	int3 v = int3(p);
+
+	// Linear congruential step. These LCG constants are from Numerical Recipies
+	// For additional #'s, PCG would do multiple LCG steps and scramble each on output
+	// So v here is the RNG state
+	v = v * 1664525 + 1013904223;
+
+	// PCG uses xorshift for the final shuffle, but it is expensive (and cheap
+	// versions of xorshift have visible artifacts). Instead, use simple MAD Feistel steps
+	//
+	// Feistel ciphers divide the state into separate parts (usually by bits)
+	// then apply a series of permutation steps one part at a time. The permutations
+	// use a reversible operation (usually ^) to part being updated with the result of
+	// a permutation function on the other parts and the key.
+	//
+	// In this case, I'm using v.x, v.y and v.z as the parts, using + instead of ^ for
+	// the combination function, and just multiplying the other two parts (no key) for 
+	// the permutation function.
+	//
+	// That gives a simple mad per round.
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+	v.x += v.y*v.z;
+	v.y += v.z*v.x;
+	v.z += v.x*v.y;
+
+	// only top 16 bits are well shuffled
+	return v >> 16;
+}
+
+// Wraps noise for tiling texture creation
+// @param v = unwrapped texture parameter
+// @param bTiling = true to tile, false to not tile
+// @param RepeatSize = number of units before repeating
+// @return either original or wrapped coord
+float3 NoiseTileWrap(float3 v,  bool bTiling, float RepeatSize)
+{
+	return bTiling ? (math::frac(v / RepeatSize) * RepeatSize) : v;
+}
+
+// Evaluate polynomial to get smooth transitions for Perlin noise
+// only needed by Perlin functions in this file
+// scalar(per component): 2 add, 5 mul
+float4 PerlinRamp(float4 t)
+{
+	return t * t * t * (t * (t * 6 - 15) + 10); 
+}
+
+// Blum-Blum-Shub-inspired pseudo random number generator
+// http://www.umbc.edu/~olano/papers/mNoise.pdf
+// real BBS uses ((s*s) mod M) with bignums and M as the product of two huge Blum primes
+// instead, we use a single prime M just small enough not to overflow
+// note that the above paper used 61, which fits in a half, but is unusably bad
+// @param Integer valued floating point seed
+// @return random number in range [0,1)
+// ~8 ALU operations (5 *, 3 frac)
+float RandBBSfloat(float seed)
+{
+	float BBS_PRIME24 = 4093.0;
+	float s = math::frac(seed / BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	s = math::frac(s * s * BBS_PRIME24);
+	return s;
+}
+
+// Modified noise gradient term
+// @param seed - random seed for integer lattice position
+// @param offset - [-1,1] offset of evaluation point from lattice point
+// @return gradient direction (xyz) and contribution (w) from this lattice point
+float4 MGradient(int seed, float3 offset)
+{
+	//TODO uint
+	int rand = Rand3DPCG16(int3(seed,0,0)).x;
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1.0 / 0x4000, 1.0 / 0x2000, 1.0 / 0x1000);
+	float3 direction = float3(int3(rand, rand, rand) & MGradientMask) * MGradientScale - 1;
+	return float4(direction.x, direction.y, direction.z, math::dot(direction, offset));
+}
+
+// compute Perlin and related noise corner seed values
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = true to return seed values for a repeating noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @param seed000-seed111 = hash function seeds for the eight corners
+// @return fractional part of v
+struct SeedValue
+{
+	float3 fv = float3(0);
+	float seed000 = 0;
+	float seed001 = 0;
+	float seed010 = 0;
+	float seed011 = 0;
+	float seed100 = 0;
+	float seed101 = 0;
+	float seed110 = 0;
+	float seed111 = 0;
+};
+
+SeedValue NoiseSeeds(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds;
+	seeds.fv = math::frac(v);
+	float3 iv = math::floor(v);
+
+	const float3 primes = float3(19, 47, 101);
+
+	if (bTiling)
+	{	// can't algebraically combine with primes
+		seeds.seed000 = math::dot(primes, NoiseTileWrap(iv, true, RepeatSize));
+		seeds.seed100 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 0), true, RepeatSize));
+		seeds.seed010 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 0), true, RepeatSize));
+		seeds.seed110 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 0), true, RepeatSize));
+		seeds.seed001 = math::dot(primes, NoiseTileWrap(iv + float3(0, 0, 1), true, RepeatSize));
+		seeds.seed101 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 1), true, RepeatSize));
+		seeds.seed011 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 1), true, RepeatSize));
+		seeds.seed111 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 1), true, RepeatSize));
+	}
+	else
+	{	// get to combine offsets with multiplication by primes in this case
+		seeds.seed000 = math::dot(iv, primes);
+		seeds.seed100 = seeds.seed000 + primes.x;
+		seeds.seed010 = seeds.seed000 + primes.y;
+		seeds.seed110 = seeds.seed100 + primes.y;
+		seeds.seed001 = seeds.seed000 + primes.z;
+		seeds.seed101 = seeds.seed100 + primes.z;
+		seeds.seed011 = seeds.seed010 + primes.z;
+		seeds.seed111 = seeds.seed110 + primes.z;
+	}
+
+	return seeds;
+}
+
+struct SimplexWeights
+{
+	float4 Result = float4(0);
+	float3 PosA = float3(0);
+	float3 PosB = float3(0);
+	float3 PosC = float3(0);
+	float3 PosD = float3(0);
+};
+
+// Computed weights and sample positions for simplex interpolation
+// @return float4(a,b,c, d) Barycentric coordinate defined as Filtered = Tex(PosA) * a + Tex(PosB) * b + Tex(PosC) * c + Tex(PosD) * d
+SimplexWeights ComputeSimplexWeights3D(float3 OrthogonalPos)
+{
+	SimplexWeights weights;
+	float3 OrthogonalPosFloor = math::floor(OrthogonalPos);
+
+	weights.PosA = OrthogonalPosFloor;
+	weights.PosB = weights.PosA + float3(1, 1, 1);
+
+	OrthogonalPos -= OrthogonalPosFloor;
+
+	float Largest = math::max(OrthogonalPos.x, math::max(OrthogonalPos.y, OrthogonalPos.z));
+	float Smallest = math::min(OrthogonalPos.x, math::min(OrthogonalPos.y, OrthogonalPos.z));
+
+	weights.PosC = weights.PosA + float3(Largest == OrthogonalPos.x, Largest == OrthogonalPos.y, Largest == OrthogonalPos.z);
+	weights.PosD = weights.PosA + float3(Smallest != OrthogonalPos.x, Smallest != OrthogonalPos.y, Smallest != OrthogonalPos.z);
+
+	float RG = OrthogonalPos.x - OrthogonalPos.y;
+	float RB = OrthogonalPos.x - OrthogonalPos.z;
+	float GB = OrthogonalPos.y - OrthogonalPos.z;
+
+	weights.Result.z = 
+		  math::min(math::max(0, RG), math::max(0, RB))		// X
+		+ math::min(math::max(0, -RG), math::max(0, GB))		// Y
+		+ math::min(math::max(0, -RB), math::max(0, -GB));	// Z
+	
+	weights.Result.w = 
+		  math::min(math::max(0, -RG), math::max(0, -RB))		// X
+		+ math::min(math::max(0, RG), math::max(0, -GB))		// Y
+		+ math::min(math::max(0, RB), math::max(0, GB));		// Z
+
+	weights.Result.y = Smallest;
+	weights.Result.x = 1.0f - weights.Result.y - weights.Result.z - weights.Result.w;
+
+	return weights;
+}
+
+// filtered 3D gradient simple noise (few texture lookups, high quality)
+// @param v >0
+// @return random number in the range -1 .. 1
+float SimplexNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 EvalPos)
+{
+	float3 OrthogonalPos = SkewSimplex(EvalPos);
+
+	SimplexWeights Weights = ComputeSimplexWeights3D(OrthogonalPos);
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 32 bit)
+	float3 A = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosA);
+	float3 B = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosB);
+	float3 C = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosC);
+	float3 D = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosD);
+	
+	Weights.PosA = UnSkewSimplex(Weights.PosA);
+	Weights.PosB = UnSkewSimplex(Weights.PosB);
+	Weights.PosC = UnSkewSimplex(Weights.PosC);
+	Weights.PosD = UnSkewSimplex(Weights.PosD);
+
+	float DistanceWeight;
+
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosA));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float a = math::dot(A, EvalPos - Weights.PosA) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosB));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float b = math::dot(B, EvalPos - Weights.PosB) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosC));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float c = math::dot(C, EvalPos - Weights.PosC) * DistanceWeight;
+	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosD));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
+	float d = math::dot(D, EvalPos - Weights.PosD) * DistanceWeight;
+
+	return 32 * (a + b + c + d);
+}
+
+// filtered 3D noise, can be optimized
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 v, bool bTiling, float RepeatSize)
+{
+	bTiling = true;
+	float3 fv = math::frac(v);
+	float3 iv0 = NoiseTileWrap(math::floor(v), bTiling, RepeatSize);
+	float3 iv1 = NoiseTileWrap(iv0 + 1, bTiling, RepeatSize);
+
+	const int2 ZShear = int2(17, 89);
+	
+	float2 OffsetA = iv0.z * ZShear;
+	float2 OffsetB = OffsetA + ZShear;	// non-tiling, use relative offset
+	if (bTiling)						// tiling, have to compute from wrapped coordinates
+	{
+		OffsetB = iv1.z * ZShear;
+	}
+
+	// Texture size scale factor
+	float ts = 1 / 128.0f;
+
+	// texture coordinates for iv0.xy, as offset for both z slices
+	float2 TexA0 = (float2(iv0.x, iv0.y) + OffsetA + 0.5f) * ts;
+	float2 TexB0 = (float2(iv0.x, iv0.y) + OffsetB + 0.5f) * ts;
+
+	// texture coordinates for iv1.xy, as offset for both z slices
+	float2 TexA1 = TexA0 + ts;	// for non-tiling, can compute relative to existing coordinates
+	float2 TexB1 = TexB0 + ts;
+	if (bTiling)				// for tiling, need to compute from wrapped coordinates
+	{
+		TexA1 = (float2(iv1.x, iv1.y) + OffsetA + 0.5f) * ts;
+		TexB1 = (float2(iv1.x, iv1.y) + OffsetB + 0.5f) * ts;
+	}
+
+
+	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 8, 16 or 32 bit)
+	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	float3 PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 A = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 B = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 C = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 D = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 E = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 F = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 G = PerlinNoiseColor * 2 - 1;
+	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
+	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
+	float3 H = PerlinNoiseColor * 2 - 1;
+
+	float a = math::dot(A, fv - float3(0, 0, 0));
+	float b = math::dot(B, fv - float3(1, 0, 0));
+	float c = math::dot(C, fv - float3(0, 1, 0));
+	float d = math::dot(D, fv - float3(1, 1, 0));
+	float e = math::dot(E, fv - float3(0, 0, 1));
+	float f = math::dot(F, fv - float3(1, 0, 1));
+	float g = math::dot(G, fv - float3(0, 1, 1));
+	float h = math::dot(H, fv - float3(1, 1, 1));
+
+	float4 Weights = PerlinRamp(math::frac(float4(fv.x, fv.y, fv.z, 0)));
+	
+	float i = math::lerp(math::lerp(a, b, Weights.x), math::lerp(c, d, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(e, f, Weights.x), math::lerp(g, h, Weights.x), Weights.y);
+
+	return math::lerp(i, j, Weights.z);
+}
+
+// @return random number in the range -1 .. 1
+// scalar: 6 frac, 31 mul/mad, 15 add, 
+float FastGradientPerlinNoise3D_TEX(uniform texture_3d PerlinNoise3DTexture, float3 xyz)
+{
+	// needs to be the same value when creating the PerlinNoise3D texture
+	float Extent = 16;
+
+	// last texel replicated and needed for filtering
+	// scalar: 3 frac, 6 mul
+	xyz = math::frac(xyz / (Extent - 1)) * (Extent - 1);
+
+	// scalar: 3 frac
+	float3 uvw = math::frac(xyz);
+	// = floor(xyz);
+	// scalar: 3 add
+	float3 p0 = xyz - uvw;
+//	float3 f = math::pow(uvw, 2) * 3.0f - math::pow(uvw, 3) * 2.0f;	// original perlin hermite (ok when used without bump mapping)
+	// scalar: 2*3 add 5*3 mul
+	float4 pr = PerlinRamp(float4(uvw.x, uvw.y, uvw.z, 0));
+	float3 f = float3(pr.x, pr.y, pr.z);	// new, better with continues second derivative for bump mapping
+	// scalar: 3 add
+	float3 p = p0 + f;
+	// scalar: 3 mad
+	// TODO: need reverse???
+	float4 NoiseSample = tex::lookup_float4(PerlinNoise3DTexture, p / Extent + 0.5f / Extent);	// +0.5f to get rid of bilinear offset
+
+	// reconstruct from 8bit (using mad with 2 constants and dot4 was same instruction count)
+	// scalar: 4 mad, 3 mul, 3 add 
+	float3 n = float3(NoiseSample.x, NoiseSample.y, NoiseSample.z) * 255.0f / 127.0f - 1.0f;
+	float d = NoiseSample.w * 255.f - 127;
+	return math::dot(xyz, n) - d;
+}
+
+// Perlin-style "Modified Noise"
+// http://www.umbc.edu/~olano/papers/index.html#mNoise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float GradientNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = MGradient(int(seeds.seed000), seeds.fv - float3(0, 0, 0)).w;
+	float rand100 = MGradient(int(seeds.seed100), seeds.fv - float3(1, 0, 0)).w;
+	float rand010 = MGradient(int(seeds.seed010), seeds.fv - float3(0, 1, 0)).w;
+	float rand110 = MGradient(int(seeds.seed110), seeds.fv - float3(1, 1, 0)).w;
+	float rand001 = MGradient(int(seeds.seed001), seeds.fv - float3(0, 0, 1)).w;
+	float rand101 = MGradient(int(seeds.seed101), seeds.fv - float3(1, 0, 1)).w;
+	float rand011 = MGradient(int(seeds.seed011), seeds.fv - float3(0, 1, 1)).w;
+	float rand111 = MGradient(int(seeds.seed111), seeds.fv - float3(1, 1, 1)).w;
+
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D value noise - used to be incorrectly called Perlin noise
+// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
+// @param bTiling = repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension
+// @return random number in the range -1 .. 1
+float ValueNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
+
+	float rand000 = RandBBSfloat(seeds.seed000) * 2 - 1;
+	float rand100 = RandBBSfloat(seeds.seed100) * 2 - 1;
+	float rand010 = RandBBSfloat(seeds.seed010) * 2 - 1;
+	float rand110 = RandBBSfloat(seeds.seed110) * 2 - 1;
+	float rand001 = RandBBSfloat(seeds.seed001) * 2 - 1;
+	float rand101 = RandBBSfloat(seeds.seed101) * 2 - 1;
+	float rand011 = RandBBSfloat(seeds.seed011) * 2 - 1;
+	float rand111 = RandBBSfloat(seeds.seed111) * 2 - 1;
+	
+	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
+	
+	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
+	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
+	return math::lerp(i, j, Weights.z);
+}
+
+// 3D jitter offset within a voronoi noise cell
+// @param pos - integer lattice corner
+// @return random offsets vector
+float3 VoronoiCornerSample(float3 pos, int Quality)
+{
+	// random values in [-0.5, 0.5]
+	float3 noise = float3(Rand3DPCG16(int3(pos))) / 0xffff - 0.5;
+
+	// quality level 1 or 2: searches a 2x2x2 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 2x2x2 search
+	if (Quality <= 2)
+	{
+		return math::normalize(noise) * 0.2588;
+	}
+
+	// quality level 3: searches a 3x3x3 neighborhood with points distributed on a sphere
+	// scale factor to guarantee jittered points will be found within a 3x3x3 search
+	if (Quality == 3)
+	{
+		return math::normalize(noise) * 0.3090;
+	}
+
+	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
+	return noise;
+}
+
+// compare previous best with a new candidate
+// not producing point locations makes it easier for compiler to eliminate calculations when they're not needed
+// @param minval = location and distance of best candidate seed point before the new one
+// @param candidate = candidate seed point
+// @param offset = 3D offset to new candidate seed point
+// @param bDistanceOnly = if true, only set maxval.w with distance, otherwise maxval.w is distance and maxval.xyz is position
+// @return position (if bDistanceOnly is false) and distance to closest seed point so far
+float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
+{
+	if (bDistanceOnly)
+	{
+		return float4(0, 0, 0, math::min(minval.w, math::dot(offset, offset)));
+	}
+	else
+	{
+		float newdist = math::dot(offset, offset);
+		return newdist > minval.w ? minval : float4(candidate.x, candidate.y, candidate.z, newdist);
+	}
+}
+
+// 220 instruction Worley noise
+float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
+{
+	float3 fv = math::frac(v),  fv2 = math::frac(v + 0.5);
+	float3 iv = math::floor(v), iv2 = math::floor(v + 0.5);
+
+	// with initial minimum distance = infinity (or at least bigger than 4), first min is optimized away
+	float4 mindist = float4(0,0,0,100);
+	float3 p, offset;
+
+	// quality level 3: do a 3x3x3 search
+	if (Quality == 3)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = -1; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = -1; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = -1; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// everybody else searches a base 2x2x2 neighborhood
+	else
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;
+		for (offset_x = 0; offset_x <= 1; ++offset_x)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// quality level 2, do extra set of points, offset by half a cell
+					if (Quality == 2)
+					{
+						// 467 is just an offset to a different area in the random number field to avoid similar neighbor artifacts
+						p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize) + 467, Quality);
+						mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
+					}
+				}
+			}
+		}
+	}
+
+	// quality level 4: add extra sets of four cells in each direction
+	if (Quality >= 4)
+	{
+		int offset_x;
+		int offset_y;
+		int offset_z;	
+		for (offset_x = -1; offset_x <= 2; offset_x += 3)
+		{
+			for (offset_y = 0; offset_y <= 1; ++offset_y)
+			{
+				for (offset_z = 0; offset_z <= 1; ++offset_z)
+				{
+					offset = float3(offset_x, offset_y, offset_z);
+					// along x axis
+					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along y axis
+					p = float3(offset.y, offset.z, offset.x) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.y, offset.z, offset.x), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+
+					// along z axis
+					p = float3(offset.z, offset.x, offset.y) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.z, offset.x, offset.y), bTiling, RepeatSize), Quality);
+					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
+				}
+			}
+		}
+	}
+
+	// transform squared distance to real distance
+	return float4(mindist.x, mindist.y, mindist.z, math::sqrt(mindist.w));
+}
+
+// Coordinates for corners of a Simplex tetrahedron
+// Based on McEwan et al., Efficient computation of noise in GLSL, JGT 2011
+// @param v = 3D noise argument
+// @return 4 corner locations
+float4x3 SimplexCorners(float3 v)
+{
+	// find base corner by skewing to tetrahedral space and back
+	float3 tet = math::floor(v + v.x/3 + v.y/3 + v.z/3);
+	float3 base = tet - tet.x/6 - tet.y/6 - tet.z/6;
+	float3 f = v - base;
+
+	// Find offsets to other corners (McEwan did this in tetrahedral space,
+	// but since skew is along x=y=z axis, this works in Euclidean space too.)
+	float3 g = math::step(float3(f.y,f.z,f.x), float3(f.x,f.y,f.z)), h = 1 - float3(g.z, g.x, g.y);
+	float3 a1 = math::min(g, h) - 1.0 / 6.0, a2 = math::max(g, h) - 1.0 / 3.0;
+
+	// four corners
+	return float4x3(base, base + a1, base + a2, base + 0.5);
+}
+
+// Improved smoothing function for simplex noise
+// @param f = fractional distance to four tetrahedral corners
+// @return weight for each corner
+float4 SimplexSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	return (1 * scale + s*(-3 * scale + s*(3 * scale - s*scale)));
+}
+
+// Derivative of simplex noise smoothing function
+// @param f = fractional distanc eto four tetrahedral corners
+// @return derivative of smoothing function for each corner by x, y and z
+float3x4 SimplexDSmooth(float4x3 f)
+{
+	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
+	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
+	float4 s = math::saturate(2 * d);
+	s = -12 * scale + s*(24 * scale - s * 12 * scale);
+
+	return float3x4(
+		s * float4(f[0][0], f[1][0], f[2][0], f[3][0]),
+		s * float4(f[0][1], f[1][1], f[2][1], f[3][1]),
+		s * float4(f[0][2], f[1][2], f[2][2], f[3][2]));
+}
+
+// Simplex noise and its Jacobian derivative
+// @param v = 3D noise argument
+// @param bTiling = whether to repeat noise pattern
+// @param RepeatSize = integer units before tiling in each dimension, must be a multiple of 3
+// @return float3x3 Jacobian in J[*].xyz, vector noise in J[*].w
+//     J[0].w, J[1].w, J[2].w is a Perlin-style simplex noise with vector output, e.g. (Nx, Ny, Nz)
+//     J[i].x is X derivative of the i'th component of the noise so J[2].x is dNz/dx
+// You can use this to compute the noise, gradient, curl, or divergence:
+//   float3x4 J = JacobianSimplex_ALU(...);
+//   float3 VNoise = float3(J[0].w, J[1].w, J[2].w);	// 3D noise
+//   float3 Grad = J[0].xyz;							// gradient of J[0].w
+//   float3 Curl = float3(J[1][2]-J[2][1], J[2][0]-J[0][2], J[0][1]-J[1][2]);
+//   float Div = J[0][0]+J[1][1]+J[2][2];
+// All of these are confirmed to compile out all unneeded terms.
+// So Grad of X doesn't compute Y or Z components, and VNoise doesn't do any of the derivative computation.
+float3x4 JacobianSimplex_ALU(float3 v, bool bTiling, float RepeatSize)
+{
+	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
+	float3 MGradientScale = float3(1. / 0x4000, 1. / 0x2000, 1. / 0x1000);
+
+	// corners of tetrahedron
+	float4x3 T = SimplexCorners(v);
+	// TODO: uint3
+	int3 rand = int3(0);
+	float4x3 gvec0 = float4x3(1.0);
+	float4x3 gvec1 = float4x3(1.0);
+	float4x3 gvec2 = float4x3(1.0);
+	float4x3 fv = float4x3(1.0);
+	float3x4 grad = float3x4(1.0);
+
+	// processing of tetrahedral vertices, unrolled
+	// to compute gradient at each corner
+	fv[0] = v - T[0];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[0] + 0.5, bTiling, RepeatSize))));
+	gvec0[0] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[0] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[0] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][0] = math::dot(gvec0[0], fv[0]);
+	grad[1][0] = math::dot(gvec1[0], fv[0]);
+	grad[2][0] = math::dot(gvec2[0], fv[0]);
+
+	fv[1] = v - T[1];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[1] + 0.5, bTiling, RepeatSize))));
+	gvec0[1] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec1[1] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][1] = math::dot(gvec0[1], fv[1]);
+	grad[1][1] = math::dot(gvec1[1], fv[1]);
+	grad[2][1] = math::dot(gvec2[1], fv[1]);
+
+	fv[2] = v - T[2];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[2] + 0.5, bTiling, RepeatSize))));
+	gvec0[2] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[2] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[2] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][2] = math::dot(gvec0[2], fv[2]);
+	grad[1][2] = math::dot(gvec1[2], fv[2]);
+	grad[2][2] = math::dot(gvec2[2], fv[2]);
+
+	fv[3] = v - T[3];
+	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[3] + 0.5, bTiling, RepeatSize))));
+	gvec0[3] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
+	gvec1[3] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
+	gvec2[3] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
+	grad[0][3] = math::dot(gvec0[3], fv[3]);
+	grad[1][3] = math::dot(gvec1[3], fv[3]);
+	grad[2][3] = math::dot(gvec2[3], fv[3]);
+
+	// blend gradients
+	float4 sv = SimplexSmooth(fv);
+	float3x4 ds = SimplexDSmooth(fv);
+
+	float3x4 jacobian = float3x4(1.0);
+	float3 vec0 = gvec0*sv + grad[0]*ds; // NOTE: mdl is column major, convert from UE4 (row major)
+	jacobian[0] = float4(vec0.x, vec0.y, vec0.z, math::dot(sv, grad[0]));
+	float3 vec1 = gvec1*sv + grad[1]*ds;
+	jacobian[1] = float4(vec1.x, vec1.y, vec1.z, math::dot(sv, grad[1]));
+	float3 vec2 = gvec2*sv + grad[2]*ds;
+	jacobian[2] = float4(vec2.x, vec2.y, vec2.z, math::dot(sv, grad[2]));
+
+	return jacobian;
+}
+
+// While RepeatSize is a float here, the expectation is that it would be largely integer values coming in from the UI. The downstream logic assumes
+// floats for all called functions (NoiseTileWrap) and this prevents any float-to-int conversion errors from automatic type conversion.
+float Noise3D_Multiplexer(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, int Function, float3 Position, int Quality, bool bTiling, float RepeatSize)
+{
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch(Function)
+	{
+		case 0:
+			return SimplexNoise3D_TEX(PerlinNoiseGradientTexture, Position);
+		case 1:
+			return GradientNoise3D_TEX(PerlinNoiseGradientTexture, Position, bTiling, RepeatSize);
+		case 2:
+			return FastGradientPerlinNoise3D_TEX(PerlinNoise3DTexture, Position);
+		case 3:
+			return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 4:
+			return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
+		case 5:
+			return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2.0 - 1.0;
+	}
+	return 0;
+}
+//----------------------------------------------------------
+
+export float noise(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, float3 Position, float Scale, float Quality, float Function, float Turbulence, float Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, float Tiling, float RepeatSize)
+[[
+    anno::description("Noise"),
+    anno::noinline()
+]]
+{
+	Position *= Scale;
+	FilterWidth *= Scale;
+
+	float Out = 0.0f;
+	float OutScale = 1.0f;
+	float InvLevelScale = 1.0f / LevelScale;
+	
+	int iFunction(Function);
+	int iQuality(Quality);
+	int iLevels(Levels);
+	bool bTurbulence(Turbulence);
+	bool bTiling(Tiling);
+	
+	for(int i = 0; i < iLevels; ++i)
+	{
+		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
+		OutScale *= math::saturate(1.0 - FilterWidth);
+
+		if(bTurbulence)
+		{
+			Out += math::abs(Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize)) * OutScale;
+		}
+		else
+		{
+			Out += Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize) * OutScale;
+		}
+
+		Position *= LevelScale;
+		RepeatSize *= LevelScale;
+		OutScale *= InvLevelScale;
+		FilterWidth *= LevelScale;
+	}
+
+	if(!bTurbulence)
+	{
+		// bring -1..1 to 0..1 range
+		Out = Out * 0.5f + 0.5f;
+	}
+
+	// Out is in 0..1 range
+	return math::lerp(OutputMin, OutputMax, Out);
+}
+
+// Material node for noise functions returning a vector value
+// @param LevelScale usually 2 but higher values allow efficient use of few levels
+// @return in user defined range (OutputMin..OutputMax)
+export float4 vector4_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise"),
+    anno::noinline()
+]]
+{
+	float4 result = float4(0,0,0,1);
+	float3 ret = float3(0);
+	int iQuality = int(Quality);
+	int iFunction = int(Function);
+	bool bTiling = Tiling > 0.0;
+	
+	float3x4 Jacobian = JacobianSimplex_ALU(Position, bTiling, TileSize);	// compiled out if not used
+
+	// verified, HLSL compiled out the switch if Function is a constant
+	switch (iFunction)
+	{
+	case 0:	// Cellnoise
+		ret = float3(Rand3DPCG16(int3(math::floor(NoiseTileWrap(Position, bTiling, TileSize))))) / 0xffff;
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 1: // Color noise
+		ret = float3(Jacobian[0].w, Jacobian[1].w, Jacobian[2].w);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 2: // Gradient
+		result = Jacobian[0];
+		break;
+	case 3: // Curl
+		ret = float3(Jacobian[2][1] - Jacobian[1][2], Jacobian[0][2] - Jacobian[2][0], Jacobian[1][0] - Jacobian[0][1]);
+		result = float4(ret.x, ret.y, ret.z, 1);
+		break;
+	case 4: // Voronoi
+		result = VoronoiNoise3D_ALU(Position, iQuality, bTiling, TileSize, false);
+		break;
+	}
+	return result;
+}
+
+export float3 vector3_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
+[[
+    anno::description("Vector Noise float3 version"),
+    anno::noinline()
+]]
+{
+	float4 noise = vector4_noise(Position, Quality, Function, Tiling, TileSize);
+	return float3(noise.x, noise.y, noise.z);
+}
+
+
+// workaround for ue4 fresnel (without supporting for camera vector) : replacing it with 0.0, means facing to the view
+export float fresnel(float exponent [[anno::unused()]], float base_reflect_fraction [[anno::unused()]], float3 normal [[anno::unused()]])
+[[
+    anno::description("Fresnel"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float fresnel_function(float3 normal_vector [[anno::unused()]], float3 camera_vector [[anno::unused()]], 
+                                bool invert_fresnel [[anno::unused()]], float power [[anno::unused()]], 
+                                bool use_cheap_contrast [[anno::unused()]], float cheap_contrast_dark [[anno::unused()]], float cheap_contrast_bright [[anno::unused()]], 
+                                bool clamp_fresnel_dot_product [[anno::unused()]])
+[[
+    anno::description("Fresnel Function"),
+    anno::noinline()
+]]
+{
+	return 0.0;
+}
+
+export float3 camera_vector(uniform bool up_z = true)
+[[
+    anno::description("Camera Vector"),
+    anno::noinline()
+]]
+{
+	// assume camera postion is 0,0,0
+	return math::normalize(float3(0) - convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z));
+}
+
+export float pixel_depth()
+[[
+    anno::description("Pixel Depth"),
+    anno::noinline()
+]]
+{
+	return 256.0f;
+}
+
+export float scene_depth()
+[[
+    anno::description("Scene Depth")
+]]
+{
+	return 65500.0f;
+}
+
+export float3 scene_color()
+[[
+    anno::description("Scene Color")
+]]
+{
+	return float3(1.0f);
+}
+
+export float4 vertex_color()
+[[
+    anno::description("Vertex Color"),
+    anno::noinline()
+]]
+{
+	return float4(1.0f);
+}
+
+export float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
+[[
+    anno::description("Vertex Color for float2 PrimVar"),
+    anno::noinline()
+]]
+{
+	// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
+	return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
+}
+
+export float3 camera_position()
+[[
+    anno::description("Camera Position"),
+    anno::noinline()
+]]
+{
+	return float3(1000.0f, 0, 0);
+}
+
+export float3 rotate_about_axis(float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position)
+[[
+    anno::description("Rotates Position about the given axis by the given angle")
+]]
+{
+	// Project Position onto the rotation axis and find the closest point on the axis to Position
+	float3 NormalizedRotationAxis = float3(NormalizedRotationAxisAndAngle.x,NormalizedRotationAxisAndAngle.y,NormalizedRotationAxisAndAngle.z);
+	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxis * math::dot(NormalizedRotationAxis, Position - PositionOnAxis);
+	// Construct orthogonal axes in the plane of the rotation
+	float3 UAxis = Position - ClosestPointOnAxis;
+	float3 VAxis = math::cross(NormalizedRotationAxis, UAxis);
+	float[2] SinCosAngle = math::sincos(NormalizedRotationAxisAndAngle.w);
+	// Rotate using the orthogonal axes
+	float3 R = UAxis * SinCosAngle[1] + VAxis * SinCosAngle[0];
+	// Reconstruct the rotated world space position
+	float3 RotatedPosition = ClosestPointOnAxis + R;
+	// Convert from position to a position offset
+	return RotatedPosition - Position;
+}
+
+export float2 rotate_scale_offset_texcoords(float2 InTexCoords, float4 InRotationScale, float2 InOffset)
+[[
+    anno::description("Returns a float2 texture coordinate after 2x2 transform and offset applied")
+]]
+{
+	return float2(math::dot(InTexCoords, float2(InRotationScale.x, InRotationScale.y)), math::dot(InTexCoords, float2(InRotationScale.z, InRotationScale.w))) + InOffset;
+}
+
+export float3 reflection_custom_world_normal(float3 WorldNormal, bool bNormalizeInputNormal, uniform bool up_z = true)
+[[
+    anno::description("Reflection vector about the specified world space normal")
+]]
+{
+	if (bNormalizeInputNormal)
+	{
+		WorldNormal = math::normalize(WorldNormal);
+	}
+
+	return -camera_vector(up_z) + WorldNormal * math::dot(WorldNormal, camera_vector(up_z)) * 2.0;
+}
+
+export float3 reflection_vector(uniform bool up_z = true)
+[[
+    anno::description("Reflection Vector"),
+    anno::noinline()
+]]
+{
+    float3 normal = convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
+	return reflection_custom_world_normal(normal, false, up_z);
+}
+
+export float dither_temporalAA(float AlphaThreshold = 0.5f, float Random = 1.0f [[anno::unused()]])
+[[
+    anno::description("Dither TemporalAA"),
+    anno::noinline()
+]]
+{
+	return AlphaThreshold;
+}
+
+export float3 black_body( float Temp )
+[[
+    anno::description("Black Body"),
+	anno::noinline()
+]]
+{
+	float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
+	float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
+
+	float x = 3*u / ( 2*u - 8*v + 4 );
+	float y = 2*v / ( 2*u - 8*v + 4 );
+	float z = 1 - x - y;
+
+	float Y = 1;
+	float X = Y/y * x;
+	float Z = Y/y * z;
+
+	float3x3 XYZtoRGB = float3x3(
+		float3(3.2404542, -1.5371385, -0.4985314),
+		float3(-0.9692660,  1.8760108,  0.0415560),
+		float3(0.0556434, -0.2040259,  1.0572252)
+	);
+
+	return XYZtoRGB * float3( X, Y, Z ) * math::pow( 0.0004 * Temp, 4 );
+}
+
+export float per_instance_random(uniform texture_2d PerlinNoiseGradientTexture, int NumberInstances)
+[[
+    anno::description("Per Instance Random"),
+	anno::noinline()
+]]
+{
+	float weight = state::object_id() / float(NumberInstances);	
+	return NumberInstances == 0 ? 0.0 : tex::lookup_float4(PerlinNoiseGradientTexture, float2(weight, 1.0 - weight), tex::wrap_repeat, tex::wrap_repeat).x;
+}
+
+//------------------ Hair from UE4 -----------------------
+float3 hair_absorption_to_color(float3 A)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::exp(-math::sqrt(A) * D);
+}
+
+float3 hair_color_to_absorption(float3 C)
+{
+	const float B = 0.3f;
+	float b2 = B * B;
+	float b3 = B * b2;
+	float b4 = b2 * b2;
+	float b5 = B * b4;
+	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
+	return math::pow(math::log(C) / D, 2.0f);
+}
+
+export float3 get_hair_color_from_melanin(float InMelanin, float InRedness, float3 InDyeColor)
+[[
+    anno::description("Hair Color")
+]]
+{
+	InMelanin = math::saturate(InMelanin);
+	InRedness = math::saturate(InRedness);
+	float Melanin		= -math::log(math::max(1 - InMelanin, 0.0001f));
+	float Eumelanin 	= Melanin * (1 - InRedness);
+	float Pheomelanin = Melanin * InRedness;
+
+	float3 DyeAbsorption = hair_color_to_absorption(math::saturate(InDyeColor));
+	float3 Absorption = Eumelanin * float3(0.506f, 0.841f, 1.653f) + Pheomelanin * float3(0.343f, 0.733f, 1.924f);
+
+	return hair_absorption_to_color(Absorption + DyeAbsorption);
+}
+
+export float3 local_object_bounds_min()
+[[
+    anno::description("Local Object Bounds Min"),
+	anno::noinline()
+]]
+{
+	return float3(0.0);
+}
+
+export float3 local_object_bounds_max()
+[[
+    anno::description("Local Object Bounds Max"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float3 object_bounds()
+[[
+    anno::description("Object Bounds"),
+	anno::noinline()
+]]
+{
+	return float3(100.0);
+}
+
+export float object_radius()
+[[
+    anno::description("Object Radius"),
+	anno::noinline()
+]]
+{
+	return 100.0f;
+}
+
+export float3 object_world_position(uniform bool up_z = true)
+[[
+    anno::description("Object World Position"),
+	anno::noinline()
+]]
+{
+	return convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z)*state::meters_per_scene_unit()*100.0;
+}
+
+export float3 object_orientation()
+[[
+    anno::description("Object Orientation"),
+	anno::noinline()
+]]
+{
+	return float3(0);
+}
+
+export float rcp(float x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float2 rcp(float2 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float3 rcp(float3 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export float4 rcp(float4 x)
+[[
+    anno::description("hlsl rcp"),
+	anno::noinline()
+]]
+{
+	return 1.0f / x;
+}
+
+export int BitFieldExtractI32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractI32 int"),
+	anno::noinline()
+]]
+{
+	Size &= 3;
+	Offset &= 3;
+
+	if (Size == 0)
+		return 0;
+	else if (Offset + Size < 32)
+		return (Data << (32 - Size - Offset)) >> (32 - Size);
+	else
+		return Data >> Offset;
+}
+
+export int BitFieldExtractI32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractI32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(int(Data), int(Size), int(Offset));
+}
+
+export int BitFieldExtractU32(float Data, float Size, float Offset)
+[[
+    anno::description("BitFieldExtractU32 float"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export int BitFieldExtractU32(int Data, int Size, int Offset)
+[[
+    anno::description("BitFieldExtractU32 int"),
+	anno::noinline()
+]]
+{
+	return BitFieldExtractI32(Data, Size, Offset);
+}
+
+export float3 EyeAdaptationInverseLookup(float3 LightValue, float Alpha)
+[[
+    anno::description("EyeAdaptationInverseLookup"),
+	anno::noinline()
+]]
+{
+	float Adaptation = 1.0f;
+
+	// When Alpha=0.0, we want to multiply by 1.0. when Alpha = 1.0, we want to multiply by 1/Adaptation.
+	// So the lerped value is:
+	//     LerpLogScale = Lerp(log(1),log(1/Adaptaiton),T)
+	// Which is simplified as:
+	//     LerpLogScale = Lerp(0,-log(Adaptation),T)
+	//     LerpLogScale = -T * logAdaptation;
+
+	float LerpLogScale = -Alpha * math::log(Adaptation);
+	float Scale = math::exp(LerpLogScale);
+	return LightValue * Scale;
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/grutopia_usd/Table/table/5c8596964c102c0be7676263bb55cddb/instance.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_instance" (
+        prepend payload = @./instance.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/objaverse_usd/2b70993763034bef8587d3730c7ca8ff.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_2b70993763034bef8587d3730c7ca8ff" (
+        prepend payload = @./2b70993763034bef8587d3730c7ca8ff.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/objaverse_usd/2cda50e73f69438598eabf8259e27cb7.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_2cda50e73f69438598eabf8259e27cb7" (
+        prepend payload = @./2cda50e73f69438598eabf8259e27cb7.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/objaverse_usd/30f8ba058e1f4e288f5a2ddcba924c3f.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_30f8ba058e1f4e288f5a2ddcba924c3f" (
+        prepend payload = @./30f8ba058e1f4e288f5a2ddcba924c3f.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/object_usds/objaverse_usd/cf2af4b2b8c6420da69ba8d8f73744bc.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_cf2af4b2b8c6420da69ba8d8f73744bc" (
+        prepend payload = @./cf2af4b2b8c6420da69ba8d8f73744bc.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/scene_waste/obj_badbin.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_obj_badbin" (
+        prepend payload = @./obj_badbin.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}

scenes/scene_usds/IROS_scenes_aloha_final/scene_waste/base/scene_waste/obj_goodbin.usda

@@ -0,0 +1,78 @@
+#usda 1.0
+(
+    customLayerData = {
+        dictionary omni_layer = {
+            dictionary locked = {
+            }
+            dictionary muteness = {
+            }
+        }
+        dictionary renderSettings = {
+            float3 "rtx:debugView:pixelDebug:textColor" = (0, 1e18, 0)
+            float3 "rtx:fog:fogColor" = (0.75, 0.75, 0.75)
+            float3 "rtx:index:backgroundColor" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMax" = (0, 0, 0)
+            float3 "rtx:index:regionOfInterestMin" = (0, 0, 0)
+            float3 "rtx:post:backgroundZeroAlpha:backgroundDefaultColor" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gain" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorcorr:offset" = (0, 0, 0)
+            float3 "rtx:post:colorcorr:saturation" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:blackpoint" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:contrast" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gain" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:gamma" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:lift" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:multiply" = (1, 1, 1)
+            float3 "rtx:post:colorgrad:offset" = (0, 0, 0)
+            float3 "rtx:post:colorgrad:whitepoint" = (1, 1, 1)
+            float3 "rtx:post:lensDistortion:lensFocalLengthArray" = (10, 30, 50)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffX" = (450, 475, 500)
+            float3 "rtx:post:lensFlares:anisoFlareFalloffY" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:cutoffPoint" = (2, 2, 2)
+            float3 "rtx:post:lensFlares:haloFlareFalloff" = (10, 10, 10)
+            float3 "rtx:post:lensFlares:haloFlareRadius" = (75, 75, 75)
+            float3 "rtx:post:lensFlares:isotropicFlareFalloff" = (50, 50, 50)
+            float3 "rtx:post:tonemap:whitepoint" = (1, 1, 1)
+            float3 "rtx:raytracing:indexdirect:svoBrickSize" = (32, 32, 32)
+            float3 "rtx:raytracing:inscattering:singleScatteringAlbedo" = (0.9, 0.9, 0.9)
+            float3 "rtx:raytracing:inscattering:transmittanceColor" = (0.5, 0.5, 0.5)
+            float3 "rtx:sceneDb:ambientLightColor" = (0.1, 0.1, 0.1)
+            double "rtx:translucency:worldEps" = 0.005
+        }
+    }
+    defaultPrim = "World"
+    endTimeCode = 1000000
+    metersPerUnit = 1.0
+    startTimeCode = 0
+    timeCodesPerSecond = 60
+    upAxis = "Z"
+)
+
+over "Render" (
+    hide_in_stage_window = true
+)
+{
+}
+
+def Xform "World"
+{
+    def "_obj_goodbin" (
+        prepend payload = @./obj_goodbin.usd@
+    )
+    {
+        float3 xformOp:rotateXYZ = (0, 0, 0)
+        float3 xformOp:scale = (1, 1, 1)
+        double3 xformOp:translate = (0, 0, 0)
+        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+    }
+}
+
+def Xform "Environment"
+{
+    double3 xformOp:rotateXYZ = (0, 0, 0)
+    double3 xformOp:scale = (1, 1, 1)
+    double3 xformOp:translate = (0, 0, 0)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]
+}