Add files using upload-large-folder tool

.gitattributes

@@ -62,3 +62,5 @@ InternScenes/InternScenes_Real2Sim/textures/Marble012_1K-JPG.blend filter=lfs di
 InternScenes/InternScenes_Real2Sim/textures/WoodFloor051_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text
 InternScenes/InternScenes_Real2Sim/textures/WoodFloor043_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text
 InternScenes/InternScenes_Real2Sim/textures/Tiles099_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text
+InternScenes/InternScenes_Real2Sim/textures/Tiles074_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text
+InternScenes/InternScenes_Real2Sim/textures/Bricks076A_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text

InternScenes/InternScenes_Real2Sim/materials/metal/__init__.py

@@ -0,0 +1,92 @@
+# Copyright (C) 2023, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Lingjie Mei
+from collections.abc import Iterable
+
+import numpy as np
+from numpy.random import uniform
+
+from infinigen.assets.materials import common
+from infinigen.assets.materials.bark_random import hex_to_rgb
+from infinigen.core.util.color import hsv2rgba, rgb2hsv
+from infinigen.core.util.random import log_uniform
+from infinigen.core.util.random import random_general as rg
+
+from . import (
+    brushed_metal,
+    galvanized_metal,
+    grained_and_polished_metal,
+    hammered_metal,
+    metal_basic,
+)
+
+
+def apply(obj, selection=None, metal_color=None, **kwargs):
+    color = sample_metal_color(metal_color)
+    shader = get_shader()
+    common.apply(obj, shader, selection, base_color=color, **kwargs)
+
+
+def get_shader():
+    return np.random.choice(
+        [
+            brushed_metal.shader_brushed_metal,
+            galvanized_metal.shader_galvanized_metal,
+            grained_and_polished_metal.shader_grained_metal,
+            hammered_metal.shader_hammered_metal,
+        ]
+    )
+
+
+plain_colors = (
+    "weighted_choice",
+    (0.5, 0xFDD017),
+    (1, 0xC0C0C0),
+    (1, 0x8C7853),
+    (0.5, 0xB87333),
+    (0.5, 0xB5A642),
+    (1, 0xBDBAAE),
+    (1, 0xA9ACB6),
+    (1, 0xB6AFA9),
+)
+natural_colors = (
+    "weighted_choice",
+    (1, 0xC0C0C0),
+    (1, 0x8C7853),
+    (1, 0xBDBAAE),
+    (1, 0xA9ACB6),
+    (1, 0xB6AFA9),
+)
+
+
+def sample_metal_color(metal_color=None, **kwargs):
+    match metal_color:
+        case np.ndarray():
+            return metal_color
+        case "plain":
+            h, s, v = rgb2hsv(hex_to_rgb(rg(plain_colors))[:-1])
+            return hsv2rgba(
+                h + uniform(-0.1, 0.1),
+                s + uniform(-0.1, 0.1),
+                v * log_uniform(0.5, 0.2),
+            )
+        case "natural":
+            h, s, v = rgb2hsv(hex_to_rgb(rg(natural_colors))[:-1])
+            return hsv2rgba(
+                h + uniform(-0.1, 0.1),
+                s + uniform(-0.1, 0.1),
+                v * log_uniform(0.5, 0.2),
+            )
+        case "bw":
+            return hsv2rgba(uniform(0, 1), uniform(0.0, 0.2), log_uniform(0.01, 0.2))
+        case "bw+natural":
+            return (
+                sample_metal_color("bw")
+                if uniform() < 0.5
+                else sample_metal_color("natural")
+            )
+        case _:
+            if uniform() < 0.2:
+                return sample_metal_color("natural")
+            return hsv2rgba(uniform(0, 1), uniform(0.3, 0.6), log_uniform(0.02, 0.5))

InternScenes/InternScenes_Real2Sim/materials/metal/brushed_metal.py

@@ -0,0 +1,169 @@
+# Copyright (C) 2024, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Yiming Zuo
+# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=QcAMYRgR03k by blenderian
+
+
+from numpy.random import uniform
+
+from infinigen.core import surface
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_brushed_metal", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_brushed_metal(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    texture_coordinate = nw.new_node(Nodes.TextureCoord)
+
+    mapping_1 = nw.new_node(
+        Nodes.Mapping,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "Scale": (0.2000, 0.2000, 5.0000),
+        },
+    )
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)),
+            ("NodeSocketFloat", "Scale", 0.0000),
+            ("NodeSocketFloat", "Seed", 0.0000),
+        ],
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 100.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture_2 = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": mapping_1,
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+            "Roughness": 0.4000,
+            "Distortion": 0.1000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    mapping = nw.new_node(
+        Nodes.Mapping,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "Scale": (1.0000, 1.0000, 20.0000),
+        },
+    )
+
+    noise_texture_1 = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": 0.1000,
+            "Detail": 15.0000,
+            "Roughness": 0.0000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 0.2000, 6: mapping, 7: noise_texture_1.outputs["Color"]},
+        attrs={"data_type": "RGBA"},
+    )
+
+    noise_texture = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": mix.outputs[2],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+            "Roughness": 0.6000,
+            "Distortion": 0.1000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: 1.0000,
+            6: noise_texture_2.outputs["Fac"],
+            7: noise_texture.outputs["Fac"],
+        },
+        attrs={"blend_type": "DARKEN", "data_type": "RGBA"},
+    )
+
+    map_range = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={"Value": mix_1, 1: 0.4000, 2: 0.6000, 3: 0.8000, 4: 1.2000},
+    )
+
+    hue_saturation_value = nw.new_node(
+        "ShaderNodeHueSaturation",
+        input_kwargs={
+            "Value": map_range.outputs["Result"],
+            "Color": group_input.outputs["Base Color"],
+        },
+    )
+
+    map_range_1 = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={"Value": mix_1, 1: 0.4000, 2: 0.6000, 3: 0.2000, 4: 0.3000},
+    )
+
+    principled_bsdf = nw.new_node(
+        Nodes.PrincipledBSDF,
+        input_kwargs={
+            "Base Color": hue_saturation_value,
+            "Metallic": 1.0000,
+            "Specular": 0.0000,
+            "Roughness": map_range_1.outputs["Result"],
+        },
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"BSDF": principled_bsdf, "tmp_viewer": principled_bsdf},
+        attrs={"is_active_output": True},
+    )
+
+
+def shader_brushed_metal(
+    nw: NodeWrangler, scale=1.0, base_color=None, seed=None, **kwargs
+):
+    # Code generated using version 2.6.4 of the node_transpiler
+    if seed is None:
+        seed = uniform(-1000.0, 1000.0)
+    if base_color is None:
+        from infinigen.assets.materials.metal import sample_metal_color
+
+        base_color = sample_metal_color(**kwargs)
+
+    group = nw.new_node(
+        nodegroup_brushed_metal().name,
+        input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed},
+    )
+
+    material_output = nw.new_node(
+        Nodes.MaterialOutput,
+        input_kwargs={"Surface": group.outputs["BSDF"]},
+        attrs={"is_active_output": True},
+    )
+
+
+def apply(obj, selection=None, **kwargs):
+    surface.add_material(
+        obj, shader_brushed_metal, selection=selection, input_kwargs=kwargs
+    )

InternScenes/InternScenes_Real2Sim/materials/metal/galvanized_metal.py

@@ -0,0 +1,122 @@
+# Copyright (C) 2024, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Yiming Zuo
+# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=ECl2pQ1jQm8 by Ryan King Art
+
+from numpy.random import uniform
+
+from infinigen.assets.materials import common
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_galvanized_metal", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_galvanized_metal(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)),
+            ("NodeSocketFloat", "Scale", 0.0000),
+            ("NodeSocketFloat", "Seed", 0.0000),
+        ],
+    )
+
+    texture_coordinate = nw.new_node(Nodes.TextureCoord)
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 5.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+            "Roughness": 0.4000,
+            "Distortion": 0.2000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: 0.0500,
+            6: texture_coordinate.outputs["Object"],
+            7: noise_texture.outputs["Color"],
+        },
+        attrs={"clamp_factor": False, "data_type": "RGBA"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 500.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    voronoi_texture = nw.new_node(
+        Nodes.VoronoiTexture,
+        input_kwargs={
+            "Vector": mix.outputs[2],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply_1,
+        },
+        attrs={"distance": "MINKOWSKI", "voronoi_dimensions": "4D"},
+    )
+
+    map_range = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={"Value": voronoi_texture.outputs["Color"], 3: 0.1000, 4: 0.5000},
+    )
+
+    principled_bsdf = nw.new_node(
+        Nodes.PrincipledBSDF,
+        input_kwargs={
+            "Base Color": group_input.outputs["Base Color"],
+            "Metallic": 1.0000,
+            "Specular": 0.0000,
+            "Roughness": map_range.outputs["Result"],
+        },
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"BSDF": principled_bsdf},
+        attrs={"is_active_output": True},
+    )
+
+
+def shader_galvanized_metal(
+    nw: NodeWrangler, scale=1.0, base_color=None, seed=None, **kwargs
+):
+    # Code generated using version 2.6.4 of the node_transpiler
+    if seed is None:
+        seed = uniform(-1000.0, 1000.0)
+    if base_color is None:
+        from infinigen.assets.materials.metal import sample_metal_color
+
+        base_color = sample_metal_color(**kwargs)
+
+    group = nw.new_node(
+        nodegroup_galvanized_metal().name,
+        input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed},
+    )
+
+    material_output = nw.new_node(
+        Nodes.MaterialOutput,
+        input_kwargs={"Surface": group},
+        attrs={"is_active_output": True},
+    )
+
+
+def apply(obj, selection=None, **kwargs):
+    common.apply(obj, shader_galvanized_metal, selection=selection, **kwargs)

InternScenes/InternScenes_Real2Sim/materials/metal/grained_and_polished_metal.py

@@ -0,0 +1,127 @@
+# Copyright (C) 2024, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Yiming Zuo
+
+from numpy.random import uniform
+
+from infinigen.core import surface
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_grained_metal", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_grained_metal(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)),
+            ("NodeSocketFloat", "Scale", 5.0000),
+            ("NodeSocketFloat", "Seed", 0.0000),
+            ("NodeSocketFloat", "Roughness", 0.0000),
+        ],
+    )
+
+    map_range = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={"Value": group_input.outputs["Roughness"], 3: 0.0500, 4: 0.2500},
+    )
+
+    principled_bsdf = nw.new_node(
+        Nodes.PrincipledBSDF,
+        input_kwargs={
+            "Base Color": group_input.outputs["Base Color"],
+            "Metallic": 1.0000,
+            "Specular": 0.0000,
+            "Roughness": map_range.outputs["Result"],
+        },
+    )
+
+    texture_coordinate = nw.new_node(Nodes.TextureCoord)
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 2000.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+            "Distortion": 2.0000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: map_range.outputs["Result"], 1: 0.4000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: noise_texture.outputs["Fac"], 1: multiply_1},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_2, 1: 0.010},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"BSDF": principled_bsdf, "Displacement": multiply_3},
+        attrs={"is_active_output": True},
+    )
+
+
+def shader_grained_metal(
+    nw: NodeWrangler, scale=1.0, base_color=None, roughness=None, seed=None, **kwargs
+):
+    # Code generated using version 2.6.4 of the node_transpiler
+    if roughness is None:
+        roughness = uniform(0.0, 1.0)
+    if seed is None:
+        seed = uniform(-1000.0, 1000.0)
+    if base_color is None:
+        from infinigen.assets.materials.metal import sample_metal_color
+
+        base_color = sample_metal_color(**kwargs)
+
+    group = nw.new_node(
+        nodegroup_grained_metal().name,
+        input_kwargs={
+            "Base Color": base_color,
+            "Scale": scale,
+            "Seed": seed,
+            "Roughness": roughness,
+        },
+    )
+
+    displacement = nw.new_node(
+        "ShaderNodeDisplacement",
+        input_kwargs={"Height": group.outputs["Displacement"], "Midlevel": 0.0000},
+    )
+
+    material_output = nw.new_node(
+        Nodes.MaterialOutput,
+        input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement},
+        attrs={"is_active_output": True},
+    )
+
+
+def apply(obj, selection=None, **kwargs):
+    surface.add_material(
+        obj, shader_grained_metal, selection=selection, input_kwargs=kwargs
+    )

InternScenes/InternScenes_Real2Sim/materials/metal/hammered_metal.py

@@ -0,0 +1,153 @@
+# Copyright (C) 2024, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Yiming Zuo
+# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=82smQvoh0GE by Mix CG Arts
+
+from numpy.random import uniform
+
+from infinigen.core import surface
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+from infinigen.core.util.random import log_uniform
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_hammered_metal", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_hammered_metal(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)),
+            ("NodeSocketFloat", "Scale", 0.0000),
+            ("NodeSocketFloat", "Seed", 0.0000),
+        ],
+    )
+
+    principled_bsdf = nw.new_node(
+        Nodes.PrincipledBSDF,
+        input_kwargs={
+            "Base Color": group_input.outputs["Base Color"],
+            "Metallic": 1.0000,
+            "Specular": 0.0000,
+            "Roughness": 0.1000,
+        },
+    )
+
+    texture_coordinate = nw.new_node(Nodes.TextureCoord)
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 20.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+            "Roughness": 0.4000,
+            "Distortion": 0.2000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: 0.0100,
+            6: texture_coordinate.outputs["Object"],
+            7: noise_texture.outputs["Color"],
+        },
+        attrs={"clamp_factor": False, "data_type": "RGBA"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 300.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    voronoi_texture_1 = nw.new_node(
+        Nodes.VoronoiTexture,
+        input_kwargs={
+            "Vector": mix.outputs[2],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply_1,
+            "Smoothness": 0.2000,
+        },
+        attrs={"voronoi_dimensions": "4D", "feature": "SMOOTH_F1"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: voronoi_texture_1.outputs["Distance"],
+            1: group_input.outputs["Scale"],
+        },
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    power = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_2, 1: 2.5000},
+        attrs={"operation": "POWER"},
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: power, 1: log_uniform(0.001, 0.003)},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "BSDF": principled_bsdf,
+            "Displacement": multiply_3,
+            "tmp_viewer": voronoi_texture_1.outputs["Color"],
+        },
+        attrs={"is_active_output": True},
+    )
+
+
+def shader_hammered_metal(
+    nw: NodeWrangler, scale=None, base_color=None, seed=None, **kwargs
+):
+    # Code generated using version 2.6.4 of the node_transpiler
+    if seed is None:
+        seed = uniform(-1000.0, 1000.0)
+    if base_color is None:
+        from infinigen.assets.materials.metal import sample_metal_color
+
+        base_color = sample_metal_color(**kwargs)
+    if scale is None:
+        scale = log_uniform(0.8, 1.2)
+
+    group = nw.new_node(
+        nodegroup_hammered_metal().name,
+        input_kwargs={"Base Color": base_color, "Scale": scale, "Seed": seed},
+    )
+
+    displacement = nw.new_node(
+        "ShaderNodeDisplacement",
+        input_kwargs={"Height": group.outputs["Displacement"], "Midlevel": 0.0000},
+    )
+
+    material_output = nw.new_node(
+        Nodes.MaterialOutput,
+        input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement},
+        attrs={"is_active_output": True},
+    )
+
+
+def apply(obj, selection=None, **kwargs):
+    surface.add_material(
+        obj, shader_hammered_metal, selection=selection, input_kwargs=kwargs
+    )

InternScenes/InternScenes_Real2Sim/materials/stone_and_concrete/concrete.py

@@ -0,0 +1,486 @@
+# Copyright (C) 2024, Princeton University.
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory of this source tree.
+
+# Authors: Yiming Zuo
+# Acknowledgement: This file draws inspiration https://www.youtube.com/watch?v=XDqRa0ExDqs by Ryan King Art
+
+
+from numpy.random import uniform
+
+from infinigen.assets.materials import common
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+from infinigen.core.util.color import color_category
+
+
+@node_utils.to_nodegroup("nodegroup_crack", singleton=False, type="ShaderNodeTree")
+def nodegroup_crack(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketFloat", "Seed", 0.0000),
+            ("NodeSocketFloat", "Amount", 1.0000),
+            ("NodeSocketFloat", "Scale", 0.0000),
+            ("NodeSocketFloatFactor", "Snake Crack", 0.3000),
+        ],
+    )
+
+    texture_coordinate_1 = nw.new_node(Nodes.TextureCoord)
+
+    musgrave_texture_2 = nw.new_node(
+        Nodes.MusgraveTexture,
+        input_kwargs={
+            "Vector": texture_coordinate_1.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": group_input.outputs["Scale"],
+            "Detail": 15.0000,
+            "Dimension": 0.2000,
+        },
+        attrs={"musgrave_dimensions": "4D"},
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture_2 = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate_1.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply,
+            "Detail": 15.0000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    voronoi_texture = nw.new_node(
+        Nodes.VoronoiTexture,
+        input_kwargs={"Vector": noise_texture_2.outputs["Fac"], "Scale": 1.2000},
+        attrs={"feature": "DISTANCE_TO_EDGE"},
+    )
+
+    map_range_4 = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={
+            "Value": voronoi_texture.outputs["Distance"],
+            2: 0.0200,
+            3: 2.0000,
+            4: 0.0000,
+        },
+    )
+
+    mix_7 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Snake Crack"],
+            6: musgrave_texture_2,
+            7: map_range_4.outputs["Result"],
+        },
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 0.6000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    musgrave_texture_3 = nw.new_node(
+        Nodes.MusgraveTexture,
+        input_kwargs={
+            "Vector": texture_coordinate_1.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply_1,
+            "Detail": 15.0000,
+            "Dimension": 1.0000,
+        },
+        attrs={"musgrave_dimensions": "4D"},
+    )
+
+    map_range_2 = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={"Value": group_input.outputs["Amount"], 3: 1.0000, 4: -0.5000},
+    )
+
+    add = nw.new_node(
+        Nodes.Math, input_kwargs={0: map_range_2.outputs["Result"], 1: 0.1000}
+    )
+
+    map_range_1 = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={
+            "Value": musgrave_texture_3,
+            1: map_range_2.outputs["Result"],
+            2: add,
+        },
+    )
+
+    mix_4 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_7.outputs[2], 7: map_range_1.outputs["Result"]},
+        attrs={"blend_type": "DARKEN", "data_type": "RGBA"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Scale"], 1: 0.3000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    musgrave_texture_4 = nw.new_node(
+        Nodes.MusgraveTexture,
+        input_kwargs={
+            "Vector": texture_coordinate_1.outputs["Object"],
+            "W": group_input.outputs["Seed"],
+            "Scale": multiply_2,
+            "Detail": 15.0000,
+            "Dimension": 1.0000,
+        },
+        attrs={"musgrave_dimensions": "4D"},
+    )
+
+    add_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: map_range_2.outputs["Result"], 1: 0.1000}
+    )
+
+    map_range = nw.new_node(
+        Nodes.MapRange,
+        input_kwargs={
+            "Value": musgrave_texture_4,
+            1: map_range_2.outputs["Result"],
+            2: add_1,
+        },
+    )
+
+    mix_5 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: map_range.outputs["Result"]},
+        attrs={"blend_type": "DARKEN", "data_type": "RGBA"},
+    )
+
+    color_ramp = nw.new_node(Nodes.ColorRamp, input_kwargs={"Fac": mix_5.outputs[2]})
+    color_ramp.color_ramp.elements[0].position = 0.0000
+    color_ramp.color_ramp.elements[0].color = [0.0000, 0.0000, 0.0000, 1.0000]
+    color_ramp.color_ramp.elements[1].position = 1.0000
+    color_ramp.color_ramp.elements[1].color = [1.0000, 1.0000, 1.0000, 1.0000]
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"Color": color_ramp.outputs["Color"]},
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup("nodegroup_concrete", singleton=False, type="ShaderNodeTree")
+def nodegroup_concrete(nw: NodeWrangler):
+    # Code generated using version 2.6.4 of the node_transpiler
+
+    group_input_1 = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketColor", "Base Color", (0.8000, 0.8000, 0.8000, 1.0000)),
+            ("NodeSocketFloat", "Scale", 0.0000),
+            ("NodeSocketFloat", "Seed", 0.0000),
+            ("NodeSocketFloat", "Roughness", 0.0000),
+            ("NodeSocketFloat", "Crack Amount", 0.0000),
+            ("NodeSocketFloat", "Crack Scale", 0.0000),
+            ("NodeSocketFloatFactor", "Snake Crack", 0.3000),
+        ],
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Scale"], 1: 10.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply, 1: group_input_1.outputs["Crack Scale"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group = nw.new_node(
+        nodegroup_crack().name,
+        input_kwargs={
+            "Seed": group_input_1.outputs["Seed"],
+            "Amount": group_input_1.outputs["Crack Amount"],
+            "Scale": multiply_1,
+            "Snake Crack": group_input_1.outputs["Snake Crack"],
+        },
+    )
+
+    map_range_3 = nw.new_node(Nodes.MapRange, input_kwargs={"Value": group})
+
+    texture_coordinate = nw.new_node(Nodes.TextureCoord)
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Scale"], 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture_1 = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input_1.outputs["Seed"],
+            "Scale": multiply_2,
+            "Detail": 15.0000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Scale"], 1: 5.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    musgrave_texture_1 = nw.new_node(
+        Nodes.MusgraveTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input_1.outputs["Seed"],
+            "Scale": multiply_3,
+            "Detail": 15.0000,
+            "Dimension": 1.0000,
+            "Lacunarity": 3.0000,
+        },
+        attrs={"musgrave_dimensions": "4D"},
+    )
+
+    mix_2 = nw.new_node(
+        Nodes.Mix, input_kwargs={6: musgrave_texture_1}, attrs={"data_type": "RGBA"}
+    )
+
+    hue_saturation_value_1 = nw.new_node(
+        "ShaderNodeHueSaturation",
+        input_kwargs={"Value": 0.6000, "Color": group_input_1.outputs["Base Color"]},
+    )
+
+    multiply_4 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Scale"], 1: 20.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    noise_texture = nw.new_node(
+        Nodes.NoiseTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input_1.outputs["Seed"],
+            "Scale": multiply_4,
+            "Detail": 15.0000,
+            "Distortion": 0.2000,
+        },
+        attrs={"noise_dimensions": "4D"},
+    )
+
+    multiply_5 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Scale"], 1: 20.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    musgrave_texture = nw.new_node(
+        Nodes.MusgraveTexture,
+        input_kwargs={
+            "Vector": texture_coordinate.outputs["Object"],
+            "W": group_input_1.outputs["Seed"],
+            "Scale": multiply_5,
+            "Detail": 15.0000,
+            "Dimension": 0.2000,
+        },
+        attrs={"musgrave_dimensions": "4D"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={6: noise_texture.outputs["Fac"], 7: musgrave_texture},
+        attrs={"data_type": "RGBA"},
+    )
+
+    hue_saturation_value = nw.new_node(
+        "ShaderNodeHueSaturation",
+        input_kwargs={"Value": 1.4000, "Color": group_input_1.outputs["Base Color"]},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: mix.outputs[2],
+            6: group_input_1.outputs["Base Color"],
+            7: hue_saturation_value,
+        },
+        attrs={"data_type": "RGBA"},
+    )
+
+    mix_3 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: mix_2.outputs[2],
+            6: hue_saturation_value_1,
+            7: mix_1.outputs[2],
+        },
+        attrs={"data_type": "RGBA"},
+    )
+
+    hue_saturation_value_2 = nw.new_node(
+        "ShaderNodeHueSaturation",
+        input_kwargs={
+            "Value": noise_texture_1.outputs["Fac"],
+            "Fac": 0.2000,
+            "Color": mix_3.outputs[2],
+        },
+    )
+
+    hue_saturation_value_3 = nw.new_node(
+        "ShaderNodeHueSaturation",
+        input_kwargs={"Value": 0.2000, "Color": group_input_1.outputs["Base Color"]},
+    )
+
+    mix_6 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: map_range_3.outputs["Result"],
+            6: hue_saturation_value_2,
+            7: hue_saturation_value_3,
+        },
+        attrs={"data_type": "RGBA"},
+    )
+
+    principled_bsdf = nw.new_node(
+        Nodes.PrincipledBSDF,
+        input_kwargs={
+            "Base Color": mix_6.outputs[2],
+            "Roughness": group_input_1.outputs["Roughness"],
+        },
+    )
+
+    multiply_6 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Crack Amount"], 1: 0.6000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_7 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_1, 1: 5.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_crack().name,
+        input_kwargs={
+            "Seed": group_input_1.outputs["Seed"],
+            "Amount": multiply_6,
+            "Scale": multiply_7,
+        },
+    )
+
+    multiply_8 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input_1.outputs["Roughness"], 1: 1.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_9 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_1, 1: multiply_8},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_10 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_8, 1: group},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_9, 1: multiply_10})
+
+    value = nw.new_node(Nodes.Value)
+    value.outputs[0].default_value = 0.3000
+
+    multiply_11 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: value, 1: group_input_1.outputs["Roughness"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_12 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_11, 1: mix_1.outputs[2]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add_1 = nw.new_node(Nodes.Math, input_kwargs={0: add, 1: multiply_12})
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"BSDF": principled_bsdf, "Displacement": add_1},
+        attrs={"is_active_output": True},
+    )
+
+
+def shader_concrete(
+    nw: NodeWrangler,
+    scale=1.0,
+    base_color=None,
+    seed=None,
+    roughness=None,
+    crack_amount=None,
+    crack_scale=None,
+    snake_crack=None,
+    **kwargs,
+):
+    # Code generated using version 2.6.4 of the node_transpiler
+    if seed is None:
+        seed = uniform(-1000.0, 1000.0)
+    if roughness is None:
+        roughness = uniform(0.5, 1.0)
+    if crack_amount is None:
+        crack_amount = uniform(0.2, 0.8)
+    if crack_scale is None:
+        crack_scale = uniform(1.0, 3.0)
+    if snake_crack is None:
+        snake_crack = uniform(0.0, 1.0)
+    if base_color is None:
+        base_color = color_category("concrete")
+
+    group = nw.new_node(
+        nodegroup_concrete().name,
+        input_kwargs={
+            "Base Color": base_color,
+            "Scale": scale,
+            "Seed": seed,
+            "Roughness": roughness,
+            "Crack Amount": crack_amount,
+            "Crack Scale": crack_scale,
+            "Snake Crack": snake_crack,
+        },
+    )
+
+    displacement_1 = nw.new_node(
+        "ShaderNodeDisplacement",
+        input_kwargs={
+            "Height": group.outputs["Displacement"],
+            "Midlevel": 0.0000,
+            "Scale": 0.0500,
+        },
+    )
+
+    material_output = nw.new_node(
+        Nodes.MaterialOutput,
+        input_kwargs={"Surface": group.outputs["BSDF"], "Displacement": displacement_1},
+        attrs={"is_active_output": True},
+    )
+
+
+def apply(obj, selection=None, **kwargs):
+    common.apply(obj, shader_concrete, selection=selection, **kwargs)

InternScenes/InternScenes_Real2Sim/materials/tiles/cheveron.py

@@ -0,0 +1,209 @@
+# Copyright (C) 2024, Princeton University.
+
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory
+# of this source tree.
+
+# Authors: Yiming Zuo
+
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+from .utils import nodegroup_scalar_positive_modulo
+
+
+@node_utils.to_nodegroup("nodegroup_cheveron", singleton=False, type="ShaderNodeTree")
+def nodegroup_cheveron(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Subtiles Number", 1.0000),
+            ("NodeSocketFloat", "Aspect Ratio", 5.0000),
+            ("NodeSocketFloatFactor", "border", 0.1000),
+            ("NodeSocketFloatFactor", "Flatness", 0.9000),
+        ],
+    )
+
+    reroute_1 = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Aspect Ratio"]}
+    )
+
+    brick_width = nw.new_node(Nodes.Value, label="Brick Width")
+    brick_width.outputs[0].default_value = 1.0000
+
+    combine_xyz = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": reroute_1, "Y": brick_width}
+    )
+
+    scale = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz, "Scale": 0.5000},
+        attrs={"operation": "SCALE"},
+    )
+
+    reroute = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": scale.outputs["Vector"]}
+    )
+
+    separate_xyz = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]}
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1},
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_1, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: reroute_1, 1: multiply},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    snap = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: reroute_1, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_2 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap, 1: multiply_1}
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math, input_kwargs={0: group_2}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: subtract, 1: greater_than},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: group_1})
+
+    rot_amount = nw.new_node(Nodes.Value, label="rot amount")
+    rot_amount.outputs[0].default_value = 1.0000
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add, 1: rot_amount},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: separate_xyz.outputs["Y"], 1: multiply_3}
+    )
+
+    group = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: add_1, 1: brick_width}
+    )
+
+    combine_xyz_1 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group_1, "Y": group}
+    )
+
+    subtract_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_1, 1: reroute},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    absolute = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: subtract_1.outputs["Vector"]},
+        attrs={"operation": "ABSOLUTE"},
+    )
+
+    subtract_2 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: reroute, 1: absolute.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    separate_xyz_1 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": subtract_2.outputs["Vector"]}
+    )
+
+    smooth_min = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_1.outputs["X"],
+            1: separate_xyz_1.outputs["Y"],
+            2: 0.1000,
+        },
+        attrs={"operation": "SMOOTH_MIN"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: group_input.outputs["border"], 6: smooth_min},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    snap_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: add_1, 1: brick_width}, attrs={"operation": "SNAP"}
+    )
+
+    snap_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: reroute_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz_3 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2}
+    )
+
+    white_noise_texture = nw.new_node(
+        Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_3}
+    )
+
+    snap_3 = nw.new_node(
+        Nodes.Math, input_kwargs={0: add_1, 1: brick_width}, attrs={"operation": "SNAP"}
+    )
+
+    multiply_4 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: brick_width, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_3 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_3, 1: multiply_4}
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "Result": mix_1.outputs[2],
+            "Tile Color": white_noise_texture.outputs["Color"],
+            "Tile Type 1": greater_than,
+            "Tile Type 2": group_3,
+        },
+        attrs={"is_active_output": True},
+    )

InternScenes/InternScenes_Real2Sim/materials/tiles/diamond.py

@@ -0,0 +1,441 @@
+# Copyright (C) 2024, Princeton University.
+
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory
+# of this source tree.
+
+# Authors: Yiming Zuo
+
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+from .utils import nodegroup_scalar_positive_modulo
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_diamond_single", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_diamond_single(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    value_1 = nw.new_node(Nodes.Value)
+    value_1.outputs[0].default_value = 0.7070
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Width", 0.0000),
+        ],
+    )
+
+    separate_xyz = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]}
+    )
+
+    reroute = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Width"]}
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: reroute, 1: 1.5000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    snap = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["Y"], 1: multiply},
+        attrs={"operation": "SNAP"},
+    )
+
+    divide = nw.new_node(
+        Nodes.Math, input_kwargs={0: snap, 1: multiply}, attrs={"operation": "DIVIDE"}
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Width"], 1: 0.8660},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: divide, 1: multiply_1},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(
+        Nodes.Math, input_kwargs={0: separate_xyz.outputs["X"], 1: multiply_2}
+    )
+
+    combine_xyz_2 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": add, "Y": separate_xyz.outputs["Y"]}
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: reroute, 1: 1.7321},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    combine_xyz = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": multiply_3, "Y": reroute}
+    )
+
+    separate_xyz_1 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz}
+    )
+
+    snap_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add, 1: separate_xyz_1.outputs["X"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz_1 = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap})
+
+    subtract = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_2, 1: combine_xyz_1},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    scale = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz, "Scale": 0.5000},
+        attrs={"operation": "SCALE"},
+    )
+
+    subtract_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: subtract.outputs["Vector"], 1: scale.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    value_3 = nw.new_node(Nodes.Value)
+    value_3.outputs[0].default_value = 1.0000
+
+    divide_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: value_3, 1: scale.outputs["Vector"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    multiply_4 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: subtract_1.outputs["Vector"], 1: divide_1.outputs["Vector"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    vector_rotate = nw.new_node(
+        Nodes.VectorRotate,
+        input_kwargs={"Vector": multiply_4.outputs["Vector"], "Angle": 0.7854},
+    )
+
+    absolute = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: vector_rotate},
+        attrs={"operation": "ABSOLUTE"},
+    )
+
+    subtract_2 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: value_1, 1: absolute.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    white_noise_texture = nw.new_node(
+        Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_1}
+    )
+
+    divide_2 = nw.new_node(
+        Nodes.Math, input_kwargs={0: snap, 1: multiply}, attrs={"operation": "DIVIDE"}
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide_2, 1: 2.0000}
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math, input_kwargs={0: group_1}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    divide_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: snap_1, 1: separate_xyz_1.outputs["X"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    group = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide_3, 1: 2.0000}
+    )
+
+    greater_than_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: group}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    multiply_5 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: greater_than, 1: greater_than_1},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "UV": subtract_2.outputs["Vector"],
+            "Color": white_noise_texture.outputs["Color"],
+            "Value": multiply_5,
+        },
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup("nodegroup_diamond", singleton=False, type="ShaderNodeTree")
+def nodegroup_diamond(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Subtiles Number", 1.0000),
+            ("NodeSocketFloat", "Aspect Ratio", 5.0000),
+            ("NodeSocketFloatFactor", "border", 0.1000),
+            ("NodeSocketFloatFactor", "Flatness", 0.9000),
+        ],
+    )
+
+    reroute_1 = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Flatness"]}
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["border"], 1: 1.5000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply})
+
+    value = nw.new_node(Nodes.Value)
+    value.outputs[0].default_value = 0.5000
+
+    mapping = nw.new_node(
+        Nodes.Mapping,
+        input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value},
+    )
+
+    value_1 = nw.new_node(Nodes.Value)
+    value_1.outputs[0].default_value = 1.0000
+
+    group = nw.new_node(
+        nodegroup_diamond_single().name,
+        input_kwargs={"Coordinate": mapping, "Width": value_1},
+    )
+
+    separate_xyz_3 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group.outputs["UV"]}
+    )
+
+    value_3 = nw.new_node(Nodes.Value)
+    value_3.outputs[0].default_value = 0.0000
+
+    smooth_min = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_3.outputs["X"],
+            1: separate_xyz_3.outputs["Y"],
+            2: value_3,
+        },
+        attrs={"operation": "SMOOTH_MIN"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: smooth_min},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: reroute_1,
+            6: mix.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: value_1}, attrs={"operation": "MULTIPLY"}
+    )
+
+    combine_xyz = nw.new_node(Nodes.CombineXYZ, input_kwargs={"Y": multiply_1})
+
+    vector_rotate = nw.new_node(
+        Nodes.VectorRotate,
+        input_kwargs={"Vector": mapping, "Center": combine_xyz, "Angle": -2.0944},
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_diamond_single().name,
+        input_kwargs={"Coordinate": vector_rotate, "Width": value_1},
+    )
+
+    separate_xyz_4 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_1.outputs["UV"]}
+    )
+
+    smooth_min_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_4.outputs["X"],
+            1: separate_xyz_4.outputs["Y"],
+            2: value_3,
+        },
+        attrs={"operation": "SMOOTH_MIN"},
+    )
+
+    mix_2 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: smooth_min_1},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_3 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: reroute_1,
+            6: mix_2.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    mix_4 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: mix_3.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    vector_rotate_1 = nw.new_node(
+        Nodes.VectorRotate,
+        input_kwargs={"Vector": mapping, "Center": combine_xyz, "Angle": 2.0944},
+    )
+
+    group_2 = nw.new_node(
+        nodegroup_diamond_single().name,
+        input_kwargs={"Coordinate": vector_rotate_1, "Width": value_1},
+    )
+
+    separate_xyz_5 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_2.outputs["UV"]}
+    )
+
+    smooth_min_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_5.outputs["X"],
+            1: separate_xyz_5.outputs["Y"],
+            2: value_3,
+        },
+        attrs={"operation": "SMOOTH_MIN"},
+    )
+
+    mix_5 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: smooth_min_2},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_6 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: reroute_1,
+            6: mix_5.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    mix_7 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: mix_6.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    mix_8 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: group.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_9 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: group_1.outputs["Color"], 7: mix_3.outputs[2]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_11 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_8.outputs[2], 7: mix_9.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    mix_10 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_6.outputs[2], 7: group_2.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_12 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_11.outputs[2], 7: mix_10.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_1.outputs[2], 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_6.outputs[2], 1: group_2.outputs["Value"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group.outputs["Value"], 1: mix_1.outputs[2]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_4 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_3.outputs[2], 1: group_1.outputs["Value"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_3, 1: multiply_4})
+
+    add_1 = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: add})
+
+    greater_than_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add_1, 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "Result": mix_7.outputs[2],
+            "Tile Color": mix_12.outputs[2],
+            "Tile Type 1": greater_than,
+            "Tile Type 2": greater_than_1,
+        },
+        attrs={"is_active_output": True},
+    )

InternScenes/InternScenes_Real2Sim/materials/tiles/herringbone.py

@@ -0,0 +1,350 @@
+# Copyright (C) 2024, Princeton University.
+
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory
+# of this source tree.
+
+# Authors: Yiming Zuo
+
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+from .utils import nodegroup_scalar_positive_modulo
+
+
+@node_utils.to_nodegroup("nodegroup_mix", singleton=False, type="ShaderNodeTree")
+def nodegroup_mix(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketFloat", "Mask", 0.0000),
+            ("NodeSocketVector", "Vector 1", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketVector", "Vector 2", (0.0000, 0.0000, 0.0000)),
+        ],
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: 1.0000, 1: group_input.outputs["Mask"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    multiply = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: group_input.outputs["Vector 2"], 1: subtract},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={
+            0: group_input.outputs["Vector 1"],
+            1: group_input.outputs["Mask"],
+        },
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: multiply.outputs["Vector"], 1: multiply_1.outputs["Vector"]},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"Vector": add.outputs["Vector"]},
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_herringbone", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_herringbone(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Subtiles Number", 1.0000),
+            ("NodeSocketFloat", "Aspect Ratio", 5.0000),
+            ("NodeSocketFloatFactor", "border", 0.1000),
+            ("NodeSocketFloatFactor", "Flatness", 0.9000),
+        ],
+    )
+
+    reroute_1 = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": group_input.outputs["Aspect Ratio"]}
+    )
+
+    brick_width = nw.new_node(Nodes.Value, label="Brick Width")
+    brick_width.outputs[0].default_value = 1.0000
+
+    combine_xyz = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": reroute_1, "Y": brick_width}
+    )
+
+    scale = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz, "Scale": 0.5000},
+        attrs={"operation": "SCALE"},
+    )
+
+    combine_xyz_3 = nw.new_node(
+        Nodes.CombineXYZ,
+        input_kwargs={
+            "X": 1.0000,
+            "Y": group_input.outputs["Subtiles Number"],
+            "Z": 1.0000,
+        },
+    )
+
+    divide = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: scale.outputs["Vector"], 1: combine_xyz_3},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    reroute = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": divide.outputs["Vector"]}
+    )
+
+    separate_xyz = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]}
+    )
+
+    snap = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["Y"], 1: brick_width},
+        attrs={"operation": "SNAP"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: snap},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    snap_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: subtract, 1: reroute_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: reroute_1, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_1, 1: multiply}
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math, input_kwargs={0: group_1}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    group = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: subtract, 1: reroute_1},
+    )
+
+    divide_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: brick_width, 1: group_input.outputs["Subtiles Number"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    group_3 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: separate_xyz.outputs["Y"], 1: divide_1},
+    )
+
+    combine_xyz_1 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group, "Y": group_3}
+    )
+
+    snap_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: brick_width},
+        attrs={"operation": "SNAP"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: snap_2, 1: brick_width},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_1, 1: brick_width})
+
+    subtract_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["Y"], 1: add},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    group_2 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: subtract_1, 1: reroute_1},
+    )
+
+    divide_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: brick_width, 1: group_input.outputs["Subtiles Number"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    group_4 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: divide_2},
+    )
+
+    combine_xyz_2 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group_2, "Y": group_4}
+    )
+
+    group_5 = nw.new_node(
+        nodegroup_mix().name,
+        input_kwargs={
+            "Mask": greater_than,
+            "Vector 1": combine_xyz_1,
+            "Vector 2": combine_xyz_2,
+        },
+    )
+
+    subtract_2 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: group_5, 1: reroute},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    absolute = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: subtract_2.outputs["Vector"]},
+        attrs={"operation": "ABSOLUTE"},
+    )
+
+    subtract_3 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: reroute, 1: absolute.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    separate_xyz_1 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": subtract_3.outputs["Vector"]}
+    )
+
+    smooth_min = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_1.outputs["X"],
+            1: separate_xyz_1.outputs["Y"],
+            2: 0.0000,
+        },
+        attrs={"operation": "SMOOTH_MIN"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: group_input.outputs["border"], 6: smooth_min},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    snap_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: subtract, 1: reroute_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    snap_4 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["Y"], 1: divide_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz_6 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": snap_3, "Y": snap_4}
+    )
+
+    value = nw.new_node(Nodes.Value)
+    value.outputs[0].default_value = 0.5000
+
+    add_1 = nw.new_node(Nodes.VectorMath, input_kwargs={0: combine_xyz_6, 1: value})
+
+    snap_5 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: subtract_1, 1: reroute_1},
+        attrs={"operation": "SNAP"},
+    )
+
+    snap_6 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz.outputs["X"], 1: divide_2},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz_5 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": snap_5, "Y": snap_6}
+    )
+
+    group_6 = nw.new_node(
+        nodegroup_mix().name,
+        input_kwargs={
+            "Mask": greater_than,
+            "Vector 1": add_1.outputs["Vector"],
+            "Vector 2": combine_xyz_5,
+        },
+    )
+
+    white_noise_texture_1 = nw.new_node(
+        Nodes.WhiteNoiseTexture, input_kwargs={"Vector": group_6}
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: divide_1, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_9 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_4, 1: multiply_2}
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: divide_2, 1: 2.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    group_7 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: snap_6, 1: multiply_3}
+    )
+
+    group_8 = nw.new_node(
+        nodegroup_mix().name,
+        input_kwargs={"Mask": greater_than, "Vector 1": group_9, "Vector 2": group_7},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "Result": mix_1.outputs[2],
+            "Tile Color": white_noise_texture_1.outputs["Color"],
+            "Tile Type 1": greater_than,
+            "Tile Type 2": group_8,
+        },
+        attrs={"is_active_output": True},
+    )

InternScenes/InternScenes_Real2Sim/materials/tiles/hexagon.py

@@ -0,0 +1,424 @@
+# Copyright (C) 2024, Princeton University.
+
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory
+# of this source tree.
+
+# Authors: Yiming Zuo
+
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+from .utils import nodegroup_scalar_positive_modulo
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_distance_to_axis", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_distance_to_axis(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Vector", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketVector", "Axis", (0.0000, 0.0000, 0.0000)),
+        ],
+    )
+
+    length = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: group_input.outputs["Vector"]},
+        attrs={"operation": "LENGTH"},
+    )
+
+    power = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: length.outputs["Value"], 1: 2.0000},
+        attrs={"operation": "POWER"},
+    )
+
+    normalize = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: group_input.outputs["Axis"]},
+        attrs={"operation": "NORMALIZE"},
+    )
+
+    dot_product = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: group_input.outputs["Vector"], 1: normalize.outputs["Vector"]},
+        attrs={"operation": "DOT_PRODUCT"},
+    )
+
+    power_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: dot_product.outputs["Value"], 1: 2.0000},
+        attrs={"operation": "POWER"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math, input_kwargs={0: power, 1: power_1}, attrs={"operation": "SUBTRACT"}
+    )
+
+    sqrt = nw.new_node(
+        Nodes.Math, input_kwargs={0: subtract}, attrs={"operation": "SQRT"}
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={"Distance": sqrt},
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup("nodegroup_hex_single", singleton=False, type="ShaderNodeTree")
+def nodegroup_hex_single(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Size", 0.5000),
+        ],
+    )
+
+    separate_xyz_3 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]}
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Size"], 1: 1.0000},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Size"], 1: 1.7321},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    combine_xyz_2 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": multiply, "Y": multiply_1}
+    )
+
+    separate_xyz_4 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz_2}
+    )
+
+    snap = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math, input_kwargs={0: snap, 1: 0.5774}, attrs={"operation": "MULTIPLY"}
+    )
+
+    add = nw.new_node(
+        Nodes.Math, input_kwargs={0: multiply_2, 1: separate_xyz_3.outputs["X"]}
+    )
+
+    group_3 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]},
+    )
+
+    group_4 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+    )
+
+    combine_xyz_3 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group_3, "Y": group_4}
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_2, 1: (0.5000, 0.3333, 0.0000)},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_3, 1: multiply_3.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    reroute = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": subtract.outputs["Vector"]}
+    )
+
+    group = nw.new_node(
+        nodegroup_distance_to_axis().name,
+        input_kwargs={"Vector": reroute, "Axis": (0.0000, 1.0000, 0.0000)},
+    )
+
+    group_1 = nw.new_node(
+        nodegroup_distance_to_axis().name,
+        input_kwargs={"Vector": reroute, "Axis": (0.8660, -0.5000, 0.0000)},
+    )
+
+    group_2 = nw.new_node(
+        nodegroup_distance_to_axis().name,
+        input_kwargs={"Vector": reroute, "Axis": (-0.8660, -0.5000, 0.0000)},
+    )
+
+    combine_xyz_1 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group, "Y": group_1, "Z": group_2}
+    )
+
+    snap_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    snap_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2})
+
+    white_noise_texture = nw.new_node(
+        Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz}
+    )
+
+    divide = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: snap_2, 1: separate_xyz_4.outputs["X"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    group_5 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide, 1: 2.0000}
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math, input_kwargs={0: group_5}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "UV": combine_xyz_1,
+            "Color": white_noise_texture.outputs["Color"],
+            "Value": greater_than,
+        },
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup("nodegroup_hexagon", singleton=False, type="ShaderNodeTree")
+def nodegroup_hexagon(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Subtiles Number", 1.0000),
+            ("NodeSocketFloat", "Aspect Ratio", 5.0000),
+            ("NodeSocketFloatFactor", "border", 0.1000),
+            ("NodeSocketFloatFactor", "Flatness", 0.9000),
+        ],
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["border"], 1: 0.8660},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply})
+
+    size = nw.new_node(Nodes.Value, label="Size")
+    size.outputs[0].default_value = 1.0000
+
+    multiply_1 = nw.new_node(
+        Nodes.Math, input_kwargs={0: size}, attrs={"operation": "MULTIPLY"}
+    )
+
+    value = nw.new_node(Nodes.Value)
+    value.outputs[0].default_value = 0.5000
+
+    mapping = nw.new_node(
+        Nodes.Mapping,
+        input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value},
+    )
+
+    group_5 = nw.new_node(
+        nodegroup_hex_single().name, input_kwargs={"Coordinate": mapping, "Size": size}
+    )
+
+    separate_xyz_5 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_5.outputs["UV"]}
+    )
+
+    value_3 = nw.new_node(Nodes.Value)
+    value_3.outputs[0].default_value = 0.0000
+
+    smooth_max = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_5.outputs["X"],
+            1: separate_xyz_5.outputs["Y"],
+            2: value_3,
+        },
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    smooth_max_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: smooth_max, 1: separate_xyz_5.outputs["Z"], 2: value_3},
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_1, 1: smooth_max_1},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    mix = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: subtract},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math, input_kwargs={0: size}, attrs={"operation": "MULTIPLY"}
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math, input_kwargs={0: size, 1: 0.8660}, attrs={"operation": "MULTIPLY"}
+    )
+
+    combine_xyz = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": multiply_2, "Y": multiply_3}
+    )
+
+    multiply_4 = nw.new_node(
+        Nodes.Math, input_kwargs={0: size, 1: 99.0000}, attrs={"operation": "MULTIPLY"}
+    )
+
+    combine_xyz_1 = nw.new_node(Nodes.CombineXYZ, input_kwargs={"X": multiply_4})
+
+    add = nw.new_node(Nodes.VectorMath, input_kwargs={0: combine_xyz, 1: combine_xyz_1})
+
+    add_1 = nw.new_node(
+        Nodes.VectorMath, input_kwargs={0: mapping, 1: add.outputs["Vector"]}
+    )
+
+    group_6 = nw.new_node(
+        nodegroup_hex_single().name,
+        input_kwargs={"Coordinate": add_1.outputs["Vector"], "Size": size},
+    )
+
+    separate_xyz_6 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_6.outputs["UV"]}
+    )
+
+    smooth_max_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_6.outputs["X"],
+            1: separate_xyz_6.outputs["Y"],
+            2: value_3,
+        },
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    smooth_max_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: smooth_max_2, 1: separate_xyz_6.outputs["Z"], 2: value_3},
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    subtract_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_1, 1: smooth_max_3},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    mix_3 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: subtract_1},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_2 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix_3.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    mix_4 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: mix_2.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    mix_5 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_1.outputs[2], 7: group_5.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_6 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_2.outputs[2], 7: group_6.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_7 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_5.outputs[2], 7: mix_6.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_1.outputs[2], 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    multiply_5 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_1.outputs[2], 1: group_5.outputs["Value"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    greater_than_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_5, 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "Result": mix_4.outputs[2],
+            "Tile Color": mix_7.outputs[2],
+            "Tile Type 1": greater_than,
+            "Tile Type 2": greater_than_1,
+        },
+        attrs={"is_active_output": True},
+    )

InternScenes/InternScenes_Real2Sim/materials/tiles/triangle.py

@@ -0,0 +1,379 @@
+# Copyright (C) 2024, Princeton University.
+
+# This source code is licensed under the BSD 3-Clause license found in the LICENSE file in the root directory
+# of this source tree.
+
+# Authors: Yiming Zuo
+
+from infinigen.core.nodes import node_utils
+from infinigen.core.nodes.node_wrangler import Nodes, NodeWrangler
+
+from .utils import nodegroup_scalar_positive_modulo
+
+
+@node_utils.to_nodegroup(
+    "nodegroup_triangle_single", singleton=False, type="ShaderNodeTree"
+)
+def nodegroup_triangle_single(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    value_2 = nw.new_node(Nodes.Value)
+    value_2.outputs[0].default_value = 0.0000
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Size", 0.5000),
+        ],
+    )
+
+    separate_xyz_3 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_input.outputs["Coordinate"]}
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Size"], 1: 0.8660},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["Size"], 1: 0.7500},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    combine_xyz_2 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": multiply, "Y": multiply_1}
+    )
+
+    separate_xyz_4 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": combine_xyz_2}
+    )
+
+    snap = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math, input_kwargs={0: snap, 1: 0.5774}, attrs={"operation": "MULTIPLY"}
+    )
+
+    add = nw.new_node(
+        Nodes.Math, input_kwargs={0: multiply_2, 1: separate_xyz_3.outputs["X"]}
+    )
+
+    group_3 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]},
+    )
+
+    group_4 = nw.new_node(
+        nodegroup_scalar_positive_modulo().name,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+    )
+
+    combine_xyz_3 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": group_3, "Y": group_4}
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_2, 1: (0.5000, 0.3333, 0.0000)},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: combine_xyz_3, 1: multiply_3.outputs["Vector"]},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    reroute = nw.new_node(
+        Nodes.Reroute, input_kwargs={"Input": subtract.outputs["Vector"]}
+    )
+
+    dot_product = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: reroute, 1: (0.0000, 1.0000, 0.0000)},
+        attrs={"operation": "DOT_PRODUCT"},
+    )
+
+    dot_product_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: reroute, 1: (0.8660, -0.5000, 0.0000)},
+        attrs={"operation": "DOT_PRODUCT"},
+    )
+
+    dot_product_2 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: reroute, 1: (-0.8660, -0.5000, 0.0000)},
+        attrs={"operation": "DOT_PRODUCT"},
+    )
+
+    combine_xyz = nw.new_node(
+        Nodes.CombineXYZ,
+        input_kwargs={
+            "X": dot_product.outputs["Value"],
+            "Y": dot_product_1.outputs["Value"],
+            "Z": dot_product_2.outputs["Value"],
+        },
+    )
+
+    subtract_1 = nw.new_node(
+        Nodes.VectorMath,
+        input_kwargs={0: value_2, 1: combine_xyz},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    snap_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: separate_xyz_3.outputs["Y"], 1: separate_xyz_4.outputs["Y"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    snap_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add, 1: separate_xyz_4.outputs["X"]},
+        attrs={"operation": "SNAP"},
+    )
+
+    combine_xyz_1 = nw.new_node(
+        Nodes.CombineXYZ, input_kwargs={"X": snap_1, "Y": snap_2}
+    )
+
+    white_noise_texture = nw.new_node(
+        Nodes.WhiteNoiseTexture, input_kwargs={"Vector": combine_xyz_1}
+    )
+
+    divide = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: snap_2, 1: separate_xyz_4.outputs["X"]},
+        attrs={"operation": "DIVIDE"},
+    )
+
+    group = nw.new_node(
+        nodegroup_scalar_positive_modulo().name, input_kwargs={0: divide, 1: 2.0000}
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math, input_kwargs={0: group}, attrs={"operation": "GREATER_THAN"}
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "UV": subtract_1.outputs["Vector"],
+            "Color": white_noise_texture.outputs["Color"],
+            "Value": greater_than,
+        },
+        attrs={"is_active_output": True},
+    )
+
+
+@node_utils.to_nodegroup("nodegroup_triangle", singleton=False, type="ShaderNodeTree")
+def nodegroup_triangle(nw: NodeWrangler):
+    # Code generated using version 2.6.5 of the node_transpiler
+
+    group_input = nw.new_node(
+        Nodes.GroupInput,
+        expose_input=[
+            ("NodeSocketVector", "Coordinate", (0.0000, 0.0000, 0.0000)),
+            ("NodeSocketFloat", "Subtiles Number", 1.0000),
+            ("NodeSocketFloat", "Aspect Ratio", 5.0000),
+            ("NodeSocketFloatFactor", "border", 0.1000),
+            ("NodeSocketFloatFactor", "Flatness", 0.9000),
+        ],
+    )
+
+    multiply = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: group_input.outputs["border"], 1: 0.5774},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    reroute = nw.new_node(Nodes.Reroute, input_kwargs={"Input": multiply})
+
+    value_6 = nw.new_node(Nodes.Value)
+    value_6.outputs[0].default_value = 1.0000
+
+    multiply_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: value_6, 1: 0.2500},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    value = nw.new_node(Nodes.Value)
+    value.outputs[0].default_value = 0.4330
+
+    mapping_1 = nw.new_node(
+        Nodes.Mapping,
+        input_kwargs={"Vector": group_input.outputs["Coordinate"], "Scale": value},
+    )
+
+    reroute_1 = nw.new_node(Nodes.Reroute, input_kwargs={"Input": mapping_1})
+
+    group_8 = nw.new_node(
+        nodegroup_triangle_single().name,
+        input_kwargs={"Coordinate": reroute_1, "Size": value_6},
+    )
+
+    separate_xyz_5 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_8.outputs["UV"]}
+    )
+
+    value_4 = nw.new_node(Nodes.Value)
+    value_4.outputs[0].default_value = 0.0000
+
+    smooth_max = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_5.outputs["X"],
+            1: separate_xyz_5.outputs["Y"],
+            2: value_4,
+        },
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    smooth_max_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: smooth_max, 1: separate_xyz_5.outputs["Z"], 2: value_4},
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    subtract = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_1, 1: smooth_max_1},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    mix_1 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: subtract},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_4 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix_1.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    vector_rotate = nw.new_node(
+        Nodes.VectorRotate, input_kwargs={"Vector": reroute_1, "Angle": 3.1416}
+    )
+
+    group_7 = nw.new_node(
+        nodegroup_triangle_single().name,
+        input_kwargs={"Coordinate": vector_rotate, "Size": value_6},
+    )
+
+    separate_xyz_6 = nw.new_node(
+        Nodes.SeparateXYZ, input_kwargs={"Vector": group_7.outputs["UV"]}
+    )
+
+    smooth_max_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={
+            0: separate_xyz_6.outputs["X"],
+            1: separate_xyz_6.outputs["Y"],
+            2: value_4,
+        },
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    smooth_max_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: smooth_max_2, 1: separate_xyz_6.outputs["Z"], 2: value_4},
+        attrs={"operation": "SMOOTH_MAX"},
+    )
+
+    subtract_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: multiply_1, 1: smooth_max_3},
+        attrs={"operation": "SUBTRACT"},
+    )
+
+    mix_3 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: reroute, 6: subtract_1},
+        attrs={"blend_type": "BURN", "data_type": "RGBA"},
+    )
+
+    mix_2 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={
+            0: group_input.outputs["Flatness"],
+            6: mix_3.outputs[2],
+            7: (1.0000, 1.0000, 1.0000, 1.0000),
+        },
+        attrs={"blend_type": "DODGE", "data_type": "RGBA"},
+    )
+
+    mix_5 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: mix_2.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    mix_7 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_2.outputs[2], 7: group_7.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_6 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_4.outputs[2], 7: group_8.outputs["Color"]},
+        attrs={"blend_type": "MULTIPLY", "data_type": "RGBA"},
+    )
+
+    mix_8 = nw.new_node(
+        Nodes.Mix,
+        input_kwargs={0: 1.0000, 6: mix_7.outputs[2], 7: mix_6.outputs[2]},
+        attrs={"blend_type": "ADD", "data_type": "RGBA"},
+    )
+
+    greater_than = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_4.outputs[2], 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    multiply_2 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_4.outputs[2], 1: group_8.outputs["Value"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    multiply_3 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: mix_2.outputs[2], 1: group_7.outputs["Value"]},
+        attrs={"operation": "MULTIPLY"},
+    )
+
+    add = nw.new_node(Nodes.Math, input_kwargs={0: multiply_2, 1: multiply_3})
+
+    greater_than_1 = nw.new_node(
+        Nodes.Math,
+        input_kwargs={0: add, 1: 0.0000},
+        attrs={"operation": "GREATER_THAN"},
+    )
+
+    group_output = nw.new_node(
+        Nodes.GroupOutput,
+        input_kwargs={
+            "Result": mix_5.outputs[2],
+            "Tile Color": mix_8.outputs[2],
+            "Tile Type 1": greater_than,
+            "Tile Type 2": greater_than_1,
+        },
+        attrs={"is_active_output": True},
+    )