Engine#

namespace engine#

Enums

enum class CustomComputeResourceKind#

Resource type for custom compute shader bindings.

Values:

enumerator Buffer#: Structured or raw GPU buffer resource.

enumerator Texture#: Texture image resource.

enum class CustomComputeResourceAccess#

Access permission mode for custom compute shader resources.

Values:

enumerator ReadOnly#: Read-only shader resource.

enumerator WriteOnly#: Write-only unordered access resource.

enumerator ReadWrite#: Read-write unordered access resource.

enum class CustomComputeDispatchMode#

Compute dispatch mode for executing custom compute passes.

Values:

enumerator ExplicitGroupCount#: Dispatch using explicit 3D thread group counts.

enumerator ResourceElementCount#: Compute thread group count dynamically from resource element count.

enum class SharedBufferAccess#

Declared custom-compute access policy for shared engine GPU buffers.

Values:

enumerator ReadOnly#: Allows read-only custom-compute bindings.

enumerator WriteOnly#: Allows write-only custom-compute bindings.

enumerator ReadWrite#: Allows read/write custom-compute bindings.

enum class SharedBufferBindFlags : std::uint32_t#

Binding usage flags for shared GPU buffers.

Values:

enumerator None#: No binding flags specified.

enumerator ShaderResource#: Bindable as a Shader Resource View (SRV).

enumerator UnorderedAccess#: Bindable as an Unordered Access View (UAV).

enum class SharedBufferTensorDTypeCode#

DLPack tensor data type codes for shared buffer tensor view export.

Values:

enumerator Int#: Signed integer.

enumerator UInt#: Unsigned integer.

enumerator Float#: Floating point.

enumerator Bool#: Boolean.

Functions

inline constexpr SharedBufferBindFlags operator|(const SharedBufferBindFlags lhs, const SharedBufferBindFlags rhs) noexcept#

Bitwise OR operator for SharedBufferBindFlags.

Returns:: The union of lhs and rhs.

inline constexpr SharedBufferBindFlags operator&(const SharedBufferBindFlags lhs, const SharedBufferBindFlags rhs) noexcept#

Bitwise AND operator for SharedBufferBindFlags.

Returns:: The intersection of lhs and rhs.

bool computeUltrasoundProbeLayout(const UltrasoundProbeComponent &probeComponent, const UltrasoundRendererComponent &rendererComponent, UltrasoundProbeLayout &outLayout)#

Computes the output image layout implied by ultrasound probe and renderer settings.

Parameters:

probeComponent – Probe configuration. It must be enabled.
rendererComponent – Renderer configuration that determines requested output dimensions.
outLayout – Receives an empty layout on failure.

Returns:

False when ultrasound support is unavailable, the probe is disabled, or the underlying ultrasound engine cannot be configured.

struct CameraComponent#

#include <components.h>

Camera component defining projection, view targets, and rendering modes.

Public Types

enum class Product : std::uint32_t#

Output product modes rendered by the camera.

Values:

enumerator ColorDepth#: Standard RGBA color and depth output; supports ManagedPrimary.

enumerator Depth#: Single-channel depth output; requires an ExplicitSurface depth target.

enumerator SegmentationDepth#: Semantic mask and depth output; requires ExplicitSurface with color+depth and R32_UINT color.

enum class BackgroundMode : std::uint32_t#

Background clear modes for camera rendering.

Values:

enumerator ClearColor#: Solid clear color background.

enumerator EnvironmentCubemap#: Skybox / Image-Based Lighting cubemap background.

Public Members

float verticalFovDegrees = 60.0f#: Vertical Field-of-View in degrees.

float nearClip = 0.01f#: Near clipping plane distance.

float farClip = 1000.0f#: Far clipping plane distance.

Product product = Product::ColorDepth #: Rendered camera output product type.

gpu::RenderOutputBinding output = {}#: Target binding; ManagedPrimary accepts ColorDepth only.

std::uint32_t outputWidth = 0#: Optional explicit target width (0 for default).

std::uint32_t outputHeight = 0#: Optional explicit target height (0 for default).

gpu::GpuRenderViewport viewport = {}#: Normalized viewport; honored only for non-layered ExplicitSurface targets.

bool clearColor = true#: Whether to clear target color buffer before rendering.

bool clearDepth = true#: Whether to clear target depth buffer before rendering.

Diligent::float4 clearColorValue = {0.0f, 0.0f, 0.0f, 1.0f}#: Clear color RGBA values.

float clearDepthValue = 1.0f#: Clear depth value.

BackgroundMode backgroundMode#: Camera background rendering mode.

std::uint32_t renderOrder = 0#: Rendering priority order (ascending).

struct ColliderComponent#

#include <components.h>

Collider component attached to entities for physical collision queries and dynamics.

Public Members

physics::ColliderShapeType shapeType#: Collision primitive geometry shape type.

Diligent::float4 shapeParams#: Shape dimensions (e.g. radius, box extents).

Diligent::float3 localPosition#: Local offset position relative to transform.

Diligent::QuaternionF localRotation#: Local offset rotation relative to transform.

bool enabled = true#: Active collision state.

float friction = 0.0f#: Dynamic friction coefficient.

float staticFriction = -1.0f#: Static friction coefficient (-1 to reuse dynamic friction).

float restitution = 0.0f#: Coefficient of restitution (bounciness).

std::uint32_t collisionLayer = 1u#: Bitmask collision layer.

std::uint32_t collisionMask = 0xffffffffu#: Bitmask collision filtering mask.

struct ColliderHandle#

#include <components.h>

Lightweight handle wrapper for a physics collider instance.

Public Functions

inline bool isValid() const noexcept#

Checks if the collider handle is valid.

Returns:: True if valid, false otherwise.

Public Members

physics::ColliderId id = physics::kInvalidColliderId #: Unique collider ID.

struct ConstraintLayoutMapping#

#include <constraint_layout_mapping.h>

Complete prepared mapping for the supported rigid-adjacent constraint families.

Public Members

std::uint64_t layoutRevision = 0u#: Prepared host-side constraint-layout invalidation key produced by prepare(). This describes when authored slot interpretation changes and is not the same as the live GPU custom-compute resource bindingGeneration exposed after uploadWorld().

RigidParticleAttachmentConstraintLayoutMapping rigidParticleAttachments#: Attachments.

RigidDistanceConstraintLayoutMapping rigidDistanceConstraints#: Distances.

RoutedCableConstraintLayoutMapping routedCables#: Routed cables.

struct CustomComputeDispatchDesc#

#include <custom_compute.h>

Dispatch execution parameters for custom compute passes.

Public Members

CustomComputeDispatchMode mode#: Dispatch mode.

std::uint32_t groupCountX = 1u#: Dispatch thread group count along X dimension.

std::uint32_t groupCountY = 1u#: Dispatch thread group count along Y dimension.

std::uint32_t groupCountZ = 1u#: Dispatch thread group count along Z dimension.

std::string countResourceKey#: Listed resource key used by ResourceElementCount mode.

struct CustomComputePassDesc#

#include <custom_compute.h>

Complete descriptor for compiling and instantiating a custom compute shader pass.

Set exactly one of shaderPath and shaderSource. File-based shaders require shaderDirectory; every pass needs at least one resource binding and non-zero thread-group dimensions.

Public Members

std::string debugName#: Debug label for diagnostics.

std::filesystem::path shaderDirectory#: Root directory for shader source files.

std::string shaderPath#: File source path relative to shaderDirectory.

std::string shaderSource#: Alternative in-memory HLSL source.

std::vector<std::filesystem::path> includeDirectories#: Custom shader search paths for HLSL includes.

std::string entryPoint = "main"#: Shader entry point function name.

std::uint32_t threadGroupSizeX = 1u#: Workgroup size X dimension.

std::uint32_t threadGroupSizeY = 1u#: Workgroup size Y dimension.

std::uint32_t threadGroupSizeZ = 1u#: Workgroup size Z dimension.

std::vector<CustomComputeResourceBindingDesc> resourceBindings#: Non-empty resource bindings.

std::string constantBufferVariableName#: Empty to omit a constant buffer.

std::uint32_t constantBufferSizeBytes = 0u#: Requested constant-buffer size in bytes.

std::vector<std::uint8_t> constantData#: Initial bytes; size also contributes to allocation.

CustomComputeDispatchDesc dispatch = {}#: Dispatch parameters.

struct CustomComputePassHandle#

#include <custom_compute.h>

Handle wrapper identifying a registered custom compute shader pass.

Public Functions

inline bool isValid() const noexcept#

Checks if the custom compute pass handle is valid.

Returns:: True if valid, false otherwise.

Public Members

std::uint64_t id = 0u#: Unique handle identifier.

struct CustomComputeResourceBindingDesc#

#include <custom_compute.h>

Binding descriptor mapping exactly one supported resource source to a shader variable.

Public Members

std::string shaderVariableName#: HLSL shader variable name.

std::string resourceKey#: Key returned by listCustomComputeResources().

SharedBufferHandle sharedBufferHandle = {}#: Alternative engine-owned shared buffer source.

gpu::GpuRenderTargetBinding renderTargetBinding = {}#: Alternative shader-readable target.

gpu::GpuRenderTargetTexturePlane renderTargetTexturePlane#: Texture plane selection (Color, Depth).

CustomComputeResourceAccess access#: Requested access; render targets support read-only only.

struct CustomComputeResourceDesc#

#include <custom_compute.h>

Metadata descriptor for a custom compute GPU resource.

Public Members

std::string key#: Resource key used by CustomComputeResourceBindingDesc::resourceKey.

CustomComputeResourceKind kind#: Resource type kind (Buffer, Texture).

CustomComputeResourceAccess access = CustomComputeResourceAccess::ReadOnly #: Access mode.

std::uint32_t elementCount = 0u#: Number of elements in resource.

std::uint32_t elementStrideBytes = 0u#: Stride per element in bytes.

std::uint64_t bindingGeneration#: Changes when the underlying GPU binding is replaced; recreate dependent passes.

struct DirectionalLightComponent#

#include <components.h>

Directional light source for global scene illumination and shadow mapping.

Public Members

Diligent::float3 direction = {0.0f, -1.0f, 0.0f}#: Light direction vector.

Diligent::float3 color = {1.0f, 1.0f, 1.0f}#: Light color RGB values.

float intensity = 1.0f#: Illumination intensity multiplier.

float range = 0.0f#: Currently unused for directional lights.

float shadowDistance = 50.0f#: Maximum shadow rendering distance.

float shadowFadeDistance = 20.0f#: Distance over which shadows fade out.

float shadowBias = 0.0015f#: Shadow depth comparison bias.

bool castsShadows = true#: Enable shadow map generation.

struct EntityPoseMappingEntry#

#include <render_scene_types.h>

Maps one pose in a source pose buffer to one pose slot in the entity scene.

The two reserved fields are part of the GPU buffer layout and must be zero.

Public Members

std::uint32_t sourcePoseIndex = 0#: Index into the source pose buffers.

std::uint32_t entityPoseIndex = 0#: Destination entity-pose slot.

std::uint32_t reserved0 = 0#: Reserved; set to zero.

std::uint32_t reserved1 = 0#: Reserved; set to zero.

struct FluidComponent#

#include <components.h>

Particle-based fluid simulation component (SPH / Position-Based Fluids).

Public Members

physics::FluidSourceDesc source = {}#: Fluid particle emitter/initializer source descriptor.

physics::FluidMaterialDesc material = {}#: Fluid material properties (viscosity, surface tension).

Diligent::float4 visualColor#: Visual RGBA color for fluid rendering.

float particleMass = 1.0f#: Fluid particle mass.

float particleRadius = 0.125f#: Particle interaction radius.

std::uint32_t collisionLayer = 1u#: Collision layer.

std::uint32_t collisionMask = 0xffffffffu#: Collision mask.

struct JointLayoutMapping#

#include <joint_layout_mapping.h>

Prepared parallel arrays mapping rigid-joint definitions to rigid-body slots.

Public Members

std::uint32_t ballJointCount = 0u#: Number of ball-joint slots.

std::uint32_t hingeJointCount = 0u#: Number of hinge-joint slots.

std::uint32_t sphericalJointCount = 0u#: Number of spherical-joint slots.

std::uint32_t sliderJointCount = 0u#: Number of slider-joint slots.

std::uint64_t layoutRevision = 0u#: Prepared host-side rigid-joint slot-layout invalidation key produced by prepare(). This describes when authored slot interpretation changes and is not the same as the live GPU custom-compute resource bindingGeneration exposed after uploadWorld().

std::vector<physics::BallJointId> ballJointIds#: Ball-joint IDs, indexed by ball-joint slot.

std::vector<std::uint32_t> ballEnvironmentIndices#: Environment of body A.

std::vector<physics::RigidBodyId> ballBodyIdsA#: First body IDs.

std::vector<physics::RigidBodyId> ballBodyIdsB#: Second body IDs.

std::vector<std::uint32_t> ballBodyIndicesA#: First body slots.

std::vector<std::uint32_t> ballBodyIndicesB#: Second body slots.

std::vector<physics::HingeJointId> hingeJointIds#: Hinge-joint IDs, indexed by hinge-joint slot.

std::vector<std::uint32_t> hingeEnvironmentIndices#: Environment of body A.

std::vector<physics::RigidBodyId> hingeBodyIdsA#: First body IDs.

std::vector<physics::RigidBodyId> hingeBodyIdsB#: Second body IDs.

std::vector<std::uint32_t> hingeBodyIndicesA#: First body slots.

std::vector<std::uint32_t> hingeBodyIndicesB#: Second body slots.

std::vector<physics::SphericalJointId> sphericalJointIds#: Spherical-joint IDs, indexed by spherical-joint slot.

std::vector<std::uint32_t> sphericalEnvironmentIndices#: Environment of body A.

std::vector<physics::RigidBodyId> sphericalBodyIdsA#: First body IDs.

std::vector<physics::RigidBodyId> sphericalBodyIdsB#: Second body IDs.

std::vector<std::uint32_t> sphericalBodyIndicesA#: First body slots.

std::vector<std::uint32_t> sphericalBodyIndicesB#: Second body slots.

std::vector<physics::SliderJointId> sliderJointIds#: Slider-joint IDs, indexed by slider-joint slot.

std::vector<std::uint32_t> sliderEnvironmentIndices#: Environment of body A.

std::vector<physics::RigidBodyId> sliderBodyIdsA#: First body IDs.

std::vector<physics::RigidBodyId> sliderBodyIdsB#: Second body IDs.

std::vector<std::uint32_t> sliderBodyIndicesA#: First body slots.

std::vector<std::uint32_t> sliderBodyIndicesB#: Second body slots.

struct MeshfreeSoftBodyComponent#

#include <components.h>

Meshfree / particle-based soft body component for point cloud elastic simulation.

Public Members

std::vector<Diligent::float3> particles#: Particle rest position list.

std::vector<Diligent::float3> surfaceRestPositions#: Surface mesh rest position coordinates.

std::vector<Diligent::float3> surfaceNormals#: Surface mesh normal vectors.

std::vector<Diligent::uint3> surfaceTriangles#: Surface mesh triangle indices.

std::vector<std::uint32_t> staticParticleIndices#: Particle indices fixed in space.

physics::SoftBodyMaterialDesc material = {}#: Material property descriptor.

float particleRadius = 0.001f#: Particle radius.

float particleMass = 0.001f#: Mass per particle.

std::uint32_t neighbourCount = 12u#: Particle neighbor interaction count.

float compliance = 1.0e-6f#: Constraint compliance parameter.

bool selfCollisionEnabled = false#: Enable self-collision.

std::uint32_t collisionLayer = 1u#: Collision layer.

std::uint32_t collisionMask = 0xffffffffu#: Collision mask.

struct MeshRendererComponent#

#include <components.h>

Mesh renderer component binding a 3D mesh and material for visual rendering.

Public Members

graphics::MeshHandle mesh = {}#: Handle to the geometry mesh resource.

graphics::MaterialHandle material = {}#: Handle to the visual material resource.

std::uint32_t segmentationId = 0u#: ID for semantic image segmentation passes.

bool visible = true#: Visibility flag for camera rendering.

struct ParticleLayoutMapping#

#include <particle_layout_mapping.h>

Prepared parallel arrays mapping particles and deformable owners to GPU slot layout.

Public Members

std::uint32_t particleCount = 0u#: Number of particle slots.

std::uint32_t softBodyCount = 0u#: Number of soft-body owner slots.

std::uint32_t fluidCount = 0u#: Number of fluid owner slots.

std::uint32_t strandCount = 0u#: Number of strand owner slots.

std::uint64_t layoutRevision = 0u#: Prepared host-side particle/deformable slot-layout invalidation key produced by prepare(). This describes when authored slot interpretation changes and is not the same as the live GPU custom-compute resource bindingGeneration exposed after uploadWorld().

std::vector<std::uint32_t> environmentIndices#: Environment indices, indexed by particle slot in [0, particleCount).

std::vector<std::uint32_t> particleKinds#: Numeric particle-kind values.

std::vector<std::uint32_t> ownerTypes#: Numeric owner-type values.

std::vector<std::uint32_t> ownerIndices#: Owner slots within their owner type.

std::vector<std::uint32_t> strandIds#: Strand IDs where applicable.

std::vector<std::uint32_t> strandOrders#: Ordinal positions within strands.

std::vector<std::uint32_t> strandRoles#: Numeric strand-role values.

std::vector<std::uint32_t> owningSoftBodyIndices#: Owning soft-body slots where applicable.

std::vector<std::uint32_t> particleMaterialIndices#: Particle material slots.

std::vector<std::uint32_t> fluidMaterialIndices#: Fluid material slots.

std::vector<std::uint32_t> phases#: Particle phase values.

std::vector<std::uint32_t> collisionLayers#: Collision layer masks.

std::vector<std::uint32_t> collisionMasks#: Collision filter masks.

std::vector<std::uint32_t> adjacencyOffsets#: Offsets into physics adjacency data.

std::vector<std::uint32_t> adjacencyCounts#: Adjacency counts.

std::vector<common::EntityId> softBodyEntityIds#: Owning entity IDs, indexed by soft-body slot.

std::vector<std::uint32_t> softBodyEnvironmentIndices#: Environment indices.

std::vector<std::uint32_t> softBodyParticleOffsets#: First particle slots.

std::vector<std::uint32_t> softBodyParticleCounts#: Particle counts.

std::vector<common::EntityId> fluidEntityIds#: Owning entity IDs, indexed by fluid slot.

std::vector<std::uint32_t> fluidEnvironmentIndices#: Environment indices.

std::vector<std::uint32_t> fluidParticleOffsets#: First particle slots.

std::vector<std::uint32_t> fluidParticleCounts#: Particle counts.

std::vector<common::EntityId> strandEntityIds#: Owning entity IDs, indexed by strand slot.

std::vector<std::uint32_t> strandEnvironmentIndices#: Environment indices.

std::vector<std::uint32_t> strandParticleOffsets#: First particle slots.

std::vector<std::uint32_t> strandParticleCounts#: Particle counts.

struct PointLightComponent#

#include <components.h>

Point light source emitting light uniformly in all directions.

Public Members

Diligent::float3 color = {1.0f, 1.0f, 1.0f}#: Light color RGB values.

float intensity = 1.0f#: Illumination intensity multiplier.

float range = 10.0f#: Attenuation distance range.

float shadowBias = 0.0015f#: Shadow depth bias.

bool castsShadows = false#: Enable shadow map generation.

struct ProceduralDeformableCurveRenderComponent#

#include <components.h>

Procedural render component for generating tube meshes along deformable curves (strands/sutures).

Public Members

physics::ParticleSequenceId sequenceId#: Target particle sequence ID.

float radius = 0.05f#: Tube mesh cross-section radius.

std::uint32_t radialResolution = 8u#: Number of radial tube segments.

bool enabled = true#: Enable rendering.

class RenderSceneUploader#

#include <render_scene_uploader.h>

Public Functions

explicit RenderSceneUploader(gpu::GpuDevice &device)#: Creates an uploader associated with device. Call initialize() before use.

~RenderSceneUploader()#: Releases uploader resources.

bool initialize(const common::SceneLayoutDesc &layout = common::SceneLayoutDesc{})#

Initializes GPU scene buffers and the physics-to-render pose synchronization pass.

Parameters:: layout – Per-environment scene capacities used to size GPU buffers.
Returns:: False when compatible graphics and physics backend contexts or shader resources are unavailable.

void shutdown()#: Releases all GPU resources and resets this uploader to its uninitialized state.

bool uploadEntityPoseData(const std::vector<Diligent::float4> &positions, const std::vector<Diligent::float4> &orientations, const std::vector<Diligent::float4> &scales)#

Uploads complete entity pose arrays to the shared entity-scene pose buffers.

Returns:: False unless initialized, all three arrays have equal length, and the physics backend is available.

bool applyMappedEntityPoses(const common::PoseBufferView &sourcePoses, const std::vector<EntityPoseMappingEntry> &mappings)#

Dispatches a GPU copy of selected source poses into entity-scene pose slots.

Parameters:

sourcePoses – Source GPU pose buffers. All three buffers and a non-zero count are required when mappings is non-empty.
mappings – Source-to-destination pose mappings to apply.

Returns:

False when uninitialized, required buffers/backend resources are unavailable, or the synchronization dispatch cannot be submitted.

bool uploadRenderableMetadata(const std::vector<graphics::GpuRenderableMetadata> &renderables)#: Uploads renderable metadata; an empty vector clears the recorded renderable count.

bool uploadRenderableQueueInfo(const std::vector<graphics::GpuRenderableQueueInfo> &queueInfo)#: Uploads render-queue information for renderable slots.

bool uploadSoftBodyVertexBindings(const std::vector<graphics::GpuSoftBodyVertexBinding> &bindings)#: Uploads soft-body vertex-to-particle bindings.

bool uploadCameraInputs(const std::vector<graphics::GpuCameraInput> &cameras)#: Uploads camera inputs; an empty vector clears the recorded camera count.

bool uploadLightInputs(const std::vector<graphics::GpuLightInput> &lights)#: Uploads light inputs; an empty vector clears the recorded light count.

bool uploadLocalLightSelections(const std::vector<graphics::GpuLocalLightSelection> &selections)#: Uploads per-renderable local-light selections.

graphics::GpuEntitySceneView sceneView() const noexcept#: Returns a non-owning view of the internally managed GPU entity scene.

graphics::GpuEntitySceneView sceneView(const common::PoseBufferView &poses, std::uint32_t entityCount) const noexcept#: Returns a scene view that uses caller-supplied pose buffers with this uploader’s uploaded renderable, camera, and light buffers.

const common::SceneLayoutDesc &layout() const noexcept#: Returns the layout supplied to initialize(), or the default layout after shutdown.

struct RigidBodyComponent#

#include <components.h>

Rigid body component defining linear/angular velocity, mass properties, and kinematic targets.

Public Members

Diligent::float3 linearVelocity = {0.0f, 0.0f, 0.0f}#: Linear velocity vector.

Diligent::float3 angularVelocity = {0.0f, 0.0f, 0.0f}#: Angular velocity vector.

Diligent::float3 inverseInertiaLocal#: Local inverse inertia tensor diagonal.

std::vector<Diligent::float3> proxyParticleLocalPositions = {}#: Local positions of proxy particles.

physics::ParticleContactMaterialDesc proxyParticleMaterial = {}#: Proxy particle contact material properties.

physics::RigidBodyType bodyType#: Rigid body type (Dynamic, Static, Kinematic).

float inverseMass = 1.0f#: Inverse mass (1/kg).

float proxyParticleRadius = 0.0f#: Radius of proxy collision particles.

std::uint32_t proxyCollisionLayer = 1u#: Bitmask collision layer for proxy particles.

std::uint32_t proxyCollisionMask = 0xffffffffu#: Bitmask collision mask for proxy particles.

bool suturingEnabled = false#: Enable surgical suturing needle proxy interactions.

std::uint32_t needleTipProxyIndex = 0u#: Proxy particle index representing needle tip.

Diligent::float3 kinematicTargetPosition#: Kinematic target position for interpolation.

Diligent::QuaternionF kinematicTargetRotation#: Kinematic target orientation quaternion.

bool kinematicTargetEnabled = false#: Enable kinematic target positioning.

struct RigidDistanceConstraintLayoutMapping#

#include <constraint_layout_mapping.h>

Prepared parallel arrays describing rigid-distance constraints.

Every vector is indexed by constraint slot in [0, count).

Public Members

std::uint32_t count = 0u#: Number of rigid-distance constraint slots.

std::vector<physics::RigidDistanceConstraintId> constraintIds#: Constraint IDs.

std::vector<std::uint32_t> environmentIndices#: Environment of body A.

std::vector<physics::RigidBodyId> rigidBodyIdsA#: First rigid-body IDs.

std::vector<physics::RigidBodyId> rigidBodyIdsB#: Second rigid-body IDs.

std::vector<std::uint32_t> rigidBodyIndicesA#: Prepared slots for body A.

std::vector<std::uint32_t> rigidBodyIndicesB#: Prepared slots for body B.

std::vector<std::uint32_t> enabledFlags#: One for enabled constraints and zero otherwise.

struct RigidLayoutMapping#

#include <rigid_layout_mapping.h>

Prepared parallel arrays mapping rigid bodies and colliders to their GPU slot layout.

Public Members

std::uint32_t rigidBodyCount = 0u#: Number of rigid-body slots.

std::uint32_t colliderCount = 0u#: Number of collider slots.

std::uint64_t layoutRevision = 0u#: Prepared host-side rigid/collider slot-layout invalidation key produced by prepare(). This describes when authored slot interpretation changes and is not the same as the live GPU custom-compute resource bindingGeneration exposed after uploadWorld().

std::vector<physics::RigidBodyId> rigidBodyIds#: Rigid-body IDs, indexed by rigid-body slot in [0, rigidBodyCount).

std::vector<common::EntityId> rigidBodyEntityIds#: Entities owning rigid bodies.

std::vector<std::uint32_t> rigidBodyEnvironmentIndices#: Environment indices.

std::vector<physics::ColliderId> colliderIds#: Collider IDs, indexed by collider slot in [0, colliderCount).

std::vector<common::EntityId> colliderEntityIds#: Entities owning colliders.

std::vector<physics::RigidBodyId> colliderOwnerBodyIds#: Owning rigid-body IDs.

std::vector<std::uint32_t> colliderOwnerBodyIndices#: Owning rigid-body slots.

std::vector<std::uint32_t> colliderEnvironmentIndices#: Environment indices.

std::vector<std::uint32_t> colliderShapeTypes#: Numeric ColliderShapeType values.

std::vector<std::uint32_t> colliderEnabledFlags#: One for enabled colliders, zero otherwise.

std::vector<std::uint32_t> colliderCollisionLayers#: Collision layer masks.

std::vector<std::uint32_t> colliderCollisionMasks#: Collision filter masks.

std::vector<Diligent::float3> colliderLocalPositions#: Body-local positions.

std::vector<Diligent::QuaternionF> colliderLocalRotations#: Body-local orientations.

std::vector<Diligent::float4> colliderShapeParams#: Shape-specific parameters.

std::vector<std::uint32_t> bodyColliderOffsets#: First flattened collider index per body, indexed by rigid-body slot.

std::vector<std::uint32_t> bodyColliderCounts#: Collider count per body.

std::vector<std::uint32_t> bodyColliderIndices#: Flattened collider slots.

struct RigidParticleAttachmentConstraintLayoutMapping#

#include <constraint_layout_mapping.h>

Prepared parallel arrays describing rigid-particle attachment constraints.

Every vector except where noted is indexed by constraint slot in [0, count).

Public Members

std::uint32_t count = 0u#: Number of attachment-constraint slots.

std::vector<physics::RigidParticleAttachmentConstraintId> constraintIds#: This prepared mapping reflects authored host-side references resolved by prepare(). Runtime GPU edits to the live rigid-particle attachment descriptor buffer after uploadWorld() (for example retargeting particleIndex) do not feed back into these arrays until the host reauthors and prepares again.

std::vector<std::uint32_t> environmentIndices#: Owning rigid body’s environment indices.

std::vector<physics::RigidBodyId> rigidBodyIds#: Referenced rigid-body IDs.

std::vector<std::uint32_t> rigidBodyIndices#: Prepared rigid-body slot indices.

std::vector<common::EntityId> particleEntityIds#: Entities owning referenced particles.

std::vector<std::uint32_t> particleReferenceTypes#: Numeric particle-reference types.

std::vector<std::uint32_t> particleLocalIndices#: Particle indices local to their owners.

std::vector<std::uint32_t> enabledFlags#: One for enabled constraints and zero otherwise.

struct RoutedCableConstraintLayoutMapping#

#include <constraint_layout_mapping.h>

Prepared arrays describing routed-cable constraints and their flattened route points.

Public Members

std::uint32_t count = 0u#: Number of routed-cable constraint slots.

std::vector<physics::RoutedCableConstraintId> constraintIds#: Constraint IDs, indexed by constraint slot in [0, count).

std::vector<std::uint32_t> environmentIndices#: First resolved route-point environment.

std::vector<std::uint32_t> routePointOffsets#: Offsets into flattened route-point arrays.

std::vector<std::uint32_t> routePointCounts#: Number of route points per constraint.

std::vector<std::uint32_t> enabledFlags#: One for enabled constraints and zero otherwise.

std::vector<physics::RigidBodyId> routePointRigidBodyIds#: Route-point body IDs in the flattened arrays addressed by offsets and counts above.

std::vector<std::uint32_t> routePointRigidBodyIndices#: Prepared route-point body slots.

std::vector<Diligent::float3> routePointLocalGuideOffsets#: Body-local guide offsets.

class Runtime#

#include <runtime.h>

Main engine runtime coordinator managing GPU devices, physics solvers, graphics, and custom compute passes.

Public Functions

Runtime()#: Constructs an uninitialized runtime.

~Runtime()#: Shuts down the runtime if necessary.

Runtime(const Runtime&) = delete#

Runtime &operator=(const Runtime&) = delete#

Runtime(Runtime&&) = delete#

Runtime &operator=(Runtime&&) = delete#

bool initialize(const RuntimeConfig &config = RuntimeConfig{})#

Initializes the engine runtime with the specified configuration parameters.

Parameters:: config – Runtime configuration options including GPU, physics, and renderer settings.
Returns:: True if initialization succeeds; false otherwise.

void shutdown()#: Shuts down the engine runtime and releases allocated GPU/physics resources.

void prepare()#

Prepares authored world and render state for GPU upload.

Call uploadWorld() after this method and before stepPhysics() or custom-compute execution. Does nothing before initialize().

bool uploadWorld()#

Uploads the prepared physics and render scene state to GPU resources.

Returns:: True if all required uploads succeed; false before initialize().

bool stepPhysics(const common::FrameContext &frameContext)#

Advances physics using the supplied frame context.

Requires a successful uploadWorld() call after the most recent prepare().

Returns:: True if the physics step succeeds.

bool stepSimulationSensors(const common::FrameContext &frameContext)#

Executes simulation-driven sensors, including ultrasound when configured.

Returns:: False before initialize() or if the ultrasound system reports failure.

void stepVisualSensors(const common::FrameContext &frameContext)#: Updates the GPU scene and renders visual sensors for the supplied frame.

Note

Does nothing before initialize().

void endFrame(const common::FrameContext &frameContext)#: Ends the active device frame and submits queued presentation/readback work.

Note

Does nothing before initialize() or when no device frame is active.

World &getWorld() noexcept#: Returns the runtime-owned world.

const World &getWorld() const noexcept#: Returns the runtime-owned world.

gpu::GpuDevice *getGpuDevice() noexcept#: Returns the GPU device, or nullptr before initialization and after shutdown.

const gpu::GpuDevice *getGpuDevice() const noexcept#: Returns the GPU device, or nullptr before initialization and after shutdown.

physics::PhysicsSolver *getPhysicsSolver() noexcept#: Returns the physics solver, or nullptr before initialization and after shutdown.

const physics::PhysicsSolver *getPhysicsSolver() const noexcept#: Returns the physics solver, or nullptr before initialization and after shutdown.

void setGravity(const Diligent::float3 &gravity) noexcept#

Sets gravity for the initialized physics solver.

Parameters:: gravity – Gravity acceleration vector.

const graphics::RenderStats &lastRenderStats() const noexcept#: Returns statistics from the most recent visual-sensor render.

void setRenderFrameOptions(const graphics::RenderFrameOptions &options) noexcept#

Sets options applied to subsequent visual-sensor renders.

Parameters:: options – Per-frame rendering options.

const graphics::RenderFrameOptions &renderFrameOptions() const noexcept#: Returns options applied to visual-sensor renders.

graphics::RenderResourceManager &getResources() noexcept#: Returns the runtime-owned render resource manager.

const graphics::RenderResourceManager &getResources() const noexcept#: Returns the runtime-owned render resource manager.

RuntimeInfo getInfo() const noexcept#: Returns engine version and optional feature support information.

SharedBufferHandle createSharedBuffer(const SharedBufferDesc &desc)#: Creates an engine-owned structured GPU buffer that can be bound in custom compute. When CUDA interop is available and the allocation is exportable, the same buffer can also be imported into CUDA/Torch through DLPack.

bool destroySharedBuffer(SharedBufferHandle handle)#: Destroys the runtime handle for a shared buffer. Exported DLPack tensors may keep the underlying storage alive until their consumer releases it.

std::vector<SharedBufferInfo> listSharedBuffers() const#: Lists currently registered shared-buffer handles and their metadata.

bool tryGetSharedBufferInfo(SharedBufferHandle handle, SharedBufferInfo &outInfo) const#: Queries metadata for one shared buffer handle.

bool tryGetSharedBufferCudaView(SharedBufferHandle handle, SharedBufferCudaView &outView) const#: Returns the CUDA-facing device pointer view for one shared buffer when CUDA interop is available and this buffer was successfully imported into CUDA.

bool syncSharedBufferToCuda(SharedBufferHandle handle)#: Inserts a GPU-side wait so subsequent CUDA/Torch work sees prior Vulkan/D3D compute writes. Fails when the shared buffer is not imported into CUDA.

bool syncSharedBufferFromCuda(SharedBufferHandle handle)#: Inserts a GPU-side wait so subsequent Vulkan/D3D compute work sees prior CUDA/Torch writes. Fails when the shared buffer is not imported into CUDA.

SharedBufferLease retainSharedBufferLease(SharedBufferHandle handle) const#: Retains the storage backing a shared buffer independently of its runtime handle. Keep the returned lease alive while an external consumer uses an exported buffer view.

bool tryGetPreparedRigidLayoutMapping(RigidLayoutMapping &outMapping) const#

Returns the current prepared rigid-body/collider slot mapping derived from authored state. This is valid after prepare() and does not require uploadWorld(). The returned layoutRevision is a prepared host-side slot-layout invalidation key and is separate from the live GPU custom-compute bindingGeneration exposed after uploadWorld().

Parameters:: outMapping – Receives an empty mapping when the runtime is uninitialized.
Returns:: False when the runtime or physics solver is unavailable.

bool tryGetPreparedConstraintLayoutMapping(ConstraintLayoutMapping &outMapping) const#

Returns the current prepared rigid-adjacent constraint mapping derived from authored state. This is valid after prepare() and does not require uploadWorld(). The returned layoutRevision is a prepared host-side slot-layout invalidation key and is separate from the live GPU custom-compute bindingGeneration exposed after uploadWorld().

Parameters:: outMapping – Receives an empty mapping when the runtime is uninitialized.
Returns:: False when the runtime or physics solver is unavailable.

bool tryGetPreparedParticleLayoutMapping(ParticleLayoutMapping &outMapping) const#

Returns the current prepared particle/deformable slot mapping derived from authored state. This is valid after prepare() and does not require uploadWorld(). The returned layoutRevision is a prepared host-side slot-layout invalidation key and is separate from the live GPU custom-compute bindingGeneration exposed after uploadWorld().

Parameters:: outMapping – Receives an empty mapping when the runtime is uninitialized.
Returns:: False when the runtime or physics solver is unavailable.

bool tryGetPreparedJointLayoutMapping(JointLayoutMapping &outMapping) const#

Returns the current prepared rigid-joint slot mapping derived from authored state for ball, hinge, spherical, and slider joints. This is valid after prepare() and does not require uploadWorld(). The returned layoutRevision is a prepared host-side slot-layout invalidation key and is separate from the live GPU custom-compute bindingGeneration exposed after uploadWorld().

Parameters:: outMapping – Receives an empty mapping when the runtime is uninitialized.
Returns:: False when the runtime or physics solver is unavailable.

bool computeUltrasoundProbeLayout(const UltrasoundProbeComponent &probeComponent, const UltrasoundRendererComponent &rendererComponent, UltrasoundProbeLayout &outLayout) const#

Computes an ultrasound output layout for probe and renderer components.

Parameters:

probeComponent – Ultrasound probe configuration.
rendererComponent – Ultrasound renderer configuration.
outLayout – Output layout to populate.

Returns:

True if layout computation succeeds.

std::vector<CustomComputeResourceDesc> listCustomComputeResources()#

Lists custom-compute resources registered for the uploaded world.

Returns:: Resource descriptors, or an empty vector when unavailable.

CustomComputePassHandle createCustomComputePass(const CustomComputePassDesc &desc)#

Compiles and registers a custom compute pass for the uploaded world.

Parameters:: desc – Compute-pass configuration.
Returns:: Registered pass handle, or an invalid handle if creation fails.

bool updateCustomComputePassConstants(CustomComputePassHandle handle, const std::vector<std::uint8_t> &data)#

Updates a custom compute pass’s constant-buffer data.

Parameters:

handle – Registered compute-pass handle.
data – Replacement constant-buffer bytes.

Returns:

False for an invalid handle, a pass without constants, or an oversized payload.

bool executeCustomComputePass(CustomComputePassHandle handle)#

Executes a registered custom compute pass for the uploaded world.

Parameters:: handle – Registered compute-pass handle.
Returns:: False if the pass or its required resources are unavailable or changed.

bool destroyCustomComputePass(CustomComputePassHandle handle)#

Destroys a registered custom compute pass.

Parameters:: handle – Registered compute-pass handle.
Returns:: True if the handle was registered.

struct RuntimeConfig#

#include <runtime.h>

Configuration descriptor for initializing the CRESSim-Neo engine runtime.

Public Members

gpu::GpuDeviceDesc gpuDeviceDesc = {}#: Desired GPU device configuration.

common::SceneLayoutDesc sceneLayout = {}#: Scene layout capacity settings.

graphics::RendererDesc rendererDesc = {}#: Graphics renderer parameters.

physics::PhysicsSolverDesc physicsDesc = {}#: Physics solver parameters.

struct RuntimeInfo#

#include <runtime.h>

Information structure holding engine version and optional feature support flags.

Public Members

std::string engineVersion#: Full semver engine version string.

std::uint32_t engineVersionMajor = 0u#: Major version number.

std::uint32_t engineVersionMinor = 0u#: Minor version number.

std::uint32_t engineVersionPatch = 0u#: Patch version number.

bool cudaInteropSupported = false#: True if CUDA interop is enabled and available.

bool ultrasoundSupported = false#: True if CRESSim-Ultrasound integration is available.

struct SharedBufferCudaView#

#include <shared_buffer.h>

View descriptor exposing CUDA device memory pointer and size for interop.

Public Functions

inline bool isValid() const noexcept#

Checks if the CUDA device view is valid.

Returns:: True if valid, false otherwise.

Public Members

void *devicePointer = nullptr#: Raw CUDA device pointer.

std::uint64_t sizeBytes = 0u#: Size of accessible device memory in bytes.

std::int32_t deviceOrdinal = -1#: CUDA device ordinal index.

struct SharedBufferDesc#

#include <shared_buffer.h>

Descriptor for creating an engine-owned shared GPU buffer.

Public Members

std::string debugName#: Debug label for GPU diagnostic tools.

std::uint32_t elementStrideBytes = 0u#: Non-zero stride per element in bytes.

std::uint32_t elementCount = 0u#: Non-zero initial element count.

std::uint32_t minimumCapacity = 0u#: Optional lower bound on allocated element capacity.

SharedBufferAccess access = SharedBufferAccess::ReadWrite #: Custom-compute access policy; bindFlags control GPU views.

SharedBufferBindFlags bindFlags#: Must not be None.

struct SharedBufferHandle#

#include <shared_buffer.h>

Handle wrapper identifying an engine-owned shared GPU buffer.

Public Functions

inline bool isValid() const noexcept#

Checks if the shared buffer handle is valid.

Returns:: True if valid, false otherwise.

Public Members

std::uint64_t id = 0u#: Unique handle identifier.

struct SharedBufferInfo#

#include <shared_buffer.h>

Detailed information and runtime state for a shared GPU buffer.

Public Members

SharedBufferHandle handle = {}#: Buffer handle.

std::string debugName#: Debug label.

std::uint32_t elementStrideBytes = 0u#: Element stride in bytes.

std::uint32_t elementCount = 0u#: Current element count.

std::uint32_t capacity = 0u#: Total element capacity.

std::uint64_t sizeBytes = 0u#: Total allocated size in bytes.

SharedBufferAccess access#: Declared custom-compute access policy.

SharedBufferBindFlags bindFlags = SharedBufferBindFlags::None #: Binding flags.

bool exportable = false#: True if buffer is exportable for CUDA/DLPack interop.

bool importedIntoCuda = false#: True if buffer is currently imported into CUDA.

class SharedBufferLease#

#include <shared_buffer.h>

RAII lease keeping shared GPU buffer memory alive across external DLPack/Torch consumers.

Public Functions

SharedBufferLease() = default#

inline bool isValid() const noexcept#

Checks if the buffer lease is active and valid.

Returns:: True if valid, false otherwise.

struct SharedBufferTensorDesc#

#include <shared_buffer.h>

Tensor metadata descriptor for exporting a shared buffer to DLPack / PyTorch.

The Python export API requires a non-empty shape and byte-aligned, non-zero dtype metadata.

Public Members

std::vector<std::int64_t> shape#: Tensor dimensions shape array.

std::vector<std::int64_t> strides#: Tensor strides array.

SharedBufferTensorDTypeCode dtypeCode#: Element data type code.

std::uint8_t dtypeBits = 32u#: Element bit width (e.g. 32 for float32).

std::uint16_t dtypeLanes = 1u#: Vector lanes count per element.

std::uint64_t byteOffset = 0u#: Byte offset from buffer start.

struct SoftBodyAuthoringParticles#

#include <components.h>

Authoring particle position container for soft body asset creation.

Public Members

std::uint32_t particleCount = 0u#: Total particle count.

std::vector<Diligent::float3> restPositions = {}#: Rest position coordinate array.

struct SoftBodyComponent#

#include <components.h>

Soft body component supporting tetrahedral and meshfree particle sources.

Public Members

physics::SoftBodySourceDesc source = {}#: Source mesh file or tetrahedral asset descriptor.

physics::SoftBodyMaterialDesc material = {}#: Particle contact material parameters.

float particleMass = 1.0f#: Mass per node particle.

float particleRadius = 0.125f#: Collision radius per particle.

float edgeCompliance#: Extended Position Based Dynamics (XPBD) edge constraint compliance.

float volumeCompliance = 0.001f#: XPBD volume conservation constraint compliance.

bool selfCollisionEnabled = false#: Enable internal self-collision handling.

bool supportsSuturing = false#: Enable surgical thread suturing insertion.

std::uint32_t collisionLayer = 1u#: Collision bitmask layer.

std::uint32_t collisionMask = 0xffffffffu#: Collision bitmask filter.

struct SpotLightComponent#

#include <components.h>

Spot light source emitting a cone of light in a specified direction.

Public Members

Diligent::float3 direction = {0.0f, -1.0f, 0.0f}#: Spot light emission direction.

Diligent::float3 color = {1.0f, 1.0f, 1.0f}#: Light color RGB values.

float intensity = 1.0f#: Illumination intensity multiplier.

float range = 10.0f#: Attenuation distance range.

float innerConeAngle = 25.0f#: Inner full-intensity cone angle (degrees).

float outerConeAngle = 35.0f#: Outer zero-intensity cone angle (degrees).

float shadowBias = 0.0015f#: Shadow depth bias.

bool castsShadows = false#: Enable shadow map generation.

struct StrandComponent#

#include <components.h>

1D elastic strand component for surgical threads and sutures.

Public Members

physics::StrandMaterialDesc material = {}#: Particle contact material parameters.

std::vector<Diligent::float3> restPositions = {}#: Rest positions of strand particles.

std::vector<std::uint32_t> staticParticleIndices#: Fixed node particle indices.

float particleMass = 1.0f#: Mass per strand node particle.

float particleRadius = 0.125f#: Collision radius per strand node.

float stretchShearCompliance = 0.0f#: Stretching and shearing constraint compliance.

float bendCompliance = 0.0f#: Bending constraint compliance.

float twistCompliance = 0.0f#: Torsional twisting compliance.

float distanceCompliance = 0.0f#: Distance constraint compliance.

Diligent::float3 rootMaterialNormal#: Normal vector at strand root constraint.

bool selfCollisionEnabled = false#: Enable strand self-collision.

bool suturingEnabled = false#: Enable suturing path tracking.

float pathNodeSpacing = 0.2f#: Node spacing along suturing path.

std::uint32_t collisionLayer = 1u#: Collision layer.

std::uint32_t collisionMask = 0xffffffffu#: Collision mask.

struct TransformComponent#

#include <components.h>

World transform component for spatial positioning, orientation, and scaling.

Public Members

common::Transform worldTransform = {}#: 3D world-space translation, rotation, and scale.

struct UltrasoundAmplitudeRange#

#include <components.h>

Signal amplitude range for ultrasound acoustic scatterer reflections.

Public Members

float minimum = 0.0f#: Minimum signal amplitude.

float maximum = 0.0f#: Maximum signal amplitude.

struct UltrasoundProbeComponent#

#include <components.h>

Ultrasound transducer probe component for simulated B-mode ultrasound imaging.

Public Types

enum class Geometry : std::uint32_t#

Ultrasound transducer probe array geometry type.

Values:

enumerator Linear#: Linear array transducer.

enumerator Curvilinear#: Convex / curvilinear array transducer.

Public Members

bool enabled = true#: Enable ultrasound beam simulation.

Geometry geometry = Geometry::Linear #: Transducer array geometry.

std::uint32_t numScanlines = 50u#: Number of acoustic scanlines.

float lineLength = 1.2f#: Scanline penetration depth.

float scanlineSpacing = 0.01f#: Spacing between adjacent scanlines.

float sectorAngleDegrees = 60.0f#: Sector sweep angle for curvilinear arrays.

float probeRadius = 0.35f#: Physical transducer head curvature radius.

float soundSpeed = 1540.0f#: Acoustic speed of sound in medium (m/s).

float worldUnitsPerMeter = 10.0f#: World unit scaling factor per meter.

float noiseAmplitude = 0.0f#: Thermal and speckle noise amplitude.

float samplingFrequency = 100e6f#: Acoustic RF signal sampling frequency (Hz).

float demodulationFrequency = 2.5e6f#: RF demodulation carrier frequency (Hz).

float centerFrequency = 2.5e6f#: Transducer center frequency (Hz).

float fractionalBandwidth = 0.2f#: Transducer fractional bandwidth.

float beamSigmaLateral = 0.001f#: Lateral acoustic beam profile Gaussian sigma.

float beamSigmaElevational = 0.001f#: Elevational acoustic beam profile Gaussian sigma.

std::uint32_t radialDecimation = 4u#: Radial decimation factor for image generation.

std::uint32_t threadsPerBlock = 128u#: CUDA compute block thread size.

std::uint32_t cudaNumStreams = 1u#: Number of concurrent CUDA streams.

std::uint32_t numTimeSamples = 0u#: RF time-domain samples per scanline.

bool useArcProjection = false#: Enable arc projection geometry.

bool enablePhaseDelay = true#: Enable phase delay beamforming.

struct UltrasoundProbeLayout#

#include <components.h>

Output layout descriptor for ultrasound probe imaging targets.

Public Members

std::uint32_t numScanlines = 0u#: Total scanlines in probe image.

std::uint32_t samplesPerScanline = 0u#: Acoustic samples per scanline.

std::uint32_t imageWidth = 0u#: Output B-mode image width (pixels).

std::uint32_t imageHeight = 0u#: Output B-mode image height (pixels).

Diligent::TEXTURE_FORMAT colorFormat#: Target texture format.

bool layeredOutputSupported = true#: Support for array/layered render targets.

struct UltrasoundProbeResult#

#include <components.h>

Execution result containing output handles and metadata for ultrasound probe simulation.

Public Members

bool prepared = false#: True if metadata/handles are published for current frame.

bool completed = false#: True if simulation completed for completedFrameIndex.

std::uint64_t completedFrameIndex#: Frame index corresponding to completed ultrasound output.

std::uint32_t numScanlines = 0u#: Scanline count in output.

std::uint32_t samplesPerScanline = 0u#: Samples per scanline.

std::uint64_t totalScattererCount = 0u#: Evaluated scatterer count.

std::uint32_t imageWidth = 0u#: Generated B-mode image width.

std::uint32_t imageHeight = 0u#: Generated B-mode image height.

gpu::GpuRenderTargetBinding imageBinding = {}#: Render target binding for generated B-mode texture.

struct UltrasoundRendererComponent#

#include <components.h>

Renderer binding component for ultrasound B-mode image output generation.

Public Members

bool enabled = true#: Active rendering state.

gpu::RenderOutputBinding output = {}#: Output target binding descriptor.

std::uint32_t outputWidth = 0u#: Output width in pixels.

std::uint32_t outputHeight = 0u#: Output height in pixels.

bool useFixedMaxNormalization = false#: Enable fixed maximum signal intensity normalization.

float fixedMaxSignal = 1.0f#: Fixed maximum signal normalization value.

struct UltrasoundScattererSourceComponent#

#include <components.h>

Scatterer point cloud source for generating tissue ultrasound acoustic backscatter.

Public Members

bool enabled = true#: Enable acoustic backscattering.

float density = 1000000.0f#: Acoustic scatterer point density per cubic meter.

float pointDistanceOverride = 0.0f#: Override spacing between scatterer points.

class UltrasoundSystem#

#include <ultrasound_system.h>

Public Functions

UltrasoundSystem(gpu::GpuDevice &device, physics::PhysicsSolver &physicsSolver)#: Creates an ultrasound system using the supplied GPU device and physics solver.

~UltrasoundSystem()#: Shuts down the system and releases per-probe resources.

bool initialize()#: Resets and initializes system state.

void shutdown()#: Releases probe runtimes, output targets, and CUDA bridge resources.

bool prepare(World &world)#

Prepares enabled probes and publishes their current output metadata to world.

Returns:: False only when the system is uninitialized or has been disabled after a fatal ultrasound setup failure; unavailable optional backends cause preparation to be skipped.

bool execute(const common::FrameContext &frameContext, World &world)#

Executes enabled ultrasound probes for frameContext and updates world results.

Returns:: False only when the system is uninitialized or disabled after a fatal setup error; unavailable optional backends cause execution to be skipped.

bool computeProbeLayout(const UltrasoundProbeComponent &probeComponent, const UltrasoundRendererComponent &rendererComponent, UltrasoundProbeLayout &outLayout) const#: Computes a probe output layout using the same rules as the free function.

class World#

#include <world.h>

Primary ECS scene graph container managing entities, components, graphics views, and physics bindings.

Public Types

using ColliderHandle = engine::ColliderHandle #

Public Functions

World()#: Constructs an empty world with the default scene layout.

~World()#: Releases world state.

World(const World &other)#: Deep-copies world state from other.

World &operator=(const World &other)#: Replaces this world with a deep copy of other.

World(World &&other) noexcept#: Transfers world state from other; the moved-from object is valid only for destruction or reassignment.

World &operator=(World &&other) noexcept#: Transfers world state from other; the moved-from object is valid only for destruction or reassignment.

common::EntityId createEntity(std::uint32_t envIndex = 0u)#

Creates a new entity within the world scene graph.

Parameters:: envIndex – Environment index for parallel RL environments (default: 0).
Returns:: Unique EntityId for the created entity, or kInvalidEntityId if envIndex is outside the configured environment count.

bool destroyEntity(common::EntityId entityId)#

Destroys an existing entity and removes all associated components.

Parameters:: entityId – Entity ID to destroy.
Returns:: True if entity was destroyed; false if invalid or not found.

void setSceneLayout(const common::SceneLayoutDesc &layout)#

Sets the scene layout capacities before any scene authoring occurs.

Note

Calls made after authoring has begun leave the existing layout unchanged.

Parameters:: layout – Scene layout descriptor.

const common::SceneLayoutDesc &sceneLayout() const noexcept#

Gets the current scene layout capacity descriptor.

Returns:: Reference to current SceneLayoutDesc.

bool setEntityEnvironment(common::EntityId entityId, std::uint32_t envIndex)#

Assigns an entity to a specific environment index, migrating its associated state.

Parameters:

entityId – Entity ID.
envIndex – Environment index.

Returns:

True if assignment succeeded; false for an invalid entity or environment index, or if associated state cannot be migrated.

std::uint32_t entityEnvironment(common::EntityId entityId) const noexcept#

Gets the environment index assigned to an entity.

Parameters:: entityId – Entity ID.
Returns:: Environment index, or zero when entityId is not alive.

bool setEnvironmentIbl(std::uint32_t envIndex, const graphics::EnvironmentIblDesc &desc)#

Configures Image-Based Lighting (IBL) environment maps for an environment index.

Parameters:

envIndex – Environment index.
desc – Environment IBL descriptor.

Returns:

True if configured successfully.

const graphics::EnvironmentIblDesc *tryGetEnvironmentIbl(std::uint32_t envIndex) const noexcept#

Gets the Environment IBL descriptor stored for an initialized environment index.

Parameters:: envIndex – Environment index.
Returns:: Pointer to EnvironmentIblDesc (including its default value when not explicitly configured), or nullptr if host scene storage has not been initialized for envIndex.

bool setEnvironmentFluid(std::uint32_t envIndex, const graphics::EnvironmentFluidDesc &desc)#

Configures environment fluid properties for an environment index.

Parameters:

envIndex – Environment index.
desc – Environment fluid descriptor.

Returns:

True if configured successfully.

const graphics::EnvironmentFluidDesc *tryGetEnvironmentFluid(std::uint32_t envIndex) const noexcept#

Gets the Environment fluid descriptor stored for an initialized environment index.

Parameters:: envIndex – Environment index.
Returns:: Pointer to EnvironmentFluidDesc (including its default value when not explicitly configured), or nullptr if host scene storage has not been initialized for envIndex.

bool isAlive(common::EntityId entityId) const#

Checks if an entity is alive and active in the world.

Parameters:: entityId – Entity ID to query.
Returns:: True if alive, false otherwise.

const std::vector<common::EntityId> &entities() const noexcept#

Returns the list of all active entity IDs in the world.

Returns:: Const reference to vector of active EntityIds.

void setTransform(common::EntityId entityId, const TransformComponent &component)#

Assigns or updates the TransformComponent for an entity.

On an entity with a rigid body, this immediately overwrites the body’s pose (a teleport); it does not create a kinematic target.

Parameters:

entityId – Target entity ID.
component – Transform component data.

void setMeshRenderer(common::EntityId entityId, const MeshRendererComponent &component)#

Assigns or updates the MeshRendererComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Mesh renderer component data.

void setCamera(common::EntityId entityId, const CameraComponent &component)#

Assigns or updates the CameraComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Camera component data.

void setDirectionalLight(common::EntityId entityId, const DirectionalLightComponent &component)#

Assigns or updates a DirectionalLightComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Directional light component data.

void setPointLight(common::EntityId entityId, const PointLightComponent &component)#

Assigns or updates a PointLightComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Point light component data.

void setSpotLight(common::EntityId entityId, const SpotLightComponent &component)#

Assigns or updates a SpotLightComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Spot light component data.

void setRigidBody(common::EntityId entityId, const RigidBodyComponent &component)#

Assigns or updates a RigidBodyComponent for an entity.

Parameters:

entityId – Target entity ID.
component – Rigid body component data.

bool removeRigidBody(common::EntityId entityId)#

Removes the RigidBodyComponent from an entity and removes its colliders.

Parameters:: entityId – Target entity ID.
Returns:: True if removed; false otherwise.

bool setSoftBody(common::EntityId entityId, const SoftBodyComponent &component)#

Assigns a SoftBodyComponent to an entity.

A successful replacement clears any authored ultrasound scatterer amplitude ranges for the entity because their required count depends on the soft body’s rest-particle set.

Parameters:

entityId – Target entity ID.
component – Soft body component data.

Returns:

True if set successfully.

bool setMeshfreeSoftBody(common::EntityId entityId, const MeshfreeSoftBodyComponent &component)#

Assigns a MeshfreeSoftBodyComponent to an entity.

Parameters:

entityId – Target entity ID.
component – Meshfree soft body component data.

Returns:

True if set successfully.

bool removeSoftBody(common::EntityId entityId)#

Removes the SoftBodyComponent and any authored ultrasound amplitude ranges.

Parameters:: entityId – Target entity ID.
Returns:: True if either the soft body or its amplitude ranges existed and was removed.

bool setStrand(common::EntityId entityId, const StrandComponent &component)#

Assigns a StrandComponent to an entity.

Parameters:

entityId – Target entity ID.
component – Strand component data.

Returns:

True if set successfully.

bool removeStrand(common::EntityId entityId)#

Removes the StrandComponent from an entity.

Parameters:: entityId – Target entity ID.
Returns:: True if removed; false otherwise.

void setProceduralDeformableCurveRender(common::EntityId entityId, const ProceduralDeformableCurveRenderComponent &component)#

Assigns a ProceduralDeformableCurveRenderComponent to an entity.

Parameters:

entityId – Target entity ID.
component – Procedural curve render component data.

bool removeProceduralDeformableCurveRender(common::EntityId entityId)#

Removes ProceduralDeformableCurveRenderComponent from an entity.

Parameters:: entityId – Target entity ID.
Returns:: True if removed; false otherwise.

bool setFluid(common::EntityId entityId, const FluidComponent &component)#

Assigns a FluidComponent to an entity.

Parameters:

entityId – Target entity ID.
component – Fluid component data.

Returns:

True if set successfully.

bool removeFluid(common::EntityId entityId)#

Removes the FluidComponent from an entity.

Parameters:: entityId – Target entity ID.
Returns:: True if removed; false otherwise.

physics::AuthoredParticleSequenceState &upsertParticleSequence(const physics::AuthoredParticleSequenceState &state)#

Creates or updates an authored particle sequence.

Parameters:: state – Sequence state to store.
Returns:: Reference to the stored sequence state.

physics::AuthoredParticleDistanceConstraintState &upsertParticleDistanceConstraint(const physics::AuthoredParticleDistanceConstraintState &state)#

Creates or updates an authored particle distance constraint.

An invalid or unknown ID creates a new constraint. Negative rest length and compliance are clamped to zero; particle references remain authored until derived state is rebuilt.

Parameters:: state – Constraint state to store.
Returns:: Reference to the stored constraint state.

bool upsertRigidParticleAttachmentConstraint(const physics::AuthoredRigidParticleAttachmentConstraintState &state, physics::AuthoredRigidParticleAttachmentConstraintState *outAuthored = nullptr)#

Creates or updates a rigid-particle attachment constraint.

Its referenced particle and rigid body must exist in the same environment. Negative compliance is clamped to zero.

Parameters:

state – Constraint state to store.
outAuthored – Optional output receiving the stored state.

Returns:

False for invalid/out-of-range references or different environments.

bool upsertStrandRigidAttachmentConstraint(const physics::AuthoredStrandRigidAttachmentConstraintState &state, physics::AuthoredStrandRigidAttachmentConstraintState *outAuthored = nullptr)#

Creates or updates a strand-rigid attachment constraint.

The strand segment and rigid body must exist in the same environment. segmentT is clamped to [0, 1], the local rotation is normalized, and negative compliance is clamped to zero.

Returns:: False for invalid references or different environments.

bool upsertRigidDistanceConstraint(const physics::AuthoredRigidDistanceConstraintState &state, physics::AuthoredRigidDistanceConstraintState *outAuthored = nullptr)#

Creates or updates a rigid distance constraint.

Bodies must be distinct and in the same environment. Negative rest distance and compliance are clamped to zero.

Returns:: False for invalid/same-body references or different environments.

bool upsertRoutedCableConstraint(const physics::AuthoredRoutedCableConstraintState &state, physics::AuthoredRoutedCableConstraintState *outAuthored = nullptr)#

Creates or updates a routed cable constraint.

The route needs at least two rigid-body guide points in one environment, with no consecutive duplicate bodies. Negative target length and compliance are clamped to zero.

Returns:: False for an invalid route or guide-body reference.

bool upsertBallJoint(const physics::BallJointState &state)#

Creates or updates a ball joint between two rigid-body entities.

Returns:: False unless both entities are alive, have rigid bodies, and share an environment.

bool upsertHingeJoint(const physics::HingeJointState &state)#

Creates or updates a hinge joint between two rigid-body entities.

Returns:: False unless both entities are alive, have rigid bodies, and share an environment.

bool upsertSphericalJoint(const physics::SphericalJointState &state)#

Creates or updates a spherical joint between two rigid-body entities.

Returns:: False unless both entities are alive, have rigid bodies, and share an environment.

bool upsertSliderJoint(const physics::SliderJointState &state)#

Creates or updates a slider joint between two rigid-body entities.

Returns:: False unless both entities are alive, have rigid bodies, and share an environment.

physics::AuthoredParticleCollisionFilterState &upsertParticleCollisionFilter(const physics::AuthoredParticleCollisionFilterState &state)#

Creates or updates an authored particle collision filter.

An invalid or unknown filter ID creates a new filter; a zero collision layer becomes 1.

physics::AuthoredSuturingSequenceState &upsertSuturingSequence(const physics::AuthoredSuturingSequenceState &state)#

Creates or updates an authored suturing sequence.

Negative path-node spacing is clamped to zero and the tip index is clamped to the entries.

bool removeParticleDistanceConstraint(physics::ParticleConstraintId constraintId)#: Removes an authored particle distance constraint.

bool removeRigidParticleAttachmentConstraint(physics::RigidParticleAttachmentConstraintId constraintId)#: Removes a rigid-particle attachment constraint.

bool removeStrandRigidAttachmentConstraint(physics::StrandRigidAttachmentConstraintId constraintId)#: Removes a strand-rigid attachment constraint.

bool removeRigidDistanceConstraint(physics::RigidDistanceConstraintId constraintId)#: Removes a rigid distance constraint.

bool removeRoutedCableConstraint(physics::RoutedCableConstraintId constraintId)#: Removes a routed cable constraint.

bool removeBallJoint(physics::BallJointId jointId)#: Removes a ball joint.

bool removeHingeJoint(physics::HingeJointId jointId)#: Removes a hinge joint.

bool removeSphericalJoint(physics::SphericalJointId jointId)#: Removes a spherical joint.

bool removeSliderJoint(physics::SliderJointId jointId)#: Removes a slider joint.

bool removeParticleCollisionFilter(physics::ParticleCollisionFilterId filterId)#: Removes a particle collision filter.

bool removeSuturingSequence(physics::SuturingSequenceId sequenceId)#: Removes a suturing sequence.

void setUltrasoundProbe(common::EntityId entityId, const UltrasoundProbeComponent &component)#: Assigns or updates an enabled ultrasound probe component for an entity.

Note

Passing a disabled component removes the probe and its published result.

bool removeUltrasoundProbe(common::EntityId entityId)#: Removes an ultrasound probe component and its result from an entity.

void setUltrasoundRenderer(common::EntityId entityId, const UltrasoundRendererComponent &component)#: Assigns or updates an ultrasound renderer component for an entity.

bool removeUltrasoundRenderer(common::EntityId entityId)#: Removes an ultrasound renderer component and clears any published probe result.

void setUltrasoundScattererSource(common::EntityId entityId, const UltrasoundScattererSourceComponent &component)#: Assigns or updates an enabled ultrasound scatterer source component for an entity.

Note

Passing a disabled component removes the source and its amplitude ranges.

bool removeUltrasoundScattererSource(common::EntityId entityId)#: Removes an ultrasound scatterer source and its amplitude ranges from an entity.

void setUltrasoundScattererAmplitudeRanges(common::EntityId entityId, const std::vector<UltrasoundAmplitudeRange> &ranges)#: Sets ultrasound scatterer amplitude ranges for an entity.

Note

The entity must have a soft body and provide exactly one range per authored particle.

bool clearUltrasoundScattererAmplitudeRanges(common::EntityId entityId)#: Clears ultrasound scatterer amplitude ranges for an entity.

ColliderHandle addCollider(common::EntityId entityId, const ColliderComponent &component)#

Adds a collider to an entity with a rigid body and returns its handle.

Returns:: An invalid handle if the entity is invalid, not alive, or has no rigid body.

void updateCollider(ColliderHandle handle, const ColliderComponent &component)#: Updates the component of a registered collider handle.

bool removeCollider(ColliderHandle handle)#: Removes a registered collider handle.

bool replaceColliders(common::EntityId entityId, const std::vector<ColliderComponent> &components)#

Replaces all colliders on an entity with a rigid body.

Returns:: False if the entity is invalid, not alive, or has no rigid body.

bool removeTransform(common::EntityId entityId)#: Removes the transform component from an entity.

bool removeMeshRenderer(common::EntityId entityId)#: Removes the mesh renderer component from an entity.

bool removeCamera(common::EntityId entityId)#: Removes the camera component from an entity.

bool removeDirectionalLight(common::EntityId entityId)#: Removes the directional-light component from an entity.

bool removePointLight(common::EntityId entityId)#: Removes the point-light component from an entity.

bool removeSpotLight(common::EntityId entityId)#: Removes the spot-light component from an entity.

std::optional<TransformComponent> tryGetTransform(common::EntityId entityId) const#: Returns the transform component for an entity, or std::nullopt.

std::optional<MeshRendererComponent> tryGetMeshRenderer(common::EntityId entityId) const#: Returns the mesh renderer component for an entity, or std::nullopt.

std::optional<CameraComponent> tryGetCamera(common::EntityId entityId) const#: Returns the camera component for an entity, or std::nullopt.

std::optional<DirectionalLightComponent> tryGetDirectionalLight(common::EntityId entityId) const#: Returns the directional-light component for an entity, or std::nullopt.

std::optional<PointLightComponent> tryGetPointLight(common::EntityId entityId) const#: Returns the point-light component for an entity, or std::nullopt.

std::optional<SpotLightComponent> tryGetSpotLight(common::EntityId entityId) const#: Returns the spot-light component for an entity, or std::nullopt.

std::optional<RigidBodyComponent> tryGetRigidBody(common::EntityId entityId) const#: Returns the rigid-body component for an entity, or std::nullopt.

std::optional<SoftBodyComponent> tryGetSoftBody(common::EntityId entityId) const#: Returns the soft-body component for an entity, or std::nullopt.

std::optional<StrandComponent> tryGetStrand(common::EntityId entityId) const#: Returns the strand component for an entity, or std::nullopt.

std::optional<ProceduralDeformableCurveRenderComponent> tryGetProceduralDeformableCurveRender(common::EntityId entityId) const#: Returns the procedural deformable-curve renderer for an entity, or std::nullopt.

std::optional<FluidComponent> tryGetFluid(common::EntityId entityId) const#: Returns the fluid component for an entity, or std::nullopt.

const physics::AuthoredParticleSequenceState *tryGetParticleSequence(physics::ParticleSequenceId sequenceId) const noexcept#: Returns an authored particle sequence by ID, or nullptr.

const physics::AuthoredParticleDistanceConstraintState *tryGetParticleDistanceConstraint(physics::ParticleConstraintId constraintId) const noexcept#: Returns an authored particle distance constraint by ID, or nullptr.

const physics::AuthoredRigidParticleAttachmentConstraintState *tryGetRigidParticleAttachmentConstraint(physics::RigidParticleAttachmentConstraintId constraintId) const noexcept#: Returns a rigid-particle attachment constraint by ID, or nullptr.

const physics::AuthoredStrandRigidAttachmentConstraintState *tryGetStrandRigidAttachmentConstraint(physics::StrandRigidAttachmentConstraintId constraintId) const noexcept#: Returns a strand-rigid attachment constraint by ID, or nullptr.

const physics::AuthoredRigidDistanceConstraintState *tryGetRigidDistanceConstraint(physics::RigidDistanceConstraintId constraintId) const noexcept#: Returns a rigid distance constraint by ID, or nullptr.

const physics::AuthoredRoutedCableConstraintState *tryGetRoutedCableConstraint(physics::RoutedCableConstraintId constraintId) const noexcept#: Returns a routed cable constraint by ID, or nullptr.

const physics::BallJointState *tryGetBallJoint(physics::BallJointId jointId) const noexcept#: Returns a ball joint by ID, or nullptr.

const physics::HingeJointState *tryGetHingeJoint(physics::HingeJointId jointId) const noexcept#: Returns a hinge joint by ID, or nullptr.

const physics::SphericalJointState *tryGetSphericalJoint(physics::SphericalJointId jointId) const noexcept#: Returns a spherical joint by ID, or nullptr.

const physics::SliderJointState *tryGetSliderJoint(physics::SliderJointId jointId) const noexcept#: Returns a slider joint by ID, or nullptr.

const physics::AuthoredParticleCollisionFilterState *tryGetParticleCollisionFilter(physics::ParticleCollisionFilterId filterId) const noexcept#: Returns an authored particle collision filter by ID, or nullptr.

const physics::AuthoredSuturingSequenceState *tryGetSuturingSequence(physics::SuturingSequenceId sequenceId) const noexcept#: Returns an authored suturing sequence by ID, or nullptr.

std::optional<UltrasoundProbeComponent> tryGetUltrasoundProbe(common::EntityId entityId) const#: Returns the ultrasound probe component for an entity, or std::nullopt.

std::optional<UltrasoundRendererComponent> tryGetUltrasoundRenderer(common::EntityId entityId) const#: Returns the ultrasound renderer component for an entity, or std::nullopt.

std::optional<UltrasoundScattererSourceComponent> tryGetUltrasoundScattererSource(common::EntityId entityId) const#: Returns the ultrasound scatterer source component for an entity, or std::nullopt.

std::optional<SoftBodyAuthoringParticles> tryGetSoftBodyAuthoringParticles(common::EntityId entityId) const#: Returns authored rest positions for a soft body, or std::nullopt.

const std::vector<UltrasoundAmplitudeRange> *tryGetUltrasoundScattererAmplitudeRanges(common::EntityId entityId) const noexcept#: Returns ultrasound scatterer amplitude ranges for an entity, or nullptr.

const UltrasoundProbeResult *tryGetUltrasoundProbeResult(common::EntityId entityId) const noexcept#: Returns the most recently published ultrasound probe result, or nullptr.

std::optional<ColliderComponent> tryGetCollider(ColliderHandle handle) const#: Returns the component for a registered collider handle, or std::nullopt.

const std::vector<ColliderHandle> &colliderHandles(common::EntityId entityId) const#

Returns collider handles belonging to an entity.

Returns:: An empty shared list when the entity has no collider links.

physics::PhysicsWorld &physicsWorld() noexcept#

Gets a reference to the internal PhysicsWorld instance.

Returns:: Reference to PhysicsWorld.

const physics::PhysicsWorld &physicsWorld() const noexcept#

Gets a const reference to the internal PhysicsWorld instance.

Returns:: Const reference to PhysicsWorld.

void setGpuEntityScene(const graphics::GpuEntitySceneView &sceneView) noexcept#: Sets the GPU scene view used by render-state accessors.

const std::vector<graphics::RenderableInstance> &renderables() const noexcept#: Returns authored renderable instances.

const std::vector<graphics::CameraData> &cameras() const noexcept#: Returns authored camera data.

const std::vector<graphics::LightData> &lights() const noexcept#: Returns authored light data.

std::uint32_t entityPoseSlot(common::EntityId entityId) const noexcept#: Returns an entity’s pose slot, or an invalid slot when none is assigned.

const std::vector<Diligent::float4> &entityPosePositions() const noexcept#: Returns entity-pose positions prepared for GPU upload.

const std::vector<Diligent::float4> &entityPoseOrientations() const noexcept#: Returns entity-pose orientations prepared for GPU upload.

const std::vector<Diligent::float4> &entityPoseScales() const noexcept#: Returns entity-pose scales prepared for GPU upload.

const std::vector<Diligent::float4> &renderObjectPositions() const noexcept#: Returns render-object positions prepared for GPU upload.

const std::vector<Diligent::float4> &renderObjectOrientations() const noexcept#: Returns render-object orientations prepared for GPU upload.

const std::vector<Diligent::float4> &renderObjectScales() const noexcept#: Returns render-object scales prepared for GPU upload.

const std::vector<graphics::GpuRenderableMetadata> &renderableMetadata() const noexcept#: Returns renderable metadata prepared for GPU upload.

const std::vector<graphics::GpuRenderableQueueInfo> &renderableQueueInfo() const noexcept#: Returns renderable queue information prepared for GPU upload.

const std::vector<graphics::GpuCameraInput> &cameraInputs() const noexcept#: Returns camera inputs prepared for GPU upload.

const std::vector<graphics::GpuLightInput> &lightInputs() const noexcept#: Returns light inputs prepared for GPU upload.

const std::vector<graphics::GpuLocalLightSelection> &localLightSelections() const noexcept#: Returns per-environment local-light selections prepared for GPU upload.

const std::vector<graphics::GpuSoftBodyVertexBinding> &softBodyVertexBindings() const noexcept#: Returns soft-body vertex bindings prepared for GPU upload.

const std::vector<graphics::IndirectCommandRegistryEntry> &opaqueDrawRegistry() const noexcept#: Returns the opaque indirect-draw registry.

const std::vector<graphics::TransparentDrawEntry> &transparentDrawRegistry() const noexcept#: Returns the transparent draw registry.

const std::vector<graphics::IndirectCommandRegistryEntry> &shadowDrawRegistry() const noexcept#: Returns the directional-shadow indirect-draw registry.

const std::vector<graphics::IndirectCommandRegistryEntry> &localShadowDrawRegistry() const noexcept#: Returns the local-light-shadow indirect-draw registry.

const std::vector<EntityPoseMappingEntry> &physicsRenderableMappings()#: Returns mappings between physics bodies and renderables, rebuilding them if needed.

std::uint64_t entityPoseRevision() const noexcept#: Returns the entity-pose data revision.

std::uint64_t renderableMetadataRevision() const noexcept#: Returns the renderable-metadata revision.

std::uint64_t renderableQueueInfoRevision() const noexcept#: Returns the renderable-queue revision.

std::uint64_t softBodyVertexBindingRevision() const noexcept#: Returns the soft-body vertex-binding revision.

std::uint64_t cameraInputRevision() const noexcept#: Returns the camera-input revision.

std::uint64_t lightInputRevision() const noexcept#: Returns the light-input revision.

std::uint64_t localLightSelectionRevision() const noexcept#: Returns the local-light-selection revision.

const graphics::GpuEntitySceneView &gpuEntityScene() const noexcept#: Returns the GPU entity-scene view.

graphics::HostSceneView hostSceneView() const noexcept#: Returns an immutable bundle of host scene data for rendering.

void ensureRenderStateUpToDate(const graphics::RenderResourceManager &resources)#: Updates render state derived from authored world and resource state.

const std::unordered_map<common::EntityId, UltrasoundProbeComponent> &ultrasoundProbeComponents() const noexcept#: Returns ultrasound probe components keyed by entity ID.

const std::unordered_map<common::EntityId, UltrasoundRendererComponent> &ultrasoundRendererComponents() const noexcept#: Returns ultrasound renderer components keyed by entity ID.

const std::unordered_map<common::EntityId, UltrasoundScattererSourceComponent> &ultrasoundScattererSourceComponents() const noexcept#: Returns ultrasound scatterer source components keyed by entity ID.

std::uint64_t ultrasoundScattererAmplitudeRevision() const noexcept#: Returns the ultrasound scatterer-amplitude revision.

void setUltrasoundProbeResult(common::EntityId entityId, const UltrasoundProbeResult &result)#: Publishes an ultrasound probe result under an entity ID without validating it.

void clearUltrasoundProbeResult(common::EntityId entityId)#: Clears a published ultrasound probe result for an entity ID, if present.

bool removeParticleSequence(physics::ParticleSequenceId sequenceId)#: Removes an authored particle sequence.