Scenes (.scenes)

Rooms (.scenes.room)

room

class infinigen2.scenes.room.room.LivingroomResult(...)

Bases: NamedTuple

all_objects: list

lights: list

colliders: CollisionSet

floor: pf.MeshObject

dimensions: pf.Vector | None

infinigen2.scenes.room.room.livingroom_rand(...) → LivingroomResult

Example renders

infinigen2 livingroom_rand render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 livingroom_rand render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 livingroom_rand render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 livingroom_rand render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 livingroom_rand render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 livingroom_rand render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• dimensions (pf.Vector | None) -- (default: None)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

room_furniture

class infinigen2.scenes.room.room_furniture.ArrangementResult(...)

Bases: NamedTuple

sofas: list[MeshResult]

dining_tables: list[MeshResult]

rugs: list[pf.MeshObject]

center_coffee_tables: list[MeshResult]

class infinigen2.scenes.room.room_furniture.MeshResult(*args, **kwargs)

Bases: Protocol

property mesh: pf.MeshObject

class infinigen2.scenes.room.room_furniture.RoomFurnitureResult(...)

Bases: NamedTuple

furniture: list[pf.MeshObject]

storage_surfaces: list[pf.MeshObject]

lights: list[LightObject]

colliders: CollisionSet

floor: pf.MeshObject

storage_objects: list[pf.MeshObject]

coffee_tables: list[pf.MeshObject]

side_tables: list[pf.MeshObject]

diningtable_objs: list[pf.MeshObject]

sofas: list[pf.MeshObject]

rugs: list[pf.MeshObject]

infinigen2.scenes.room.room_furniture.back_face_grounded(...) → bool

True iff every corner of obj’s back (-X local) face has a collider directly behind it within (1 + eps) * margin. Rejects placements where part of the back overhangs a window/door alcove (no wall behind that corner).

Parameters:

• obj (pf.MeshObject)

• colliders (CollisionSet)

• margin (float)

• eps (float) -- (default: 0.5)

infinigen2.scenes.room.room_furniture.centered_sofa_setup_rand(

...,

) → tuple[ArrangementResult, CollisionSet]

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• floor (pf.MeshObject)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

• storage_objects (list[MeshResult])

infinigen2.scenes.room.room_furniture.keep_unobstructed(

results,

center,

colliders,

) → list[infinigen2.scenes.room.room_furniture.MR]

Drop results whose center a collider separates from center (e.g. a wall between the rug and the sofa). Returns the unobstructed results; reads colliders but does not update them.

Parameters:

• results (list[MR | None])

• center (ndarray)

• colliders (CollisionSet)

infinigen2.scenes.room.room_furniture.place_dining_table(

...,

) → tuple[list[MeshResult], CollisionSet]

Place a single dining table: 2/3 in clear floor space, 1/3 snapped to a wall. Returns the placed result (length 0 or 1) and updated colliders.

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.room.room_furniture.random_bbox_poses_animation_rand(...)

Parameters:

• camera (CameraObject)

• rng (Generator)

• room_dimensions (pf.Vector)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

• wall_margin (float) -- (default: 0.5)

• ceil_margin (float) -- (default: 0.3)

• floor_margin (float) -- (default: 0.3)

infinigen2.scenes.room.room_furniture.retry_place(...) → infinigen2.scenes.room.room_furniture.MR | None

Re-pose child with place_fn until it clears the existing colliders (and satisfies accept_fn, if given), or give up and return None. Reads colliders but never extends it; keep_non_colliding owns updates and intra-batch collisions.

Parameters:

• rng (Generator)

• child (MR)

• colliders (CollisionSet)

• place_fn (Callable[[...], None])

• attempts (int) -- (default: 7)

• accept_fn (Callable[[pf.MeshObject], bool] | None) -- (default: None)

infinigen2.scenes.room.room_furniture.room_furniture_rand(...) → RoomFurnitureResult

Parameters:

• rng (Generator)

• dimensions (pf.Vector)

• wall_planes (list[pf.MeshObject])

• floor (pf.MeshObject)

• frame_start (int) -- (default: 1)

• frame_end (int) -- (default: 1)

• extra_colliders (list[pf.MeshObject] | None) -- (default: None)

• wall_storage (list[pf.MeshObject] | None) -- (default: None)

infinigen2.scenes.room.room_furniture.side_table_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

infinigen2.scenes.room.room_furniture.storage_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

infinigen2.scenes.room.room_furniture.table_decoration_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

room_shape

class infinigen2.scenes.room.room_shape.RoomEdgeToWallsResult(geometry, vector, is_face_flat)

Bases: NamedTuple

geometry: pf.ProcNode[pf.MeshObject]

vector: pf.ProcNode[pf.Vector]

is_face_flat: pf.ProcNode[bool]

class infinigen2.scenes.room.room_shape.RoomShapeResult(...)

Bases: NamedTuple

walls: pf.MeshObject

flat_walls: list[pf.MeshObject]

floor: pf.MeshObject

ceiling: pf.MeshObject

dimensions: pf.Vector

edge_curve: RoomEdgeCurveResult

property all_objects: list[pf.MeshObject]

infinigen2.scenes.room.room_shape.room_dimensions_rand(rng) → pf.Vector

Parameters:

rng (Generator)

infinigen2.scenes.room.room_shape.room_edge_to_walls(

curve,

height,

is_edge_point_flat,

) → RoomEdgeToWallsResult

Parameters:

• curve (pf.ProcNode[CurveObject])

• height (pf.ProcNode[float] | float)

• is_edge_point_flat (pf.ProcNode[bool] | bool)

infinigen2.scenes.room.room_shape.room_shape_rand(

rng,

dimensions=None,

floor_ceiling_offset_epsilon=0.005,

) → RoomShapeResult

Example renders

infinigen2 room_shape_rand render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 room_shape_rand render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 room_shape_rand render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 room_shape_rand render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 room_shape_rand render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 room_shape_rand render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• dimensions (pf.Vector | None) -- (default: None)

• floor_ceiling_offset_epsilon (float) -- (default: 0.005)

room_small_objects

Place collections of small primitive objects onto room surfaces.

Geometry-node Poisson-scatter of a collection of small objects onto a parent surface: selecting upward-facing faces and instancing a collection at random-density, min-distance points.

The room-facing entrypoint builds a shared pool of primitives and scatters subsets of it onto each target’s real surface.

infinigen2.scenes.room.room_small_objects.objects_scatter_rand(

...,

) → tuple[list[pf.MeshObject], CollisionSet]

Per target, free scatter 2/3 of the time and a centered row 1/3; each target skipped with prob skip_prob. Returns placed + colliders.

Parameters:

• rng (Generator)

• targets (list[pf.MeshObject])

• pool (pf.Collection)

• colliders (CollisionSet)

• skip_prob (float) -- (default: 0.333)

infinigen2.scenes.room.room_small_objects.objects_scattered_on_surface(

...,

) → tuple[list[pf.MeshObject], CollisionSet]

Poisson-scatter small objects on each target’s real surface; each target skipped with prob skip_prob. spacing_factor=0 packs furniture surfaces densely. Returns placed + colliders.

Parameters:

• rng (Generator)

• targets (list[pf.MeshObject])

• pool (pf.Collection)

• colliders (CollisionSet)

• skip_prob (float) -- (default: 0.333)

• spacing_factor (float) -- (default: 0.0)

infinigen2.scenes.room.room_small_objects.small_objects_collection_rand(rng) → pf.Collection

One room-wide pool of small primitives to draw from per target. Each primitive’s origin is dropped to its base so instances sit on the surface.

Parameters:

rng (Generator)

room_surface_features

class infinigen2.scenes.room.room_surface_features.CeilingFeaturesResult(...)

Bases: NamedTuple

floor: pf.MeshObject

ceiling: pf.MeshObject

backs: list[pf.MeshObject]

sills: list[pf.MeshObject]

light_meshes: list[pf.MeshObject]

lights: list[LightObject]

class infinigen2.scenes.room.room_surface_features.WallFeatureResult(...)

Bases: NamedTuple

wall_geom: list[pf.MeshObject]

backs: list[pf.MeshObject]

sills: list[pf.MeshObject]

storage: list[pf.MeshObject]

lights: list[LightObject]

decorations: dict[str, list[pf.MeshObject]]

class infinigen2.scenes.room.room_surface_features.WallFeaturesResult(...)

Bases: NamedTuple

wall_planes: list[pf.MeshObject]

backs: list[pf.MeshObject]

sills: list[pf.MeshObject]

storage: list[pf.MeshObject]

lights: list[LightObject]

decorations: dict[str, list[pf.MeshObject]]

infinigen2.scenes.room.room_surface_features.ceiling_feature_rand(

rng,

shape,

wall_thickness=0.1,

) → CeilingFeaturesResult

Parameters:

• rng (Generator)

• shape (RoomShapeResult)

• wall_thickness (float) -- (default: 0.1)

infinigen2.scenes.room.room_surface_features.ceiling_light_bars_rand(

...,

) → tuple[pf.MeshObject, list[pf.MeshObject], list[pf.MeshObject], list[pf.MeshObject], list[LightObject]]

Parameters:

• rng (Generator)

• ceiling (pf.MeshObject)

• ceiling_material (pf.Material)

• dimensions (pf.Vector)

infinigen2.scenes.room.room_surface_features.ceiling_light_placement_rand(

rng,

ceiling,

dimensions,

) → tuple[list[pf.MeshObject], list[LightObject]]

Parameters:

• rng (Generator)

• ceiling (pf.MeshObject)

• dimensions (pf.Vector)

infinigen2.scenes.room.room_surface_features.ceiling_skylights_rand(

rng,

ceiling,

ceiling_material,

) → tuple[pf.MeshObject, list[pf.MeshObject], list[pf.MeshObject], list[pf.MeshObject], list[LightObject]]

Parameters:

• rng (Generator)

• ceiling (pf.MeshObject)

• ceiling_material (pf.Material)

infinigen2.scenes.room.room_surface_features.cutout_spaced_instances(

...,

) → tuple[pf.MeshObject, pf.MeshObject | None, pf.MeshObject | None, list[pf.MeshObject]]

Cut instance-footprint niches in a surface and place instance aliases over them.

Returns (posed surface, sill or None, lightblocker or None, aliases). Instance template must be x-centered (flip-invariant w.r.t. UV sign).

Parameters:

• surface (pf.MeshObject)

• instance (pf.MeshObject)

• surface_material (pf.Material)

• spacing (pf.Vector)

• margin_low (pf.Vector)

• margin_high (pf.Vector)

• x_instances_max (int) -- (default: 1000)

• y_instances_max (int) -- (default: 1)

• canonical_up_axis (str) -- (default: 'Z')

• instance_secondary_axis (tuple[float, float, float]) -- (default: (0, 0, 1))

• wall_thickness (float) -- (default: 0.1)

• recess (bool) -- (default: True)

• recess_pct (float) -- (default: 1.0)

• keep_facecap (bool) -- (default: False)

• up_align (bool) -- (default: False)

• rotation_offset (float) -- (default: 0.0)

• footprint (pf.MeshObject | None) -- (default: None)

• chamfer (float) -- (default: 0.006)

• standoff (float) -- (default: 0.0)

infinigen2.scenes.room.room_surface_features.skirting_on_walls_rand(...) → list[pf.MeshObject]

Parameters:

• rng (Generator)

• walls (list[pf.MeshObject])

• material (pf.Material)

• profile_curve (CurveObject | None) -- (default: None)

infinigen2.scenes.room.room_surface_features.skirting_rand(rng, walls) → list[pf.MeshObject]

Parameters:

• rng (Generator)

• walls (list[pf.MeshObject])

infinigen2.scenes.room.room_surface_features.upright_cabinet_footprint(width, height) → pf.MeshObject

Flat (U=width, V=height) rect for niche-grid sizing of an up_aligned cabinet.

Parameters:

• width (float)

• height (float)

infinigen2.scenes.room.room_surface_features.wall_board_shelf_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_cubby_rand(...) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_decoration_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• window_obj (pf.MeshObject)

• window_portal (LightObject | None)

• wall_material (pf.Material)

• wall_material_alt (pf.Material)

• window_spacing (float | None) -- (default: None)

• window_bottom (float | None) -- (default: None)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_doors_rand(...) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_feature_rand(

rng,

shape,

wall_thickness=0.1,

) → WallFeaturesResult

Parameters:

• rng (Generator)

• shape (RoomShapeResult)

• wall_thickness (float) -- (default: 0.1)

infinigen2.scenes.room.room_surface_features.wall_full_window_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_horizontal_split_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_material_alt (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_painting_grid_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_plain_rand(...) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_storage_flush_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_storage_shelf_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_vertical_split_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_material_alt (pf.Material)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_window_extrusion_rand(

...,

) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• window_obj (pf.MeshObject)

• window_portal (LightObject | None)

• window_spacing (float)

• window_bottom (float)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.wall_windows_rand(...) → WallFeatureResult

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• wall_material (pf.Material)

• window_obj (pf.MeshObject)

• window_portal (LightObject | None)

• window_spacing (float)

• window_bottom (float)

• wall_thickness (float) -- (default: 0.05)

infinigen2.scenes.room.room_surface_features.window_spaced_rand(

...,

) → tuple[pf.MeshObject, pf.MeshObject | None, pf.MeshObject | None, list[pf.MeshObject]]

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

• window_obj (pf.MeshObject)

• wall_material (pf.Material)

• spacing (float)

• window_bottom (float)

• wall_thickness (float) -- (default: 0.05)

Module contents

asset_demo

class infinigen2.scenes.asset_demo.DevSceneResult(all_objects, cameras, lights)

Bases: NamedTuple

all_objects: list

cameras: list

lights: list

infinigen2.scenes.asset_demo.demo_cube(size=1.0) → pf.MeshObject

Parameters:

size (float) -- (default: 1.0)

infinigen2.scenes.asset_demo.grid_plane() → pf.MeshObject

infinigen2.scenes.asset_demo.hardcoded_camera(...) → CameraObject

Parameters:

• base_location (pf.Vector)

• dist_mult (float) -- (default: 1)

• elevation_deg (float) -- (default: 19)

• altitude (float) -- (default: 2.2)

• yaw_offset_deg (float) -- (default: 0)

infinigen2.scenes.asset_demo.material_banana(

rng,

material=None,

environment=None,

) → DevSceneResult

Example renders

infinigen2 material_banana render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_banana render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_banana render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_banana render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_banana render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_banana render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.material_cube(

rng,

material=None,

environment=None,

) → DevSceneResult

Example renders

infinigen2 material_cube render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_cube render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_cube render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_cube render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_cube render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_cube render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.material_monkey(

rng,

material=None,

environment=None,

) → DevSceneResult

Example renders

infinigen2 material_monkey render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_monkey render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_monkey render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_monkey render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_monkey render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_monkey render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.material_plane_horizontal_uv(

rng,

material=None,

environment=None,

) → DevSceneResult

Example renders

infinigen2 material_plane_horizontal_uv render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_horizontal_uv render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_horizontal_uv render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_horizontal_uv render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_horizontal_uv render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_horizontal_uv render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.material_plane_orthographic(...) → DevSceneResult

Orthographic top-down plane scene for pixel-perfect GT validation.

Every pixel sees the same flat plane face: object index is uniform and all surface normals point straight up (+Z world space).

Example renders

infinigen2 material_plane_orthographic render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_orthographic render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_orthographic render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_orthographic render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_orthographic render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_orthographic render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

• size (float) -- (default: 1.333)

infinigen2.scenes.asset_demo.material_plane_uv(

rng,

material=None,

environment=None,

) → DevSceneResult

Example renders

infinigen2 material_plane_uv render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_uv render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_uv render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_uv render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_uv render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_plane_uv render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.material_sphere(...) → DevSceneResult

Example renders

infinigen2 material_sphere render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_sphere render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_sphere render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_sphere render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_sphere render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_sphere render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

• subdivisions (int) -- (default: 4)

• radius (float) -- (default: 0.75)

infinigen2.scenes.asset_demo.material_torus_uv(...) → DevSceneResult

Example renders

infinigen2 material_torus_uv render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_torus_uv render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_torus_uv render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_torus_uv render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_torus_uv render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 material_torus_uv render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• material (pf.Material | None) -- (default: None)

• environment (World | None) -- (default: None)

• major_radius (float) -- (default: 0.5)

• minor_radius (float) -- (default: 0.25)

infinigen2.scenes.asset_demo.object_demo(...) → DevSceneResult

Example renders

infinigen2 object_demo render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

infinigen2 object_demo render_cycles --seed 1 --passes rgb -r 480 480 -s 256 📋

infinigen2 object_demo render_cycles --seed 2 --passes rgb -r 480 480 -s 256 📋

infinigen2 object_demo render_cycles --seed 3 --passes rgb -r 480 480 -s 256 📋

infinigen2 object_demo render_cycles --seed 4 --passes rgb -r 480 480 -s 256 📋

infinigen2 object_demo render_cycles --seed 5 --passes rgb -r 480 480 -s 256 📋

Parameters:

• rng (Generator)

• obj (pf.MeshObject | None) -- (default: None)

• camera (CameraObject | None) -- (default: None)

• environment (World | None) -- (default: None)

infinigen2.scenes.asset_demo.scale_reference(location, radius=0.3) → pf.MeshObject

Parameters:

• location (ndarray)

• radius (float) -- (default: 0.3)

collision_collection

class infinigen2.scenes.collision_collection.CollisionSet(

objs: 'list[pf.Object]',

collision_manager: 'trimesh.collision.CollisionManager',

object_names: 'dict[int, str]',

mesh_colliders: 'dict[int, trimesh.Trimesh]',

mesh_fcl_colliders: 'dict[int, Any]',

object_fcl_objs: 'dict[int, Any]',

object_last_transforms: 'dict[int, np.ndarray]',

)

Bases: object

Parameters:

• objs (list[Object])

• collision_manager (CollisionManager)

• object_names (dict[int, str])

• mesh_colliders (dict[int, Trimesh])

• mesh_fcl_colliders (dict[int, Any])

• object_fcl_objs (dict[int, Any])

• object_last_transforms (dict[int, ndarray])

infinigen2.scenes.collision_collection.any_self_collision(col) → bool

Return True if any two objects in the set currently intersect each other.

Parameters:

col (CollisionSet)

infinigen2.scenes.collision_collection.box_intersection_test(col, transform, size=1.0) → bool

Parameters:

• col (CollisionSet)

• transform (ndarray)

• size (float) -- (default: 1.0)

infinigen2.scenes.collision_collection.collision_set(objs, existing=None) → CollisionSet

Parameters:

• objs (list[Object])

• existing (CollisionSet | None) -- (default: None)

infinigen2.scenes.collision_collection.intersection_test(col, obj) → bool

Parameters:

• col (CollisionSet)

• obj (Object)

infinigen2.scenes.collision_collection.n_colliders(col) → int

Parameters:

col (CollisionSet)

infinigen2.scenes.collision_collection.raycast(col, ray_origins, ray_directions) → Any

Raycast over the combined mesh from tracked colliders.

Parameters:

• col (CollisionSet)

• ray_origins (ndarray)

• ray_directions (ndarray)

floating_objects

class infinigen2.scenes.floating_objects.FloatingObjectsResult(all_objects, colliders)

Bases: NamedTuple

all_objects: list[pf.MeshObject]

colliders: CollisionSet

infinigen2.scenes.floating_objects.floating_lights_rand(...) → FloatingObjectsResult

Create up to max_lights colored point lights and place them in bbox.

Parameters:

• rng (Generator)

• colliders (CollisionSet | None) -- (default: None)

• bbox (tuple[ndarray, ndarray] | None) -- (default: None)

• n_lights (int | None) -- (default: None)

• max_lights (int) -- (default: 3)

• total_wattage (float | None) -- (default: None)

infinigen2.scenes.floating_objects.floating_object_asset_rand(rng) → pf.MeshObject

Parameters:

rng (Generator)

infinigen2.scenes.floating_objects.floating_objects_rand(...) → FloatingObjectsResult

Parameters:

• colliders (CollisionSet | None) -- Existing collision set to extend. Defaults to an empty set.

• bbox (tuple[ndarray, ndarray] | None) -- Bounding box for placement. Defaults to a [-10, 10]^3 cube.

• floating_objects (list[pf.MeshObject] | None) -- If provided, place these objects instead of sampling new ones.

• volume_density (float) -- Roughly what percent of the box’s volume should we fill when sampling.

• check_collisions (bool) -- If False, do not add the placed objects to the returned collision set.

• rng (Generator)

infinigen2.scenes.floating_objects.point_lamp_colored_rand(...) → LightObject

A point light whose emission uses a fully-random RGB color.

Parameters:

• rng (Generator)

• energy (float)

• color (tuple[float, float, float] | None) -- (default: None)

• shadow_soft_size (float | None) -- (default: None)

infinigen2.scenes.floating_objects.rotated_bbox_extents(obj, rot, scale) → tuple[ndarray, ndarray]

Return (min, max) of the object’s local bbox corners after applying rot and scale, centered at origin.

Parameters:

• obj (pf.MeshObject)

• rot (pf.Vector)

• scale (pf.Vector)

placement_utils

infinigen2.scenes.placement_utils.delete_object(obj)

Parameters:

obj (Object)

infinigen2.scenes.placement_utils.distribute_in_bbox(...) → list[Object]

Place each object at a uniformly-random location inside bbox, keeping its current rotation and scale, fitting its bounding box within the box, and (when colliders is non-empty) rejection-sampling up to attempts times so mesh placements avoid that collision set. Mutates each object’s location in place.

Parameters:

• rng (Generator)

• objects (list[Object])

• bbox (tuple[ndarray, ndarray])

• colliders (CollisionSet | None) -- (default: None)

• attempts (int) -- (default: 8)

infinigen2.scenes.placement_utils.duplicates(...) → list[Object]

Parameters:

• obj (Object)

• locations (ndarray)

• rotations (ndarray | None) -- (default: None)

• scales (ndarray | None) -- (default: None)

infinigen2.scenes.placement_utils.keep_non_colliding(

items,

colliders,

key=<function <lambda>>,

) → tuple[list[infinigen2.scenes.placement_utils.T], CollisionSet]

Keep each item whose key(item) mesh doesn’t collide with colliders or an already-kept item, folding kept meshes into the set. Skips Nones; rejected items are dropped (not deleted) and removed later by scene autocleanup.

Parameters:

• items (list[T | None])

• colliders (CollisionSet)

• key (Callable[[T], Object]) -- (default: <function <lambda>>)

infinigen2.scenes.placement_utils.repeat_attempts(...) → infinigen2.scenes.placement_utils.T | None

Parameters:

• func (Callable[[...], T | None])

• rng (Generator)

• attempts (int) -- (default: 5)

• args (Any)

• kwargs (Any)

infinigen2.scenes.placement_utils.snap_to_plane(...)

Snap child to parent using bbox sides with canonical local coordinates.

TODO: allow constraint_axis=None and 2D offsets within bounding box free dirs

Parameters:

• child (Object) -- Object to position

• parent (Object) -- Object to snap to

• placement (float) -- How far left or right along to place the object, relative to the parent and the constraint axis e.g. if constraint_axis=(0, 0, 1), placement=0.5 means centered, 0 means left edge of parent’s bbox, 1 means right edge of parent’s bbox.

• child_side (str) -- Which side of child touches the parent

• parent_side (str) -- Which side of parent touches the child

• margin (float) -- Gap between surfaces

• constraint_axis (pf.Vector) -- Axis to constrain the placement to. The location wont change along this axis, and we may rotate the object around this axis to snap it.

• overhang (bool) -- If true, only the center of the childs bbox must attach to the parent, rather than the entire side of the bbox touching the parent.

Module contents