registerSkinnedMesh(meshKey, geo, skeleton, animations)

registerModelNodeAnimation(modelInstanceId, graph, animations, playbackState = null)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ============================================================================ SkeletalAnimation.js CPU skeletal animation + skinning for imported models Evaluates glTF animations per frame, computes joint world matrices, and skins vertex positions/normals/tangents on CPU. Updates the GPU vertex buffer via EntityMeshRenderer. ============================================================================ Functions Register a skinned mesh for animation playback. Parameters: (string) — e.g. 'custom <uuid ' (Object) — { positions, normals, tangents, uvs, indices, joints, weights } (Object) — { joints[], inverseBindMatrices, jointCount } (Object[]) — Array of { name, channels[], duration } Unregister a skinned mesh. Get a skinned mesh instance. Tick all active skinned meshes. Call once per frame before rendering. Parameters: (number) — Delta time in seconds Register ordinary glTF node animation once per model entity instance. Check if a meshKey has skeletal animation. Get the current skinned positions/normals/tangents for a mesh. Returns null if not a skinned mesh. Compute current local space skinned bounds from bind vertices and live skin matrices. This remains authoritative when GPU skinning intentionally leaves CPU outputs stale. Get the current bounds already refreshed by the animation/ragdoll tick. Get all registered skinned mesh keys. Get per bone capsule dimensions computed from vertex weights. Returns cached data computed once at registration time. Parameters: (string) — No description in source JSDoc. Returns: null} Get ANIMATED bone shapes for visual overlay rendering. Returns current frame bone positions/rotations with mesh measured capsule sizes. Uses the CURRENT animated


ANIMATED bone shapes for visual overlay rendering. Returns current frame bone positions/rotations with mesh measured capsule sizes. Uses the CURRENT animated worldMatrices so capsules track the animation exactly. This is the PRIMARY API for the visual bone overlay in Viewport.js. Each bone returns: pos: world position (midpoint between bone and first child) rot: quaternion aligning Y axis with bone direction radius: mesh measured perpendicular distance (90th percentile) halfHeight: half the bone length minus radius name: bone name for debug/classification parentIndex: parent bone index ( 1 for roots) isTerminal: true for end/nub bones (skip rendering) Parameters: (string) — e.g. 'custom <uuid ' (number[]) — [x,y,z] entity world position Returns: { shapes: [...], bodyHeight, shoulderWidth } Get bind pose bone data WITHOUT modifying state (no ragdoll, no animation stop). Used for edit mode SDF collider visualization preview. Parameters: (string) — No description in source JSDoc. (number[]) — [x,y,z] entity world position Returns: { bones: [{index, parentIndex, worldPos, worldRot, childPositions, name}], jointCount, rootScale } Enable ragdoll mode for a skinned mesh. Stops animation and returns bind pose bone world positions + hierarchy for creating physics bodies. Parameters: (string) — No description in source JSDoc. (number[]) — [x,y,z] entity world position Returns: { bones: [{index, parentIndex, worldPos, childPositions, name}], jointCount } Update bone world matrices from ragdoll physics transforms, then reskin. Parameters: (string) — No description in source JSDoc. (Float32Array) — jointCount 16 column major matrices Disable ragdoll mode, resuming animation. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned


matrices Disable ragdoll mode, resuming animation. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines re


render/mesh/VirtualGeometrySystem.js
Classes
class VirtualGeometrySystem
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Update culling parameters Create bind group for culling pass Execute cluster culling and LOD selection Get visible clusters buffer for indirect draw Get visible count buffer for indirect draw Build cluster hierarchy from mesh Uses a simple greedy clustering algorithm based on spatial locality <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/mesh/index.js
Re-exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Mesh Renderers GPU mesh rendering utilities Re exports , , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


async encodeMorphAsset(sceneInput, options = {})

async decodeMorphAsset(input, options = {})

async loadMorphAsset(source, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/assets/index.js
Exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Exports No ES module exports detected in this file. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/assets/selfTest.js
Functions
async runMorphAssetSelfTests()
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/core/AabbBvh.js
Classes
class AabbBvh
Functions
buildAabbBvh(leaves)
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createOutwardF32Bounds(bounds, expansion = 0)

packFieldletMeta({ subtype = 0, family = 0, queryMask = 0, flags = 0 } = {})

createFieldletHeader({ boundsRef, payloadRef, meta, certificateRef = INVALIDREF })

readFieldletHeader(view, byteOffset = 0)

createCertificateBundle({ surfaceRef = INVALIDREF, mediumRef = INVALIDREF, motionRef = INVALIDREF, collisionRef = INVALIDREF, } = {})

createSurfaceCertificate({ fieldValueErrorMax = 0, lipschitzMax, fallbackBand = 0, motionRadiusMax = 0, })

createMediumCertificate({ densityMax = 0, extinctionMax = 0, emissionLuminanceMax = 0, motionRadiusMax = 0, } = {})

createMotionCertificate({ displacementMax = 0, speedMax = 0, accelerationMax = 0, validDuration = 0, } = {})

createCollisionCertificate({ fieldValueErrorMax = 0, lipschitzMax, contactOffset, contactSlop = 0, motionRadiusMax = 0, })


validateIndexedTriangleMesh(mesh, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Validate finite indexed triangle geometry and, when requested, prove an oriented closed 2 manifold index topology. This is shared by authored indexed Nexels and extracted surface cache publication. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Functions Qualify a structured cloned/worker result by deterministically recompiling its authoritative semantic snapshot and comparing every executable ABI byte. This is the cross realm path; normal same realm compiler output uses the private registry above and does not pay for a second compilation. Run the compiler's exact isolated descriptor admission gates synchronously. Capability inspection uses this probe so it cannot claim a direct GPU path for a descriptor that compilation would later reject. Re exports , , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing ·


in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/core/NexelScene.js
Classes
class NexelScene
Functions
normalizeNexelPatch(input)
createNexelScene(options)
isNexelScene(value)
Re-exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Functions Re exports , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


normalizeVector3(value, path = 'vector', fallback = [0, 0, 0])

normalizeQuaternion(value, path = 'rotation')

normalizeTransform(input = undefined, path = 'transform')


render/morphfield/core/constants.js
Functions
queryMaskForKind(kind)
Constants
Notes & Examples
Shared GPU device


failMorphField(code, message, details = undefined)

invariant(condition, code, message, details = undefined)

asMorphFieldError(error, code, message, details = undefined)


render/morphfield/core/index.js
Exports
Notes & Examples
Shared GPU device


render/morphfield/core/selfTest.js
Functions
async runMorphFieldCoreSelfTests()
Notes & Examples
Shared GPU device


canonicalize(value, path = '$', options = {})

deepFreeze(value, visited = new WeakSet()

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Compare identifiers by ECMAScript UTF 16 code unit order. Unlike localeCompare(), this ordering is independent of the host locale and ICU version, so packed Fieldlet indices remain reproducible across machines. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


normalizeSource(input, path = 'source', depth = 0, options = {})

validateMaterialF32Channels(material, path = 'material')

normalizeNexelDescriptor(input, path = 'nexel')


render/morphfield/index.js
Functions
createScene(options)
createCompiler(options)
encodeAsset(scene, options)
async loadAsset(source, options)
inspectAsset(source, options)
createRenderer(options)
createPathTracer(options)
createMicrostructureRenderer(options)
createAffineBrickRenderer(options)
Constants
Re-exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Create a device independent semantic Nexel scene. Create a deterministic device independent MorphField compiler. Encode a semantic scene into a bounded, checksummed MOR2 container. Load a MOR2 container and return its authoritative semantic Nexel scene. Use inspectAsset() when chunk metadata or provenance is also required. Decode a MOR2 container while retaining provenance and optional chunks. Create an external encoder renderer that borrows its host GPUDevice. Create the bounded queue progressive compute path tracer. Create the portable u32 render cluster decoder on a borrowed GPU device. Create the direct 32 byte AFFINE4 brick decoder on a borrowed GPU device. Constants — Stable public namespace used by Engine.MorphField and bundled window.PE. Internal implementation groups remain inspectable without flattening conflicting ABI aliases into the public method surface. Re exports , , , , , , , , , , , , , , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines


optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


normalizeQualityDecision(decision, fallback, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Constants Re exports <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Re exports <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Directly expands 32 byte AFFINE4 morphology payloads into render only cells. Simulation/collision remains attached to the authoritative MorphField scene. Method Signature Summary Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Constants — Direct GPU expansion of a 32 byte, sixty four microcube AFFINE4 payload. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes A borrowed device, external encoder renderer. Each 32 byte parent Nexel is decoded directly in WGSL into at most eight render only samples. Method Signature Summary Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Constants — Portable u32 direct decode renderer for RM(1,3) Nexel clusters. Re exports <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


writeNexelFrameUniforms(target, { camera, viewport, time, frameCount, quality, pointGain, projectionScale, opacity, } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Constants — Root Algebra style immutable execution plan shared by every Nexel shader. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Functions Validate the compiler to runtime binary contract without granting runtime trust. This is intentionally useful for diagnostics and fuzzing; renderer activation separately requires the private compiler origin registry. Pack Fieldlet bounds, compiler BVH nodes, per Fieldlet collision metadata, and one validated scene trailer in a single storage binding. WebGPU guarantees only eight storage buffers per shader stage on the portable baseline, so tracing and queries cannot add separate spatial or collision bindings to the existing scene ABI. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source:


device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


inspectNexelComputeCapabilities(device, { wgslLanguageFeatures } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Reports optional compute paths separately from the portable u32 baseline. Support is not evidence that a pipeline selected or used a feature; callers must record those two states alongside benchmark results. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/runtime/index.js
Functions
async createRenderer(options)
canonicalizeCompiledScene(scene)
Re-exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Validates and detaches the canonical typed array ABI published by this realm's MorphFieldCompiler. Authored object Fieldlets and cloned certificate arrays are not a certification boundary and are rejected. Re exports , , , , , , , , , , , , , , , , , , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Buffer only compute wavefront path tracer for compiled MorphField scenes. It borrows every host object, records only into the supplied encoder, and owns only its pipelines, queue/state buffers, uniforms, and accumulation. Method Signature Summary Binds borrowed scene buffers. contains four vec4 records per Fieldlet in surface, medium, motion, collision order. Optional material extensions may be a borrowed GPU buffer, packed CPU data, or semantic descriptors. No borrowed buffer is ever destroyed. Updates same allocation scene metadata without rebuilding borrowed bind groups. Allocates bounded owned queues and an f32 sum/count accumulation buffer. Invalidates progressive accumulation on the next external encode. Records generate/intersect/shade/shadow/finalize compute passes. The host retains responsibility for finishing and submitting . Resolves an explicitly requested queue header readback after host submit. Returns the owned rgba32float radiance sum/sample count output buffer. Releases only resolution dependent queues and accumulation. Persistent pipelines, layouts, scene bindings, and lifetime counters remain ready so a later progressive encode can rebuild the extent without recompilation. Returns synchronous lifecycle data plus the latest resolved GPU counters. Releases only owned resources. Safe to call more than once. Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native


the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Packs one extension record per material as [transmissionFactor, ior, clearcoatFactor, clearcoatRoughness]. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Re exports , , , , , , , , , , , , , , , , <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


async runWavefrontSelfTest({ realWebGpu = false, device = null } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/schemas/ids.js
Constants
Notes & Examples
Shared GPU device


render/morphfield/schemas/index.js
Functions
inspectNexelCapabilities(input)
Constants
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Normalize one semantic Nexel and report the execution/query capabilities the current R2 implementation can honestly provide for it. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createParticleWorldAdapter(world, options = {})

createFluidWorldAdapter(world, options = {})

createVolumeSystemAdapter(volumeSystem, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Adapt the existing particle world to the shared host encoder. Adapt the existing external encoder fluid grid. Adapt an existing volume system exposing update(encoder, camera). Generic bridge for a caller owned GPU simulation. It deliberately does not invent domain specific solver names or resource ownership. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


integrateMedium(ray, evaluateMedium, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes CPU reference and bin builder for semantic anisotropic oriented kernels. Method Signature Summary Four exact sorted layers followed by a bounded weighted blended tail. Method Signature Summary Functions Deterministic reference integrator using a certified extinction majorant. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


encodeNexelMicrocube(pattern, { dictionary } = {})

decodeNexelMicrocube(encoded, { dictionary } = {})

packNexelDescriptor({ mortonCoordinate = 0, material = 0, morphology = 0, state = 0, lod = 0, flags = 0, } = {})

createAffineNexelBrick(patterns, options = {})

createAffineNexelBrickFromMorphologies(morphologies, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Portable binary microstructure tools for Nexel render clusters and voxel bricks. These helpers describe local storage and verification only; they do not replace a chunk CRC/authentication tag or an outer error correcting code. Functions Compile the eight affine Boolean equations into one u32 of nibble masks, then exhaustively prove the branch free parity plan against the reducer. This follows Root Algebra Lab's validated plan discipline without adopting its deliberately research only carry/sign multiplier. Compile an immutable exact dictionary and reverse lookup once per codebook. Evaluate one corner of an RM(1,3) affine microcube. Expand an affine morphology into its exact eight bit occupancy mask. Return the affine morphology for a pattern, or null for a non codeword. Six bit local face parity syndrome ordered x0,x1,y0,y1,z0,z1. A valid RM(1,3) word has zero syndrome; another valid word can still evade it. Interleave three five bit coordinates into the descriptor's 15 bit Morton field. Choose the smallest lossless local mode under the supplied dictionary. Pack the research descriptor: 15/6/4/3/2/2 exact integer fields. Pack sixty four affine microcubes into eight u32 words (32 bytes). Pack already proven morphology nibbles without expanding and re decoding. Build a brick directly from its sixty four affine morphology nibbles. Recompute every local brick invariant without trusting stored TypedArrays. Return a deterministic, exact permutation of the eight microcube corners. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss


GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


compileNexelPbdColliderSet(descriptorInput, { contactOffset = 0.002, restOffset = 0, friction = 0.36, } = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Functions Compile semantic static Nexels into PBDSolver collider inputs. PBDSolver's contactRadius remains a predictive OGC shell, while the solver geometry is inset by contactOffset restOffset so the rendered and collision surfaces settle at the requested restOffset (zero by default). Apply a compiled collider set without taking ownership of the solver. Re exports <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createParticleChainNexelDescriptors(snapshot, options = {})

createParticleChainNexelPatch(scene, snapshot, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Convert a caller owned particle chain snapshot into stable sphere/capsule Nexels. The simulation remains authoritative; this adapter performs no stepping, GPU readback, queue submission, or resource ownership transfer. Editor PhysicsChain component , CPU PBD , and ordinary arrays intentionally share this one input contract. Build an incremental scene patch while preserving stable chain IDs. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


solveQef(intersections, normals, bounds, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Rank aware QEF solver using a Jacobi eigendecomposition of the local normal covariance and a truncated pseudoinverse. Coordinates are translated to the cell center before solving to preserve f32 compatible numerical scale. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


selectSurfaceExtractor(intent = {}, capabilities = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Stable top level MorphField execution families. Classes Deterministic representation planner. Source semantics and certificates are authoritative; performance history can only promote an eligible surface to a disposable cache. Method Signature Summary Functions Selects a single extractor for an entire connected seam domain. The selector intentionally returns direct rendering when a requested topology guarantee cannot be supported by certified Hermite data. Constants — Stable top level MorphField execution families. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Certified scalar residual brick with deterministic trilinear sampling. Method Signature Summary Revisioned, fixed budget residual residency manager. The coarsest level is pinned, so every accepted source always has a certified fallback. Method Signature Summary Functions Compose analytic and residual surface certificates conservatively. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createExternalEncoderAdapter({ id, authority = 'authoritative', encode, interpolate, updateStride = 1 })

createKinematicAdapter({ id, sample, apply, authority = 'authoritative' })

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: Fixed step scheduler for external encoder simulation domains. Classes Fixed step scheduler for external encoder simulation domains. Method Signature Summary Functions Wrap an existing external encoder simulation API without changing its name. Kinematic adapter that advances a caller owned transform source. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


validateMesh(mesh, topologyRequirement = 'unspecified')

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Device independent surface cache extractor and validation boundary. Method Signature Summary Stages complete connected domains and atomically replaces validated entries. Method Signature Summary Crack safe portable fallback for a connected mixed LOD domain. Every member is resampled at the finest cell size before staging, trading memory for an exact shared boundary until a validated transition cell backend is active. Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


render/morphfield/systems/index.js
Exports
Notes & Examples
Shared GPU device

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Exports No ES module exports detected in this file. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createTransitionBoundarySignatures(mesh, options = {})

compareTransitionBoundaries(left, leftFace, right, rightFace)

assertTransitionBoundaryMatch(left, leftFace, right, rightFace)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Build canonical signatures from the open edges of a transition mesh. Signatures contain complete sorted segment records as well as a compact hash; comparisons therefore never rely on hash equality alone. World space quantization makes opposite local face orientations compare identically. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


class TransitionExtractionError extends Error

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Classes Method Signature Summary Method Signature Summary Functions Extract a deterministic transition slab for one exact 2:1 grid pair. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


validateTransitionInterface(mesh, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Validate geometry, local manifoldness, winding, exact 2:1 metadata, and all recorded boundary signatures. Open edges are valid only on one of the six transition prism faces. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


generateVisualShader(effect, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: CustomParticleEffect.js Unified Particle Effect System KEY PRINCIPLE: ONE SDF function defines BOTH: 1. Visual rendering (raymarching in fragment shader) 2. Collision detection (compute shader physics) This ensures particle appearance ALWAYS matches collision shape. Functions Generate visual raymarching shader from effect Generate collision compute shader from effect Validate effect WGSL code Returns: } Compile effect shaders on device (validates WGSL syntax) Create a new custom effect from template Clone an existing effect Get all built in presets as array Get preset by ID Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


applyEffectToEmitter(emitterComponent, effectId, params = null)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: CustomParticleEffectIntegration.js Integration Layer Wires the custom particle effect system into the engine: Initializes registry on engine startup Provides utilities for applying effects to emitters Connects visual effects to collision system Functions Initialize the custom particle effect system Call this during engine initialization Get compiled effect shaders for an effect ID Get the collision SDF system Apply a custom effect to a particle emitter component Get effect data for rendering Create effect parameters buffer data for GPU Returns a reusable Float32Array DO NOT modify after passing to GPU Get the effective SDF for a particle (for collision queries) Returns a function that evaluates the SDF at a local position Check if custom effects system is initialized <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device


use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createParticleAgeDataBindGroup(renderer, positionBuffer, metaBuffer, velocityBuffer)

setParticleAgeParams(renderer, { size = 1, quality = 1.0, lodBias = 1.0, cullThreshold = 0 })


createParticleAlbedoDataBindGroup(renderer, positionBuffer, metaBuffer, velocityBuffer)

setParticleAlbedoParams(renderer, { size = 1, quality = 1.0, lodBias = 1.0, cullThreshold = 0 })

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Create particle albedo pass renderer Create data bind group for albedo pass Update albedo pass parameters <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


async createParticleBeamRenderer(device, options = {})

renderBeamParticles(pass, renderer, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleBeamRenderer.js Beam / Lightning Particle Renderer (GAP 14) Renders connected line segments between sequential particles as thick beams. Supports: Chain mode: connect particles in sequence (particle 0→1→2→3...) Source mode: connect all particles to a single source point Lightning mode: chain + per segment jitter for electric arcs Each beam segment is a camera facing quad strip (2 triangles per segment). Width can vary per particle (from meta.w size) and taper at ends. Usage: const beam = await createParticleBeamRenderer(device, { format }); renderBeamParticles(pass, beam, world, { viewProj, instanceCount }); Functions Create a particle beam renderer. Parameters: (GPUDevice) — No description in source JSDoc. (Object) — { format, mode, width, taper, jitterAmount } Bind particle data from a particle world. Render beam particles. Parameters: (GPURenderPassEncoder) — No description in source JSDoc. (Object) — No description in source JSDoc. (Object) — { viewProj, viewRight, viewUp, time, segmentCount } Update beam parameters. Destroy the beam renderer. Constants <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks


it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createParticleBillboardDataBindGroup(renderer, positionBuffer, metaBuffer, velocityBuffer, uvBuffer, albedoTextureView, albedoSampler)

setParticleBillboardParams(renderer, { size = 1, quality = 1.0, lodBias = 1.0, cullThreshold = 0, rotationRate = 0, useColorGradient = false, stretchFactor = 0, facingMode = 0, })

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Creates a particle point renderer (spheres instead of flat billboards). This renders particles as actual points with spherical falloff. Creates a particle billboard renderer. This is a pure rendering module it does not own particle simulation. Creates a data bind group for a specific particle world. Call this once per particle world you want to render. Parameters: (Object) — The particle billboard renderer (GPUBuffer) — The particle position buffer (xyz=pos, w=age) (GPUBuffer) — The per particle metadata buffer (rgb=color, w=size+shape) (GPUBuffer) — The particle velocity buffer (xyz=vel, w=lifetime) Updates particle rendering parameters including quality settings. Parameters: (Object) — Particle renderer (Object) — No description in source JSDoc. (number) — Default particle size (fallback) (number) — Quality scalar 0.0 1.0 (1.0 = full quality) (number) — Distance LOD aggressiveness (1.0 = normal) (number) — Max particles to render (0 = no limit) Create or update the scene depth + alive list bind group (GAP 17 + 18). Call this when the depth texture changes (e.g. on resize) or when connecting the alive list from IndirectDispatch for GPU indirect draw. Parameters: (Object) — The billboard renderer (GPUTextureView) — Scene depth texture view (GPUBuffer) — Alive list buffer from IndirectDispatch (optional) <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by


by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createBlackbodySystem(device, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleBlackbodyRenderer.js Blackbody Radiation Renderer (GAP 39) Creates and manages the 1D blackbody LUT texture. Provides bind group for particle fragment shaders to sample temperature → color. Integrates with existing billboard and SDF renderers. Usage: const bb = createBlackbodySystem(device); const bindGroup = getBlackbodyBindGroup(bb); // Set as additional bind group in particle render pass Functions Create the blackbody rendering system with LUT texture. Parameters: (GPUDevice) — No description in source JSDoc. (Object) — No description in source JSDoc. Create a bind group layout for blackbody resources. Typically bound as an additional group in particle render pipelines. Create the bind group for blackbody resources. Update emission strength at runtime. Destroy. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all


access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


initBondRendererBindGroups(renderer, device, positionBuffer, velocityBuffer, metaBuffer, thermalBuffer)

uploadBonds(renderer, device, bondData, bondCount)

renderBonds(pass, renderer, viewProj, cameraPos, viewRight, viewUp)

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleBondRenderer.js Bond Line / Stick Renderer (GAP 41) Renders molecular bonds as camera facing quads between bonded particle pairs. Reads a bond buffer (vec4<u32 per bond: particleA, particleB, bondType, bondOrder). Color blends between element CPK colors at each endpoint. Supports covalent (solid), ionic (dashed), metallic (thick), hydrogen (dotted). Usage: const br = createBondRenderer(device, format); initBondRendererBindGroups(br, device, posBuffer, velBuffer, bondBuffer, colorLutBuffer, elementBuffer); uploadBonds(br, device, bondArray); renderBonds(pass, br, viewProj, cameraPos, viewRight, viewUp, bondCount); Functions Create the bond renderer. Initialize bind groups. Upload bond data from CPU. Parameters: (Uint32Array) — Flat array of [particleA, particleB, bondType, bondOrder, ...] (number) — No description in source JSDoc. Render bonds in the given render pass. Destroy. <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs


acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createCollisionPipeline(device, options = {})

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleCollisionSDF.js Custom SDF Collision Integration Integrates custom particle effect SDFs into the collision system. The same SDF code used for visual rendering is used for collision detection. This module: 1. Generates collision compute shaders with custom SDFs 2. Manages effect to index mapping for GPU dispatch 3. Provides collision evaluation utilities Classes Method Signature Summary Initialize/rebuild the collision pipeline Mark pipeline as needing rebuild (call when effects change) Register effect for collision Create bind group for particle buffer Dispatch collision computation Destroy resources Functions Register an effect for collision (assigns an index) Get effect index (0 if not registered) Get effect by index Generate the multi effect collision shader This shader supports switching between different SDFs based on effectId Create collision compute pipeline with custom SDFs Create a particle collision SDF system <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native


limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: ParticleDecalRenderer.js Render projected decals from particle collisions Renders decal quads at particle impact points (scorch marks, frost patches, wet splats). Reads from ParticleDecalSpawner's CPU side pool each frame. Pipeline: 1. ParticleDecalSpawner (sim/) creates decal descriptors from collision events 2. This renderer uploads active decals to a GPU storage buffer 3. Instanced draw: each decal = screen aligned quad projected onto surface 4. Blends onto scene with src alpha / one minus src alpha Decal data per instance (12 floats): [posX, posY, posZ, size, normX, normY, normZ, age/lifetime, r, g, b, a] Functions Create a decal rendering system Parameters: (GPUDevice) — No description in source JSDoc. (string) — Render target format Upload active decals from the CPU side spawner pool to GPU Parameters: (Object) — No description in source JSDoc. (Array) — From getActiveDecals(spawner) Render decals into the current render pass Parameters: (GPURenderPassEncoder) — No description in source JSDoc. (Object) — No description in source JSDoc. (Float32Array) — Frame uniforms (viewProj + viewRight + viewUp) Destroy decal renderer resources <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports


device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats


createParticleDepthDataBindGroup(renderer, positionBuffer, metaBuffer, velocityBuffer)

setParticleDepthParams(renderer, { size = 1, quality = 1.0, lodBias = 1.0, cullThreshold = 0 })

<! AUTOGENERATED by tools/extract api.py — content above HUMAN NOTES is overwritten Source: No file level description found in source. Add one as a leading JSDoc comment, or document it below. Functions Create particle depth pass renderer Create data bind group for depth pass Update depth pass parameters <! HUMAN NOTES Notes & Examples Shared GPU device Engine subsystems should reuse the cached wrapper returned by . The wrapper owns the native , its queue, granted features, limits, and device loss callbacks. Resources created by one native device cannot be used by another, so pass the shared wrapper or native device into each subsystem that needs GPU access. Example: Acquire the shared engine device Request a feature only when the application cannot run without it. automatically requests the engine's supported optional feature set, while reports the features actually granted to the device. Feature and limit checks Device loss Gotchas: First acquisition defines requirements: caches the wrapper. Supply mandatory features and limits on the first call. Native access: use and when a subsystem needs WebGPU primitives. Recovery: this module reports device loss but does not expose an in place API. Re bootstrap all device owned resources together. Limits: check the granted before large allocations. (Source: ) See also: GPU Device Sharing · Virtual GPU · GpuFormats