Scenes (.scenes)

House (.scenes.house)

floor_mesh

ProcFunc/Blender adapters for dependency-free house floor plans.

class infinigen2.scenes.house.floor_mesh.HouseCeilingCutoutResult(ceiling, sill, back)

Bases: NamedTuple

Fields: ceiling: MeshObject; sill: MeshObject; back: MeshObject

class infinigen2.scenes.house.floor_mesh.HouseFloorMeshPlanesResult(...)

Bases: NamedTuple

Fields: planes_interior: list[~WallPlane]; planes_exterior: list[~WallPlane]; floors: list[~MeshObject]; ceilings: list[~MeshObject]; dimensions: Vector

class infinigen2.scenes.house.floor_mesh.WallPlane(...)

Bases: NamedTuple

One room-facing wall quad, with the layout data its setup needs.

Fields: obj: MeshObject; wall_index: int; room_index: int; thickness: float; length: float; start: tuple[float, float]; end: tuple[float, float]

infinigen2.scenes.house.floor_mesh.house_ceiling_cutout(...) → HouseCeilingCutoutResult

Pierce a room ceiling polygon with footprint boxes lying fully inside it.

Parameters:

• polygon (BaseGeometry)

• centers (ndarray)

• footprint (tuple[float, float])

• height (float)

• depth (float)

infinigen2.scenes.house.floor_mesh.house_floor_profile_to_planes(

room_boundaries,

walls,

height=2.8,

) → HouseFloorMeshPlanesResult

Build one room-facing quad per wall side, plus per-room floors and ceilings.

Parameters:

• room_boundaries (tuple[tuple[tuple[tuple[float, float], ...], ...], ...])

• walls (tuple[WallSegment, ...])

• height (float) -- (default: 2.8)

infinigen2.scenes.house.floor_mesh.vertical_strip(...) → pf.MeshObject

Metric-UV wall grid from start to end, facing left of that direction.

Parameters:

• start (tuple[float, float])

• end (tuple[float, float])

• height (float)

• name (str)

floor_plan

Pure house floor-plan generation over exact planar room polygons.

Ported from the Infinigen v1 room solver (SegmentMaker, FloorPlanSolver and BlueprintSolidifier in infinigen/core/constraints/example_solver/room/).

class infinigen2.scenes.house.floor_plan.HouseFloorProfileResult(room_boundaries, walls)

Bases: NamedTuple

Fields: room_boundaries: tuple[PolygonRings, ...]; walls: tuple[WallSegment, ...]

class infinigen2.scenes.house.floor_plan.WallSegment(...)

Bases: NamedTuple

Fields: start: Point2D; end: Point2D; room_indices: tuple[int, ...]; thickness: float; door_position_frac: float | None; is_flat: bool

infinigen2.scenes.house.floor_plan.house_room_polygon(boundary_rings) → BaseGeometry

Return the closed room polygon used to derive the house walls.

Parameters:

boundary_rings (tuple[tuple[tuple[float, float], ...], ...])

infinigen2.scenes.house.floor_plan.room_connect_rand(rng, walls, room_count) → tuple[WallSegment, ...]

Choose door walls and positions forming a connected room graph.

Parameters:

• rng (Generator)

• walls (tuple[WallSegment, ...])

• room_count (int)

infinigen2.scenes.house.floor_plan.room_solve(...) → HouseFloorProfileResult

Partition an exact outline polygon into rooms and derive their walls.

Parameters:

• rng (Generator)

• boundary_rings (tuple[tuple[tuple[float, float], ...], ...])

• room_count (int)

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

• fillet_segments (tuple[tuple[tuple[float, float], tuple[float, float]], ...]) -- (default: ())

infinigen2.scenes.house.floor_plan.wall_is_exterior(wall) → bool

Parameters:

wall (WallSegment)

infinigen2.scenes.house.floor_plan.wall_length(wall) → float

Parameters:

wall (WallSegment)

furnishings

Room contents layered onto an existing unfurnished house.

class infinigen2.scenes.house.furnishings.HouseRoomFurnishingResult(all_objects, small_objects, lights)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; small_objects: list[~MeshObject]; lights: list[~LightObject]

class infinigen2.scenes.house.furnishings.HouseRoomFurnitureResult(...)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; lights: list[~LightObject]; colliders: CollisionSet; temporary_objects: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

class infinigen2.scenes.house.furnishings.SetupResult(...)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; colliders: CollisionSet; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]; lamps: list[~LampResult]; temporary_objects: list[~MeshObject]

infinigen2.scenes.house.furnishings.furnish_house_room_furniture_rand(

...,

) → HouseRoomFurnitureResult

Parameters:

• rng (Generator)

• boundary_rings (tuple[tuple[tuple[float, float], ...], ...])

• floor (pf.MeshObject)

• flat_walls (list[pf.MeshObject])

• height (float)

• colliders (CollisionSet)

infinigen2.scenes.house.furnishings.furnish_house_room_rand(

...,

) → HouseRoomFurnishingResult

Parameters:

• rng (Generator)

• boundary_rings (tuple[tuple[tuple[float, float], ...], ...])

• floor (pf.MeshObject)

• flat_walls (list[pf.MeshObject])

• height (float)

• colliders (CollisionSet)

• nonstorage_collection (pf.Collection | None) -- (default: None)

• storage_collection (pf.Collection | None) -- (default: None)

infinigen2.scenes.house.furnishings.house_furnished_rand(...) → HouseResult

Build an unfurnished house, then furnish each solved room.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

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

infinigen2.scenes.house.furnishings.link_house_room_collection(room_index, objects, lights) → pf.Collection

Parameters:

• room_index (int)

• objects (list[pf.MeshObject])

• lights (list[LightObject])

infinigen2.scenes.house.furnishings.setup_from_space_rand(...) → SetupResult

Parameters:

• rng (Generator)

• region (Polygon)

• wall_planes (list[pf.MeshObject])

• height (float)

• colliders (CollisionSet)

outline

Pure sampling of the exterior polygon used by the room solver.

Ported from Infinigen v1 GraphMaker.suggest_dimensions and ContourFactory.

class infinigen2.scenes.house.outline.HouseOutlineResult(boundary_rings, fillet_segments)

Bases: NamedTuple

Fields: boundary_rings: PolygonRings; fillet_segments: tuple[tuple[Point2D, Point2D], ...]

infinigen2.scenes.house.outline.house_outline_rand(rng, *, room_count, dimensions=None) → HouseOutlineResult

Sample a box house outline in metres, with some corners chamfered or rounded.

Parameters:

• rng (Generator)

• room_count (int)

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

unfurnished

Multi-room house layout, surfaces, and walls.

class infinigen2.scenes.house.unfurnished.HouseResult(...)

Bases: NamedTuple

Fields: all_objects: list[MeshObject]; small_objects: list[MeshObject]; cameras: list[CameraObject]; lights: list[LightObject]; rooms: tuple[HouseRoomResult, ...]; dimensions: Vector; colliders: CollisionSet; environment: World | None

class infinigen2.scenes.house.unfurnished.HouseRoomResult(...)

Bases: NamedTuple

Fields: room_index: int; boundary_rings: PolygonRings; all_objects: list[MeshObject]; lights: list[LightObject]; floor: MeshObject; ceiling: MeshObject; walls: list[MeshObject]; flat_walls: list[MeshObject]; neighbors: dict[int, int]; doors: dict[int, MeshObject]; doorway_centers: dict[int, tuple[float, float]]

class infinigen2.scenes.house.unfurnished.HouseWallResult(...)

Bases: NamedTuple

Fields: sides: tuple[HouseWallSideResult, ...]; planes_interior: list[MeshObject]; planes_exterior: list[MeshObject]; corners: list[MeshObject]; corners_by_room: dict[int, list[MeshObject]]; backs: list[MeshObject]; sills: list[MeshObject]; storage_containers: list[MeshObject]; supports: list[MeshObject]; lights: list[LightObject]; windows: list[MeshObject]; decorations: dict[str, list[MeshObject]]; doors: dict[int, MeshObject]; doorway_centers: dict[int, tuple[float, float]]; colliders: CollisionSet

class infinigen2.scenes.house.unfurnished.HouseWallSideResult(plane, result)

Bases: NamedTuple

Fields: plane: WallPlane; result: WallResult

infinigen2.scenes.house.unfurnished.house_unfurnished_rand(...) → HouseResult

Dress a house shell with surface, wall, ceiling, and lighting options.

Every room picks its floor from floor_materials and its walls from wall_materials, so the house shares a small palette.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

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

• floor_materials (list[pf.Material] | None) -- (default: None)

• wall_materials (list[pf.Material] | None) -- (default: None)

infinigen2.scenes.house.unfurnished.house_walls_rand(...) → HouseWallResult

Treat both sides of every partition and the inside of every outer wall.

Partition sides have no backs because the two offset faces close the wall.

Parameters:

• rng (Generator)

• walls (tuple[WallSegment, ...])

• planes_interior (list[WallPlane])

• planes_exterior (list[WallPlane])

• room_count (int)

• height (float)

• feature_min_width (float) -- (default: 1.4)

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

• room_wall_materials (list[pf.Material] | None) -- (default: None)

infinigen2.scenes.house.unfurnished.interior_wall_arrangement_rand(...) → WallResult

Equal-weight treatment for a partition side; doors are placed separately.

Parameters:

• rng (Generator)

• wall (pf.MeshObject)

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

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

Module contents

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 | tuple[float, float, float]) -- (default: 1.0)

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

Parameters:

• objs (Sequence[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 until it is internally clear and 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.

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.instances_along_line(...) → list[pf.MeshObject]

count aliases of instance centred in equal slots from start to end, given in parent’s local frame. Consumes instance.

Parameters:

• instance (pf.MeshObject)

• parent (pf.MeshObject)

• start (pf.Vector)

• end (pf.Vector)

• count (int)

• rotation (pf.Euler) -- (default: (0.0, 0.0, 0.0))

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.

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 | None) -- 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. If None, center the child face on the parent face without rotating 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)

bathroom_setup

class infinigen2.scenes.room.bathroom_setup.BathroomSetupResult(...)

Bases: NamedTuple

Fields: named_objects: dict[str, list[MeshObject]]; all_objects: list[MeshObject]; colliders: CollisionSet; temporary_objects: list[MeshObject]; storage_containers: list[MeshObject]; supports: list[MeshObject]; storages: list[MeshObject]

class infinigen2.scenes.room.bathroom_setup.BathroomSinkSetupResult(...)

Bases: NamedTuple

Fields: bathroom_sinks: list[MeshResult]; sink_taps: list[MeshResult]; sink_supports: list[MeshResult]; mirrors: list[MeshResult]; wall_storage: list[MeshResult]; storages: list[MeshResult]; all_objects: list[MeshObject]

infinigen2.scenes.room.bathroom_setup.bathroom_existing_sink_setup_rand(...) → BathroomSetupResult

Parameters:

• rng (Generator)

• sink_obj (pf.MeshObject)

• wall_planes (list[pf.MeshObject])

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

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

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

infinigen2.scenes.room.bathroom_setup.bathroom_setup_rand(...) → BathroomSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

infinigen2.scenes.room.bathroom_setup.bathroom_sink_setup_rand(...) → BathroomSinkSetupResult

Parameters:

• rng (Generator)

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

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

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

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

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

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

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

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

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

infinigen2.scenes.room.bathroom_setup.snap_wall_hardware_rand(...) → MeshResult | None

Wall-mount hardware beside or above one of parents, retrying until its back sits flat on wall_colliders and it clears colliders.

Parameters:

• rng (Generator)

• hardware (MeshResult)

• parents (list[pf.MeshObject])

• wall_colliders (CollisionSet)

• colliders (CollisionSet)

bed_setup

class infinigen2.scenes.room.bed_setup.BedSetupResult(...)

Bases: NamedTuple

Fields: bed: MeshObject; mattress: MeshObject | None; bedside_tables: list[~MeshObject]; bedside_lamps: list[~MeshObject]; pillows: list[~MeshObject]; lights: list[~LightObject]; all_objects: list[~MeshObject]; colliders: CollisionSet; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

infinigen2.scenes.room.bed_setup.bed_dimensions_rand(...) → pf.Vector

Parameters:

• rng (Generator)

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

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

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

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

infinigen2.scenes.room.bed_setup.bed_setup_multi_rand(...) → list[BedSetupResult]

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• bbox_min (pf.Vector)

• bbox_max (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.room.bed_setup.bed_setup_rand(...) → BedSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

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

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

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

• furniture (Sequence[pf.MeshObject] | None) -- (default: None)

infinigen2.scenes.room.bed_setup.table_bedside_composite_rand(

rng,

dimensions=None,

) → TableResult

Bedside-sized storage, regular table, or desk with under-top storage.

Parameters:

• rng (Generator)

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

ceiling_features

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

Bases: NamedTuple

Fields: floor: MeshObject; ceiling: MeshObject; backs: list[~MeshObject]; sills: list[~MeshObject]; light_meshes: list[~MeshObject]; lights: list[~LightObject]

class infinigen2.scenes.room.ceiling_features.CeilingGridResult(...)

Bases: NamedTuple

Fields: instance: MeshObject; light: LightObject | None; light_offset: tuple[float, float, float]; footprint: tuple[float, float]; spacing: tuple[float, float]; margin_low: tuple[float, float]; margin_high: tuple[float, float]; counts: tuple[int, int]; rotation_offset: tuple[float, float, float]; reveal_depth: float; recess_pct: float; chamfer: float

infinigen2.scenes.room.ceiling_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.ceiling_features.ceiling_lamp_grid_rand(

rng,

extent,

energy,

) → CeilingGridResult

Parameters:

• rng (Generator)

• extent (tuple[float, float])

• energy (float)

infinigen2.scenes.room.ceiling_features.ceiling_lamp_lights(...) → list[LightObject]

Parameters:

• light (LightObject | None)

• light_offset (tuple[float, float, float])

• meshes (list[pf.MeshObject])

• energy (float)

infinigen2.scenes.room.ceiling_features.ceiling_light_bar_grid_rand(

rng,

extent,

ceiling_material,

) → CeilingGridResult

Parameters:

• rng (Generator)

• extent (tuple[float, float])

• ceiling_material (pf.Material)

infinigen2.scenes.room.ceiling_features.ceiling_light_bar_lights_rand(...) → list[LightObject]

Parameters:

• rng (Generator)

• footprint (tuple[float, float])

• bars (list[pf.MeshObject])

• area (float)

infinigen2.scenes.room.ceiling_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.ceiling_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.ceiling_features.ceiling_skylight_grid_rand(

rng,

extent,

) → CeilingGridResult

Parameters:

• rng (Generator)

• extent (tuple[float, float])

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

cocktail_table_setup

infinigen2.scenes.room.cocktail_table_setup.table_cocktail_setup_rand(

rng,

) → DiningSetupResult

A cocktail table with height-matched tall chairs arranged around it.

Example renders

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

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

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

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

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

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

Parameters:

rng (Generator)

infinigen2.scenes.room.cocktail_table_setup.table_cocktail_setup_wall_rand(

...,

) → DiningTableSetupResult

A cocktail table with any side against a wall and tall chairs around it.

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

decoration_objects

Place floor, surface, and small decoration objects into furnished scenes.

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 reusable decoration pools and scatters subsets of them onto each target’s real surface.

class infinigen2.scenes.room.decoration_objects.DecorationObjectsResult(all_objects, lights, colliders)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; lights: list[~LightObject]; colliders: CollisionSet

infinigen2.scenes.room.decoration_objects.container_faces(parent) → pf.ProcNode[bool]

Parameters:

parent (pf.ProcNode[pf.MeshObject])

infinigen2.scenes.room.decoration_objects.decoration_collection_primitives_and_real_rand(rng) → pf.Collection

Draw reusable primitives and real objects seated at their bases.

Parameters:

rng (Generator)

infinigen2.scenes.room.decoration_objects.decoration_collection_primitives_rand(rng) → pf.Collection

Draw reusable decoration primitives with origins seated at their bases.

Parameters:

rng (Generator)

infinigen2.scenes.room.decoration_objects.decorate_floor_objects_rand(

...,

) → DecorationObjectsResult

Parameters:

• rng (Generator)

• objects (list[pf.MeshObject])

• colliders (CollisionSet)

• floor (pf.MeshObject)

• wall_planes (list[pf.MeshObject])

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

• collection (list[MeshResult] | None) -- (default: None)

infinigen2.scenes.room.decoration_objects.decorate_surface_objects_rand(

...,

) → DecorationObjectsResult

Parameters:

• rng (Generator)

• objects (list[pf.MeshObject])

• colliders (CollisionSet)

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

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

• collection (list[MeshResult] | None) -- (default: None)

infinigen2.scenes.room.decoration_objects.decoration_smallobj_rand(rng) → MeshResult

Parameters:

rng (Generator)

infinigen2.scenes.room.decoration_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.decoration_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.decoration_objects.placeable_faces(

parent,

selection,

) → pf.ProcNode[pf.MeshObject]

The selected faces, minus connected islands smaller than MIN_PLACEABLE_AREA, so small details never receive objects.

Parameters:

• parent (pf.ProcNode[pf.MeshObject])

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

infinigen2.scenes.room.decoration_objects.scatter_small_objects_on_containers(

...,

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

Scatter on recessed upward faces, drawing a collection when omitted.

Parameters:

• rng (Generator)

• targets (list[pf.MeshObject])

• colliders (CollisionSet)

• collection (pf.Collection | None) -- (default: None)

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

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

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

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

infinigen2.scenes.room.decoration_objects.scatter_small_objects_on_support_tops(

...,

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

Scatter on topmost upward faces, drawing a collection when omitted.

Parameters:

• rng (Generator)

• targets (list[pf.MeshObject])

• colliders (CollisionSet)

• collection (pf.Collection | None) -- (default: None)

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

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

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

infinigen2.scenes.room.decoration_objects.support_top_faces(parent) → pf.ProcNode[bool]

Parameters:

parent (pf.ProcNode[pf.MeshObject])

desk_setup

class infinigen2.scenes.room.desk_setup.DeskSetupResult(...)

Bases: NamedTuple

Fields: desk: MeshObject; chair: MeshObject; monitors: list[~MeshObject]; all_objects: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

infinigen2.scenes.room.desk_setup.desk_setup_rand(...) → DeskSetupResult | None

A desk and chair, snapped to a wall when wall planes are supplied.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

dining_table_setup

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

Bases: NamedTuple

Fields: dining_table: MeshObject; chairs: list[~MeshObject]; all_objects: list[~MeshObject]

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

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; dining_tables: list[~MeshResult]; dining_chairs: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

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

Instance one chair design along the table’s bounding-box edge curves.

Parameters:

• chair_obj (pf.MeshObject)

• dining_table (pf.MeshObject)

• chair_spacing (float)

• tuck (float)

• edge_margin (float)

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

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

• offset_seed (int) -- (default: 0)

infinigen2.scenes.room.dining_table_setup.chairs_on_edge(...) → pf.ProcNode[procfunc.nodes.types.Instances]

Parameters:

• chair_geo (pf.ProcNode[pf.MeshObject])

• edge (pf.ProcNode[CurveObject])

• inward (pf.ProcNode[pf.Vector] | pf.Vector)

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

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

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

• seed (pf.ProcNode[int] | int)

infinigen2.scenes.room.dining_table_setup.table_dining_setup_rand(

...,

) → DiningTableSetupResult

Place a dining table in clear floor space and arrange chairs around it.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

• region (Polygon | None) -- (default: None)

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

infinigen2.scenes.room.dining_table_setup.table_dining_setup_wall_rand(

...,

) → DiningTableSetupResult

A rectangular or circular dining table with any side against a wall.

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.room.dining_table_setup.table_dining_with_chairs_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 table_dining_with_chairs_rand object_demo render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

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

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

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

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

infinigen2 table_dining_with_chairs_rand object_demo 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)

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

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

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

infinigen2.scenes.room.dining_table_setup.table_wall_setup_rand(

...,

) → DiningTableSetupResult

Snap any side of dining_table against a wall, then arrange chairs on its open sides; place_surrounding drops the wall-side chairs.

Parameters:

• rng (Generator)

• dining_table (MeshResult)

• wall_planes (list[pf.MeshObject])

• colliders (CollisionSet)

kitchen_setup

class infinigen2.scenes.room.kitchen_setup.KitchenModuleArrayResult(...)

Bases: NamedTuple

Fields: mesh: MeshObject; all_objects: list[~MeshObject]; cabinets: list[~MeshObject]; plinths: list[~MeshObject]; sinks: list[~MeshObject]; taps: list[~MeshObject]

class infinigen2.scenes.room.kitchen_setup.KitchenSetupResult(...)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; colliders: CollisionSet; countertops: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

infinigen2.scenes.room.kitchen_setup.island_rand(...) → KitchenModuleArrayResult

A double-sided array: a front row under the countertop and a back row facing the other way, both inside one countertop two cabinets deep.

Parameters:

• rng (Generator)

• pose (pf.Matrix)

• count (int)

• n_sinks (int)

• modules (pf.Collection)

• n_modules (int)

• module_width (float)

• counter_depth (float)

• height (float)

• thickness (float)

• plinth (pf.Vector)

• cabinet_material (pf.Material)

• countertop_material (pf.Material)

infinigen2.scenes.room.kitchen_setup.island_setup_rand(...) → KitchenSetupResult

Place an island mid-floor a walkway clear of walkway, and stools along its overhang half the time.

Parameters:

• rng (Generator)

• count (int)

• n_sinks (int)

• modules (pf.Collection)

• n_modules (int)

• module_width (float)

• counter_depth (float)

• height (float)

• thickness (float)

• plinth (pf.Vector)

• cabinet_material (pf.Material)

• countertop_material (pf.Material)

• bbox_min (pf.Vector)

• bbox_max (pf.Vector)

• region (Polygon | None)

• walkway (CollisionSet)

• colliders (CollisionSet)

infinigen2.scenes.room.kitchen_setup.kitchen_cabinets_wall_setup_rand(

...,

) → KitchenSetupResult

One array of base cabinets with uppers above it per wall, each snapped back to its wall or with one end against an earlier array’s front to turn an L.

Parameters:

• rng (Generator)

• walls (list[pf.MeshObject])

• sinks_per_wall (list[int])

• base_modules (pf.Collection)

• n_base (int)

• upper_modules (pf.Collection)

• n_upper (int)

• module_width (float)

• counter_depth (float)

• height (float)

• thickness (float)

• plinth (pf.Vector)

• upper_bottom (float)

• cabinet_material (pf.Material)

• countertop_material (pf.Material)

• colliders (CollisionSet)

• wall_overlap (float)

infinigen2.scenes.room.kitchen_setup.kitchen_module_array_rand(

...,

) → KitchenModuleArrayResult

A straight run of base cabinets under one countertop, n_sinks of them sink bases, built along +y from pose with its back at x=0. modules[0] is the sink base and modules[1:n_modules] the other cabinet modules.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

• pose (pf.Matrix | None) -- (default: None)

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

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

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

• modules (pf.Collection | None) -- (default: None)

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

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

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

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

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

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

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

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

infinigen2.scenes.room.kitchen_setup.kitchen_setup_rand(...) → KitchenSetupResult

Cabinet arrays on every reserved_wall_planes wall and some wall_planes walls, then an island and wall hardware. wall_overlap is how far each wall plane extends past the room corners.

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

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

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

• region (Polygon | None) -- (default: None)

room

class infinigen2.scenes.room.room.RoomResult(...)

Bases: NamedTuple

Containers expose internal upward surfaces; supports accept objects on top. One object may provide both capabilities.

Fields: all_objects: list[~MeshObject]; cameras: list[~CameraObject]; lights: list[~LightObject]; colliders: CollisionSet; floor: MeshObject; dimensions: Vector; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]; wall_planes: list[~MeshObject]; plain_wall_planes: list[~MeshObject]

infinigen2.scenes.room.room.decorate_room_small_objects_rand(

...,

) → DecorationObjectsResult

Parameters:

• rng (Generator)

• objects (list[pf.MeshObject])

• colliders (CollisionSet)

• containers (list[pf.MeshObject])

• support_tops (list[pf.MeshObject])

• storages (list[pf.MeshObject])

• nonstorage_collection (pf.Collection | None) -- (default: None)

• storage_collection (pf.Collection | None) -- (default: None)

infinigen2.scenes.room.room.room_bathroom_rand(...) → RoomResult

Example renders

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

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

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

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

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

infinigen2 room_bathroom_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_bedroom_rand(...) → RoomResult

Example renders

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

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

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

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

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

infinigen2 room_bedroom_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_diningroom_rand(...) → RoomResult

Example renders

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

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

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

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

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

infinigen2 room_diningroom_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_kitchen_rand(...) → RoomResult

Example renders

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

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

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

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

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

infinigen2 room_kitchen_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_livingroom_rand(...) → RoomResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.room.room_unfurnished_rand(...) → RoomResult

n_plain_walls non-door walls, counted from plain_wall_offset, stay featureless and are returned as plain_wall_planes.

Parameters:

• rng (Generator)

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

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

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

• n_plain_walls (int) -- (default: 0)

• plain_wall_offset (int) -- (default: 0)

infinigen2.scenes.room.room.room_walls_rand(...) → WallResult

Arrange open_walls and merge them with the already built_walls. Mounted features hitting earlier walls’ decorations are dropped by each feature.

Parameters:

• rng (Generator)

• shape (RoomShapeResult)

• built_walls (list[WallResult])

• open_walls (list[pf.MeshObject])

• wall_materials (list[pf.Material])

infinigen2.scenes.room.room.wall_arrangement_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

• window_portal (LightObject | None) -- (default: None)

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

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

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

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

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

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

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

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

room_shape

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

Bases: NamedTuple

Fields: geometry: ProcNode[~MeshObject]; vector: ProcNode[Vector]; is_face_flat: ProcNode[bool]

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

Bases: NamedTuple

Fields: walls: MeshObject; flat_walls: list[~MeshObject]; floor: MeshObject; ceiling: MeshObject; dimensions: Vector; edge_curve: RoomEdgeCurveResult; all_objects: list[~MeshObject]; cameras: list[~CameraObject]

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)

skirting

infinigen2.scenes.room.skirting.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.skirting.skirting_rand(rng, walls) → list[pf.MeshObject]

Parameters:

• rng (Generator)

• walls (list[pf.MeshObject])

sofa_setup

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

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; sofas: list[~SofaResult]; rugs: list[~MeshObject]; throw_pillows: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

class infinigen2.scenes.room.sofa_setup.TVSetupResult(mesh, tv, all_objects)

Bases: NamedTuple

Fields: mesh: MeshObject; tv: MeshObject; all_objects: list[~MeshObject]

infinigen2.scenes.room.sofa_setup.side_tables_rand(...) → list[MeshResult]

Parameters:

• rng (Generator)

• sofas (list[SofaResult])

• colliders (CollisionSet)

• max_tables (int)

infinigen2.scenes.room.sofa_setup.sofa_setup_centered_rand(...) → SofaSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

• region (Polygon | None) -- (default: None)

infinigen2.scenes.room.sofa_setup.sofa_setup_wall_anchored_rand(...) → SofaSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.sofa_setup.sofa_setup_wall_rand(...) → SofaSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.sofa_setup.tv_setup_rand(rng) → TVSetupResult

Example renders

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

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

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

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

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

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

Parameters:

rng (Generator)

infinigen2.scenes.room.sofa_setup.tv_setup_wall_rand(

rng,

wall_planes,

colliders,

) → list[TVSetupResult]

Parameters:

• rng (Generator)

• wall_planes (list[pf.MeshObject])

• colliders (CollisionSet)

wall_base

class infinigen2.scenes.room.wall_base.WallResult(...)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; wall_planes: list[~MeshObject]; backs: list[~MeshObject]; sills: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; lights: list[~LightObject]; decorations: dict[str, list[~MeshObject]]; corner_walls: list[~MeshObject]; storages: list[~MeshObject]; colliders: CollisionSet | None

infinigen2.scenes.room.wall_base.extrude_for_thickness(obj, thickness) → pf.MeshObject

Solidify a flat surface into a back-thickness slab (the lightblocker body).

Parameters:

• obj (pf.MeshObject)

• thickness (float)

infinigen2.scenes.room.wall_base.finish_wall_plane(wall, wall_material) → pf.MeshObject

Parameters:

• wall (pf.MeshObject)

• wall_material (pf.Material)

infinigen2.scenes.room.wall_base.fit_grid_margins(...) → tuple[float, float, int]

Fit item count across extent and push slack into edge margins (low, high, n).

Parameters:

• extent (float)

• item_size (float)

• spacing (float)

• min_margin (float)

• split (float)

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

infinigen2.scenes.room.wall_base.name_objects(objs, name) → list[pf.MeshObject]

Parameters:

• objs (list[pf.MeshObject])

• name (str)

infinigen2.scenes.room.wall_base.overlap_wall_plane_edges(wall, overlap)

Parameters:

• wall (pf.MeshObject)

• overlap (float)

infinigen2.scenes.room.wall_base.plain_wall(

wall,

wall_material,

wall_thickness,

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

Materialise, thicken and canonicalise a bare wall (no cutouts).

Parameters:

• wall (pf.MeshObject)

• wall_material (pf.Material)

• wall_thickness (float)

infinigen2.scenes.room.wall_base.plane_to_posed_canonical_mesh(obj, up_axis='Z') → pf.MeshObject

Bake a planar mesh’s location/rotation into the object transform, appearance unchanged.

Parameters:

• obj (pf.MeshObject)

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

infinigen2.scenes.room.wall_base.resolve_wall_inputs(

rng,

wall,

wall_material,

) → tuple[Generator, pf.MeshObject, pf.Material]

Parameters:

• rng (Generator)

• wall (pf.MeshObject | None)

• wall_material (pf.Material | None)

infinigen2.scenes.room.wall_base.seat_upright_cabinet(...) → pf.MeshObject

Center an upright cabinet in the wall frame (X=depth out, Y=width, Z=height).

Y/Z centered on the niche; X shifted so the back sits back_depth behind the surface (opening at depth-back_depth). Placement maps local X->normal, Y->along-wall, Z->up.

Parameters:

• cab (pf.MeshObject)

• width (float)

• height (float)

• back_depth (float)

infinigen2.scenes.room.wall_base.shift_wall_ends(...)

Move each end of a wall mesh along world direction, keeping metric U.

Parameters:

• wall (pf.MeshObject)

• direction (ndarray)

• low (float)

• high (float)

infinigen2.scenes.room.wall_base.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.wall_base.wall_storage_width_rand(rng, wall_width, min_margin) → float

Parameters:

• rng (Generator)

• wall_width (float)

• min_margin (float)

infinigen2.scenes.room.wall_base.wall_uv_dimensions(wall) → tuple[float, float]

Parameters:

wall (pf.MeshObject)

infinigen2.scenes.room.wall_base.wall_plain_rand(...) → WallResult

Example renders

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

Parameters:

• rng (Generator)

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

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

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

wall_cutouts

class infinigen2.scenes.room.wall_cutouts.CutoutResult(...)

Bases: NamedTuple

Fields: geom: MeshObject; sill: MeshObject | None; lightblocker: MeshObject | None; aliases: list[~MeshObject]; trim_edges: CurveObject | None

infinigen2.scenes.room.wall_cutouts.arrange_window_portals(

window_aliases,

window_obj,

window_portal,

) → list[LightObject]

Parameters:

• window_aliases (list[pf.MeshObject])

• window_obj (pf.MeshObject)

• window_portal (LightObject)

infinigen2.scenes.room.wall_cutouts.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. Nonzero profile heights (metres) round the top/bottom of each footprint bbox into ellipse quarters spanning its full width.

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)

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

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

infinigen2.scenes.room.wall_cutouts.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.wall_cutouts.wall_cubby_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.wall_cutouts.wall_doors_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.wall_cutouts.wall_full_window_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.wall_cutouts.wall_painting_grid_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

infinigen2.scenes.room.wall_cutouts.wall_storage_shelf_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

infinigen2.scenes.room.wall_cutouts.wall_windows_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

• window_portal (LightObject | None) -- (default: None)

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

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

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

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

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

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

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

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

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

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

wall_mounts

infinigen2.scenes.room.wall_mounts.wall_board_shelf_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

infinigen2.scenes.room.wall_mounts.wall_storage_flush_rand(...) → WallResult

Example renders

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

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

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

Parameters:

• rng (Generator)

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

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

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

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

wall_storage_setup

class infinigen2.scenes.room.wall_storage_setup.WallStorageSetupResult(...)

Bases: NamedTuple

Fields: storage: list[~MeshResult]; all_objects: list[~MeshObject]; colliders: CollisionSet; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

infinigen2.scenes.room.wall_storage_setup.wall_storage_setup_rand(

rng,

wall_planes=None,

colliders=None,

) → WallStorageSetupResult

Example renders

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

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

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

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

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

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

Parameters:

• rng (Generator)

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

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

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

Ground patch at terrain scale, where position-driven terrain materials are tuned to read.

Parameters:

• rng (Generator)

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

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

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

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

Fields: 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

Fields: all_objects: list[~MeshObject]; colliders: CollisionSet

class infinigen2.scenes.floating_objects.ObjWithPostprocessingResult(mesh)

Bases: NamedTuple

Fields: mesh: MeshObject

class infinigen2.scenes.floating_objects.ObjectResult(mesh)

Bases: NamedTuple

Fields: mesh: MeshObject

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 object_demo render_cycles --seed 0 --passes rgb -r 480 480 -s 256 📋

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

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

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

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

infinigen2 floating_objects_rand object_demo 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_floating_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.lights_point_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.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.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)

indoor_space

class infinigen2.scenes.indoor_space.SetupGridResult(...)

Bases: NamedTuple

Fields: all_objects: list[~MeshObject]; storage_containers: list[~MeshObject]; supports: list[~MeshObject]; storages: list[~MeshObject]

class infinigen2.scenes.indoor_space.WallRowResult(grid, yaw)

Bases: NamedTuple

Fields: grid: SetupGridResult; yaw: float

infinigen2.scenes.indoor_space.bookshelf_aisle_rows_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.grid_centered_sofa_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.chair_banks_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.grid_cocktail_table_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.desk_aisle_rows_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.desk_grid_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.grid_dining_table_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.indoor_space_rand(...) → RoomResult

Example renders

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

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

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

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

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

infinigen2 indoor_space_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.indoor_space.seat_wall_row_rand(...) → WallRowResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

• wall_colliders (CollisionSet)

• yaw (float)

infinigen2.scenes.indoor_space.setup_grid_in_region(...) → SetupGridResult

Parameters:

• unit (SetupGridResult)

• unit_size (pf.Vector)

• center (pf.Vector)

• depth (float)

• length (float)

• yaw (float)

• gap (pf.Vector)

• aisle (float)

• rows_per_block (int)

• back_to_back (bool)

• colliders (CollisionSet)

• wall_colliders (CollisionSet | None)

infinigen2.scenes.indoor_space.setup_grid_instances(

...,

) → pf.ProcNode[procfunc.nodes.types.Instances]

Parameters:

• collection (pf.ProcNode[pf.Collection] | pf.Collection)

• count (pf.ProcNode[int] | int)

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

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

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

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

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

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

• start (pf.ProcNode[pf.Vector] | pf.Vector)

• center (pf.ProcNode[pf.Vector] | pf.Vector)

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

infinigen2.scenes.indoor_space.sink_wall_row_rand(...) → WallRowResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

• wall_colliders (CollisionSet)

• yaw (float)

infinigen2.scenes.indoor_space.sofa_grid_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.storage_aisle_rows_rand(

rng,

room_dimensions,

colliders,

) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

infinigen2.scenes.indoor_space.wall_row_rand(...) → WallRowResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

• wall_colliders (CollisionSet)

• yaw (float)

infinigen2.scenes.indoor_space.wall_rows_rand(...) → SetupGridResult

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• colliders (CollisionSet)

• wall_colliders (CollisionSet)

setup_utils

class infinigen2.scenes.setup_utils.BareMeshResult(mesh)

Bases: NamedTuple

Fields: mesh: MeshObject

class infinigen2.scenes.setup_utils.MeshResult(*args, **kwargs)

Bases: Protocol

property mesh: pf.MeshObject

infinigen2.scenes.setup_utils.back_face_grounded(...) → bool

Parameters:

• obj (pf.MeshObject)

• colliders (CollisionSet)

• margin (float)

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

• side (str) -- (default: 'back')

infinigen2.scenes.setup_utils.bbox_face_grounded(...) → bool

Parameters:

• obj (pf.MeshObject)

• colliders (CollisionSet)

• side (str)

• max_distance (float)

infinigen2.scenes.setup_utils.center_inside(region, obj) → bool

Parameters:

• region (Polygon)

• obj (pf.MeshObject)

infinigen2.scenes.setup_utils.clear_of(obj, others, distance) → bool

Parameters:

• obj (pf.MeshObject)

• others (Sequence[pf.MeshObject])

• distance (float)

infinigen2.scenes.setup_utils.inset_floor_point_rand(...) → tuple[float, float]

A random floor point where a footprint of half_size stays margin inside the room, falling back to the room centre on an axis too small for it.

Parameters:

• rng (Generator)

• room_dimensions (pf.Vector)

• half_size (tuple[float, float])

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

infinigen2.scenes.setup_utils.jitter_object_rotation_rand(...)

Retry yaw against every other object in colliders.

Parameters:

• rng (Generator)

• obj (pf.MeshObject)

• max_angle (float)

• colliders (CollisionSet)

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

infinigen2.scenes.setup_utils.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.setup_utils.retry_place(...) → infinigen2.scenes.setup_utils.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.setup_utils.side_table_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

infinigen2.scenes.setup_utils.snap_back_front(...)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

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

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

infinigen2.scenes.setup_utils.snap_on_top(...)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

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

infinigen2.scenes.setup_utils.snap_side_by_side(rng, child, parents)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

infinigen2.scenes.setup_utils.snap_to_wall(...)

Parameters:

• rng (Generator)

• child (MR)

• parents (list[pf.MeshObject])

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

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

• child_side (str | None) -- (default: None)

infinigen2.scenes.setup_utils.sofa_object_rand(rng) → SofaResult

Parameters:

rng (Generator)

infinigen2.scenes.setup_utils.standalone_wall_planes(length=15.0, height=3.0) → list[pf.MeshObject]

Parameters:

• length (float) -- (default: 15.0)

• height (float) -- (default: 3.0)

infinigen2.scenes.setup_utils.storage_object_rand(rng) → MeshResult

Parameters:

rng (Generator)

Module contents