Scenes (.scenes)

Placement (.scenes.placement)

collision

class infinigen2.scenes.placement.collision.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.placement.collision.any_self_collision(col) → bool

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

Parameters:

col (CollisionSet)

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

Parameters:

• col (CollisionSet)

• transform (ndarray)

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

infinigen2.scenes.placement.collision.collision_set(objs, cache=None) → CollisionSet

Parameters:

• objs (list[Object])

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

infinigen2.scenes.placement.collision.intersection_test(col, obj) → bool

Parameters:

• col (CollisionSet)

• obj (Object)

infinigen2.scenes.placement.collision.n_colliders(col) → int

Parameters:

col (CollisionSet)

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

Raycast over the combined mesh from tracked colliders.

Parameters:

• col (CollisionSet)

• ray_origins (ndarray)

• ray_directions (ndarray)

culling

infinigen2.scenes.placement.culling.keep_non_colliding(

items,

colliders,

key=<function <lambda>>,

) → tuple[list[infinigen2.scenes.placement.culling.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.culling.keep_unobstructed(...) → list[infinigen2.scenes.placement.culling.T]

Drop each item whose key(item) center a collider separates from center (e.g. a wall between a rug and the sofa, or beyond a wall-snapped table). Reads colliders but does not update them; skips Nones.

Parameters:

• items (list[T | None])

• center (ndarray)

• colliders (CollisionSet)

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

infinigen2.scenes.placement.culling.place_surrounding(

...,

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

Arrange items around parent with arrange_fn(rng, parent), drop any a collider separates from the parent (a wall-snapped table’s wall-side chairs land outside the room, with the wall between them and the table), cull the rest against colliders, and re-sample the whole arrangement via repeat_attempts until at least min_kept survive. colliders must exclude parent so the obstruction ray sees the wall behind it, not the parent itself. Suits chairs around a dining table or stools around a kitchen island, where one bulky design can collide every item away.

Parameters:

• rng (Generator)

• parent (pf.MeshObject)

• arrange_fn (Callable[[Generator, pf.MeshObject], list[pf.MeshObject]])

• colliders (CollisionSet)

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

• min_kept (int) -- (default: 2)

distribute

infinigen2.scenes.placement.distribute.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.distribute.duplicates(...) → list[Object]

Parameters:

• obj (Object)

• locations (ndarray)

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

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

infinigen2.scenes.placement.distribute.propagate_modifiers_to_instances(templates, instances)

Parameters:

• templates (list[pf.MeshObject])

• instances (list[pf.MeshObject])

retry

infinigen2.scenes.placement.retry.repeat_attempts(...) → infinigen2.scenes.placement.retry.T | None

Parameters:

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

• rng (Generator)

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

• args (Any)

• kwargs (Any)

snap

infinigen2.scenes.placement.snap.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

Rooms (.scenes.room)

room

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

Bases: NamedTuple

all_objects: list[pf.MeshObject]

lights: list[LightObject]

colliders: CollisionSet

floor: pf.MeshObject

dimensions: pf.Vector | None

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

A furnished living room whose centerpiece is a sofa grouping.

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)

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

Everything livingroom_rand does, but the furniture centerpiece is a choice between a sofa grouping and a dining setup (table with chairs around it).

Example renders

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

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

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

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

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

infinigen2 room_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.CenteredSofaSetupResult(...)

Bases: NamedTuple

sofas: list[MeshResult]

coffee_tables: list[MeshResult]

rugs: list[pf.MeshObject]

all_objects: list[pf.MeshObject]

class infinigen2.scenes.room.room_furniture.DiningSetupResult(dining_table, chairs, all_objects)

Bases: NamedTuple

dining_table: pf.MeshObject

chairs: list[pf.MeshObject]

all_objects: list[pf.MeshObject]

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

Bases: NamedTuple

dining_tables: list[MeshResult]

dining_chairs: list[MeshResult]

rugs: list[pf.MeshObject]

all_objects: list[pf.MeshObject]

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

Bases: Protocol

property mesh: pf.MeshObject

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

Bases: NamedTuple

sofas: list[MeshResult]

coffee_tables: list[MeshResult]

side_tables: list[MeshResult]

rugs: list[pf.MeshObject]

all_objects: list[pf.MeshObject]

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

Bases: NamedTuple

sofas: list[MeshResult]

coffee_tables: list[MeshResult]

rugs: list[pf.MeshObject]

all_objects: list[pf.MeshObject]

infinigen2.scenes.room.room_furniture.arrange_dining_chairs(...) → list[pf.MeshObject]

Instance chair_obj around the sides of dining_table, facing inward, posed by the table’s current transform, and realize the instances into one object per chair. Table and chair footprints are measured from bounding boxes inside the nodegraph. chair_spacing is the gap between adjacent chairs, tuck the meters the chair front is pulled in past the table edge (negative leaves a gap), edge_margin the clearance kept at each table corner so chairs never overhang the ends, rot_jitter the random per-chair z rotation (radians). include_ends toggles the chairs on the +/-Y ends.

Parameters:

• chair_obj (pf.MeshObject)

• dining_table (pf.MeshObject)

• chair_spacing (float)

• tuck (float)

• edge_margin (float)

• rot_jitter (float)

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

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(

...,

) → CenteredSofaSetupResult

Sofas ringing a central rug facing inward, with an optional center coffee table. Works without walls, so it is registered as a standalone Scene; wall_planes is accepted only for signature parity with the wall variant.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.room_furniture.dining_setup_rand(...) → DiningSetupResult

A dining table with a single dining chair design instanced around all four sides facing inward. Builds the table, one chair, then arranges copies of the chair around it; chairs follow the table’s pose. Pass dining_table to arrange chairs around an existing (already posed) table instead of sampling one.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

• include_ends (bool | None) -- (default: None)

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

infinigen2.scenes.room.room_furniture.dining_table_setup_rand(

...,

) → DiningTableSetupResult

Place a dining table (3/4 in clear floor space, 1/4 snapped to a wall), then arrange chairs around the posed table, plus an optional rug. Chairs are culled against colliders and dropped when a wall separates them from the table (a wall-snapped table’s wall-side chairs land outside the room), retrying the arrangement with a fresh chair design and margins when too few survive.

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

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

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.side_table_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

infinigen2.scenes.room.room_furniture.snap_back_front(...)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

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

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

infinigen2.scenes.room.room_furniture.snap_on_top(...)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

• xy_frac (tuple[float, float]) -- (default: (0.5, 0.5))

infinigen2.scenes.room.room_furniture.sofa_lamps_rand(

...,

) → tuple[list[MeshResult], list[MeshResult], list[LightObject], CollisionSet]

Place floor lamps beside sofa_meshes and table lamps atop side_table_meshes, culling against colliders. Returns (floor_lamps, table_lamps, lights, colliders); each lamp’s light is kept in lights ~2/3 of the time.

Parameters:

• rng (Generator)

• sofa_meshes (list[pf.MeshObject])

• side_table_meshes (list[pf.MeshObject])

• colliders (CollisionSet)

infinigen2.scenes.room.room_furniture.sofa_setup_rand(...) → SofaSetupResult

A sofa grouping (choice of wall-snapped or rug-centered) plus side tables beside the sofas. wall_planes passes through to the wall-snapped variant. Lamps are placed by the caller from the returned sofas and side tables (see sofa_lamps_rand).

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

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

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)

infinigen2.scenes.room.room_furniture.wall_sofa_setup_rand(...) → WallSofaSetupResult

Sofas snapped against the walls, plus an optional rug. Needs posed wall planes, so it is not registered as a standalone Scene.

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

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

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.CutoutResult(...)

Bases: NamedTuple

geom: pf.MeshObject

sill: pf.MeshObject | None

lightblocker: pf.MeshObject | None

aliases: list[pf.MeshObject]

trim_edges: CurveObject | None

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(

...,

) → CutoutResult

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

Instance template must be x-centered (flip-invariant w.r.t. UV sign). trim_edges is the sharp mouth outline of every cutout on the wall surface, posed like the wall, with curve normals pre-set for sweeping a trim profile.

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)

• rotation_offset (tuple[float, float, float]) -- (default: (0.0, 0.0, 0.0))

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

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

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

infinigen2.scenes.room.room_surface_features.cutout_trim_rand(...) → pf.MeshObject

Sweep a symmetric trim profile around cutout mouth outlines (window casing).

Parameters:

• rng (Generator)

• trim_edges (CurveObject)

• material (pf.Material)

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

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 wall-frame rect (Y=width=U, Z=height=V) for niche-grid sizing.

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(...) → CutoutResult

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

demo_curve

infinigen2.scenes.demo_curve.curve_demo(...) → DevSceneResult

Emit a representative base path curve into the pipeline state, and render it swept with a default profile so it stands alone as a scene. Downstream curve generators receive the path via their curve / base_curve parameter.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

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

infinigen2.scenes.demo_curve.trim_demo(...) → DevSceneResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

demo_material

infinigen2.scenes.demo_material.material_banana(

rng,

material=None,

environment=None,

) → DevSceneResult

Parameters:

• rng (Generator)

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

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

infinigen2.scenes.demo_material.material_cube(

rng,

material=None,

environment=None,

) → DevSceneResult

Parameters:

• rng (Generator)

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

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

infinigen2.scenes.demo_material.material_monkey(

rng,

material=None,

environment=None,

) → DevSceneResult

Parameters:

• rng (Generator)

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

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

infinigen2.scenes.demo_material.material_plane_horizontal_uv(

rng,

material=None,

environment=None,

) → DevSceneResult

Parameters:

• rng (Generator)

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

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

infinigen2.scenes.demo_material.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).

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.demo_material.material_plane_uv(

rng,

material=None,

environment=None,

) → DevSceneResult

Parameters:

• rng (Generator)

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

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

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

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.demo_material.material_torus_uv(...) → DevSceneResult

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)

demo_object

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

Parameters:

• rng (Generator)

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

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

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

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

demo_util

class infinigen2.scenes.demo_util.DevSceneResult(...)

Bases: NamedTuple

all_objects: list

cameras: list

lights: list

environment: World | None

curves: list

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

Parameters:

size (float) -- (default: 1.0)

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

infinigen2.scenes.demo_util.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.demo_util.scale_reference(location, radius=0.3) → pf.MeshObject

Parameters:

• location (ndarray)

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

floating_objects

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

Bases: NamedTuple

all_objects: list[pf.MeshObject]

colliders: CollisionSet

class infinigen2.scenes.floating_objects.ObjWithPostprocessingResult(mesh)

Bases: NamedTuple

mesh: pf.MeshObject

class infinigen2.scenes.floating_objects.ObjectResult(mesh)

Bases: NamedTuple

mesh: pf.MeshObject

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

Place colored point lights in bbox, sampling shared-wattage lights when none given.

Parameters:

• rng (Generator)

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

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

• lights (list[LightObject] | 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 [0, 5]^3 cube, so this is a usable standalone Scene generator with no room walls around it.

• 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.

• size_scale (float) -- Multiplier on the sampled object size (mean/spread/max), e.g. 2.0 for larger props. The object count is divided by size_scale**3 so the filled volume stays near volume_density.

• rng (Generator)

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

• colliders (CollisionSet | None)

• bbox (tuple[ndarray, ndarray] | None)

• floating_objects (list[pf.MeshObject] | None)

• volume_density (float)

• check_collisions (bool)

• size_scale (float)

infinigen2.scenes.floating_objects.lights_with_shared_wattage_rand(

rng,

quantity=None,

wattage=None,

) → list[LightObject]

Create quantity colored point lights whose energies sum to wattage.

Parameters:

• rng (Generator)

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

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

infinigen2.scenes.floating_objects.obj_with_postprocessing(

rng,

) → ObjWithPostprocessingResult

Example renders

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 0 --passes rgb -r 512 512 -s 128 📋

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 1 --passes rgb -r 512 512 -s 128 📋

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 2 --passes rgb -r 512 512 -s 128 📋

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 3 --passes rgb -r 512 512 -s 128 📋

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 4 --passes rgb -r 512 512 -s 128 📋

infinigen2 obj_with_postprocessing object_demo render_cycles --seed 5 --passes rgb -r 512 512 -s 128 📋

Parameters:

rng (Generator)

infinigen2.scenes.floating_objects.object_rand(rng) → ObjectResult

Parameters:

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)

Module contents