Skip to content

Splat and Renderer Options

Options for photorealistic backgrounds and the non-default renderers. SplatOptions configures a Gaussian-splat background rendered with gsplat and NyxSplatOptions one rendered with the Nyx path tracer; PCDOptions loads a raw point cloud. RayTracerOptions and BatchRendererOptions are Eden's versions of Genesis' ray tracer and Madrona batch renderer options. The sensors and rendering guide explains when to use each renderer, and the scenes guide covers real-to-sim splat scenes.

from eden.options.splat import SplatOptions
from eden.options.renderer import BatchRendererOptions

A camera shows the splat only when its CameraOptions.overlays declares a SplatComposite (camera overlays).

Gaussian splats and point clouds

Gaussian-splat scene options (gsplat and Nyx) and point-cloud options.

Attributes

SplatCameraMode module-attribute 

SplatCameraMode = Literal['auto', 'single', 'batched']

ToneMapper module-attribute 

ToneMapper = Literal['ACES_1_3', 'Neutral', 'Off', 'Reinhard']

Classes

PCDOptions 

PCDOptions(**data)

Bases: ConfigurableOptions

PCD options for Eden.

PARAMETER DESCRIPTION
path

Path to the ply file, fetched from registry/dataset when it is not a local file.
local_dir

Where the file is cached. Unset, it is assets_subdir under the asset root, resolved when the options are built (:meth:resolve_local_dir), so a saved config's local_dir stays unset.
assets_subdir

The subdirectory of the asset root that an unset local_dir means; empty is the root. A field, and so saved with the config, unlike EntityOptions' class constant: PCDs have no per-family subclasses to carry one, and saving it is harmless here. It is a relative name, never a machine's path, and it is read only while the options are built, since path is resolved to the local file then and saved resolved. What the class-constant rule elsewhere keeps out of saved configs is an absolute default path.
scale

Scale factor.
pos

Translation of the pcd.
quat

Rotation of the pcd (w, x, y, z).
multiplier

Per-splat radiance scale. Maps to LightFieldAsset.multiplier on the Nyx backend; ignored by the gsplat backend (SplatOptions). 1.0 leaves the splat unchanged, >1 brightens, <1 darkens.
tint

Per-channel multiplicative tint applied on top of multiplier. Maps to LightFieldAsset.tint on the Nyx backend; ignored by the gsplat backend.
attach_entity

Name of the entity whose pose drives this splat. Requires SplatOptions(per_env_gaussians=True): when set, the splat is treated as a dynamic rigid body that follows this entity per environment. None marks a static background splat. Ignored by the Nyx backend (which renders a static background).
attach_link

Optional link name on attach_entity to bind to (defaults to the entity's base link).
Source code in eden/options/options.py 
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

path instance-attribute 
path: str
registry class-attribute instance-attribute 
registry: str = 'Kashu7100'
dataset class-attribute instance-attribute 
dataset: str = 'eden_assets'
local_dir class-attribute instance-attribute 
local_dir: str | None = None
assets_subdir class-attribute instance-attribute 
assets_subdir: str = ''
scale class-attribute instance-attribute 
scale: float = 1.0
pos class-attribute instance-attribute 
pos: Vec3FType = (0.0, 0.0, 0.0)
quat class-attribute instance-attribute 
quat: UnitVec4FType = (1.0, 0.0, 0.0, 0.0)
multiplier class-attribute instance-attribute 
multiplier: float = 1.0
tint class-attribute instance-attribute 
tint: Vec3FType = (1.0, 1.0, 1.0)
attach_entity class-attribute instance-attribute 
attach_entity: str | None = None

attach_link: str | None = None

Methods:

resolve_local_dir 
resolve_local_dir() -> str

Where the file is cached: local_dir, else assets_subdir under the asset root.

Source code in eden/options/splat.py 
93
94
95
def resolve_local_dir(self) -> str:
    """Where the file is cached: ``local_dir``, else ``assets_subdir`` under the asset root."""
    return resolve_local_dir(self.local_dir, self.assets_subdir)

SplatOptions 

SplatOptions(**data)

Bases: DynamicConfigurableOptions

Gaussian-splat options for Eden, consumed by :class:~eden.envs.splat.SplatEnvBase (non-RL) and :class:~eden.envs.splat.SplatRLEnvBase (RL).

The one gsplat backend (:class:~eden.utils.batch_splat_renderer.BatchSplatRenderer), composited over the sim pass by segmentation mask. There is no sh_degree field (SH is read from each PLY) and no bg_color field (the background is the composite, not a fill). Shadows that sim objects cast on the background entities are carried onto the splat per camera, with the shadow_strength of the camera's SplatComposite overlay. Nyx is the separate path-traced backend (:class:NyxSplatOptions).

Which camera renders each view is selected by camera_mode — :class:~eden.entities.camera.SplatCamera renders one env-invariant pose and broadcasts it (cheap; a fixed camera over a shared background), :class:~eden.entities.camera.BatchSplatCamera renders every env's camera (needed for an attached/following camera or per_env_gaussians).

PARAMETER DESCRIPTION
per_env_gaussians

The shared / per-env Gaussian switch. False (shared) stores one Gaussian set and renders every env's camera from it — memory-light, scales to many envs, but the splat scene is identical across envs. True (per-env) gives each env its own Gaussians so splats bound to entities (PCDOptions.attach_entity) follow that env's sim poses; memory is O(num_envs * G), fitting tens–hundreds of envs. Forces the batched camera.
minibatch

Chunk size over the env/view axis, bounding peak VRAM (gsplat evaluates view-dependent SH per rendered view). None renders all envs at once.
camera_mode

How each splat camera renders. "auto" (default) picks per camera: the batched camera when per_env_gaussians or the camera is attached/following (per-env poses), else the single-view camera. "single" / "batched" force one class for every camera ("single" is rejected with per_env_gaussians=True). This is env-wide: with two or more splat cameras the forced modes apply to all of them; per-camera control would need the knob on CameraOptions, so rely on "auto" when different cameras need different modes.
Source code in eden/options/options.py 
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

per_env_gaussians class-attribute instance-attribute 
per_env_gaussians: bool = False
minibatch class-attribute instance-attribute 
minibatch: int | None = None
camera_mode class-attribute instance-attribute 
camera_mode: SplatCameraMode = 'auto'
pcds instance-attribute 
pcds: dict[str, PCDOptions]

NyxSplatOptions 

NyxSplatOptions(**data)

Bases: DynamicConfigurableOptions

Nyx-based splat rendering options.

Uses Nyx's native light field support to render gaussian-splat backgrounds inside the path tracer, instead of the gsplat rasterize-and-segmentation-composite approach of :class:SplatOptions.

PARAMETER DESCRIPTION
spp

Samples per pixel for path tracing.
denoise

Whether to apply denoising.
near

Near clipping plane distance.
far

Far clipping plane distance.
max_pt_depth

Must stay None. gs-nyx-plugin exposes no path-depth control, so a depth set here could never take effect; it is rejected rather than ignored.
lights

Light definitions in Z-up coordinates. Each dict should have a "type" key ("point", "directional", or "spot") and type-specific parameters.
env_map_paths

Paths to HDR environment map textures.
tone_mapper

Name of the gs_nyx.nyx_py_sdk.EToneMapper member to use. Use "Off" or "Reinhard" while tuning lighting to see closer-to- linear radiance feedback. Written into each camera's profile (see :func:eden.envs.nyx_splat.write_nyx_camera_profile), including a camera's own NyxCameraOptions that sets no camera_profile; one that does keeps its own.
exposure_compensation

Exposure, in EV, relative to unit exposure (a pixel shows the radiance it receives; +1 doubles the image). 0 keeps the brightness that light intensities and env-map brightnesses were tuned against; Nyx's own default camera renders 0.53 EV darker.
Source code in eden/options/options.py 
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
def __init__(self, **data):
    # Seed type metadata as construction data so BaseModel validates it into
    # __pydantic_extra__ (no-op for extra="forbid" classes, which use
    # the serialization envelope instead).
    data.update(option_metadata(self))
    # NOTE: all of the option modifications/validations should be done in the __init__ method
    try:
        BaseModel.__init__(self, **data)
    except ValidationError as exc:
        # A misspelled field on an extra="forbid" class should teach the field set, not just
        # name the typo. Only rewritten when every error is extra_forbidden.
        enriched = _enrich_extra_forbidden(type(self), exc)
        if enriched is None:
            raise
        raise enriched from None

Attributes

spp class-attribute instance-attribute 
spp: int = 32
denoise class-attribute instance-attribute 
denoise: bool = True
near class-attribute instance-attribute 
near: float = 0.1
far class-attribute instance-attribute 
far: float = 100.0
max_pt_depth class-attribute instance-attribute 
max_pt_depth: int | None = None
lights class-attribute instance-attribute 
lights: list[dict[str, Any]] = []
env_map_paths class-attribute instance-attribute 
env_map_paths: list[str] = []
tone_mapper class-attribute instance-attribute 
tone_mapper: ToneMapper = 'ACES_1_3'
exposure_compensation class-attribute instance-attribute 
exposure_compensation: float = 0.0
pcds instance-attribute 
pcds: dict[str, PCDOptions]

Functions:

Renderers

Renderer configuration options (ray tracer, madrona batch renderer).

Classes

RayTracerOptions

Bases: RayTracer

Options for the ray-tracing renderer.

PARAMETER DESCRIPTION
env_surface

Environment surface.

TYPE: Surface

env_radius

Environment radius.

TYPE: float

env_pos

Environment position.

TYPE: array - like[float, float, float]

env_euler

The euler angles of the environment, in degrees.

TYPE: array - like[float, float, float]

lights

List of lights. Each light is a dictionary with keys: ['pos', 'color', 'intensity', 'radius']. - 'pos': array-like[float, float, float] - 'color': array-like[float, float, float] - 'intensity': float - 'radius': float

TYPE: list of dict

Attributes

state_limit class-attribute instance-attribute 
state_limit: int = 2 ** 25
tracing_depth class-attribute instance-attribute 
tracing_depth: int = 32
rr_depth class-attribute instance-attribute 
rr_depth: int = 0
rr_threshold class-attribute instance-attribute 
rr_threshold: float = 0.95
env_surface class-attribute instance-attribute 
env_surface: Surface = Field(default_factory=_default_env_surface)
env_radius class-attribute instance-attribute 
env_radius: float = 15.0
env_pos class-attribute instance-attribute 
env_pos: Vec3FType = (0.0, 0.0, 0.0)
env_euler class-attribute instance-attribute 
env_euler: Vec3FType = (0, 0, 180)
lights class-attribute instance-attribute 
lights: list[dict[str, Any]] = [{'pos': (0.0, 0.0, 10.0), 'radius': 2.0, 'color': (15.0, 15.0, 15.0), 'intensity': 10.0}]

BatchRendererOptions

Bases: BatchRenderer

Options for the gs-madrona batch renderer, with declarative scene lights.

Madrona renders ambient-only until lights are added (cameras come out near-black), and it bakes the light count at scene.build() time — so lights must be registered via gs.Scene.add_light before the build. The raw genesis gs.renderers.BatchRenderer has no lights field, so this eden subclass carries them declaratively (mirroring :class:RayTracerOptions.lights); :class:eden.envs.base.EnvBase applies them right after scene creation.

PARAMETER DESCRIPTION
lights

One kwargs dict per gs.Scene.add_light call, e.g. {"pos": (0.5, 0.5, 2.0), "dir": (0, 0, -1), "intensity": 3.0, "directional": True, "castshadow": False}.

TYPE: list of dict

Attributes

lights class-attribute instance-attribute 
lights: list[dict[str, Any]] = []

See also