@waica/engine 0.24.0 → 0.26.0

package/dist/light-map.js

@@ -0,0 +1,132 @@
+import * as THREE from 'three/webgpu';
+import { FrameQuad } from './frame-quad.js';
+import { lightFootprint } from './light-field.js';
+import { createLightMapUniforms, createLightMaterial, createMultiplyMaterial, setLightDraw, } from './light-map-material.js';
+import { projectIsometric } from './projection.js';
+function emptyOccluders() {
+    const texture = new THREE.DataTexture(new Uint8Array([0]), 1, 1, THREE.RedFormat, THREE.UnsignedByteType);
+    texture.needsUpdate = true;
+    return texture;
+}
+/**
+ * The scene's light-map (issue #78, ADR 0026): an 8-bit target (inference
+ * 16) the size of the internal resolution — or of the drawing buffer — with
+ * nearest upscale, cleared to the Ambient Light, onto which each live Light
+ * adds its term through one mesh over its footprint. Then multiplied over
+ * the frame by one quad.
+ */
+export class LightMap {
+    target = new THREE.RenderTarget(1, 1, {
+        type: THREE.UnsignedByteType,
+        minFilter: THREE.NearestFilter,
+        magFilter: THREE.NearestFilter,
+        depthBuffer: false,
+    });
+    scene = new THREE.Scene();
+    geometry = new THREE.PlaneGeometry(1, 1);
+    empty = emptyOccluders();
+    uniforms = createLightMapUniforms(this.empty);
+    material = createLightMaterial(this.uniforms);
+    meshes = new Map();
+    multiply = new FrameQuad(createMultiplyMaterial(this.target.texture));
+    occluderTexture = null;
+    builtRevision = '';
+    clear = new THREE.Color();
+    savedClear = new THREE.Color();
+    /** Draws this frame's light-map into its target and leaves the renderer bound to `previous`. */
+    render(renderer, camera, frame) {
+        if (this.target.width !== frame.width || this.target.height !== frame.height) {
+            this.target.setSize(frame.width, frame.height);
+        }
+        this.syncOccluders(frame);
+        this.syncLights(frame);
+        const previous = renderer.getRenderTarget();
+        const alpha = renderer.getClearAlpha();
+        renderer.getClearColor(this.savedClear);
+        this.clear.setRGB(frame.ambient[0], frame.ambient[1], frame.ambient[2], THREE.LinearSRGBColorSpace);
+        renderer.setClearColor(this.clear, 1);
+        renderer.setRenderTarget(this.target);
+        renderer.render(this.scene, camera);
+        renderer.setRenderTarget(previous);
+        renderer.setClearColor(this.savedClear, alpha);
+    }
+    /** Multiplies the light-map over what is bound now: the canvas, or a Post Effect's canvas-like target. */
+    multiplyOver(renderer) {
+        this.multiply.render(renderer);
+    }
+    dispose() {
+        this.target.dispose();
+        this.geometry.dispose();
+        this.material.dispose();
+        this.multiply.dispose();
+        this.empty.dispose();
+        this.occluderTexture?.dispose();
+        this.meshes.clear();
+    }
+    syncOccluders(frame) {
+        if (frame.occluderRevision === this.builtRevision)
+            return;
+        this.builtRevision = frame.occluderRevision;
+        this.occluderTexture?.dispose();
+        this.occluderTexture = null;
+        const grid = frame.occluders();
+        if (!grid) {
+            this.uniforms.occluders.value = this.empty;
+            this.uniforms.grid.value.set(0, 0, 1, 0);
+            this.uniforms.gridSize.value.set(1, 1);
+            return;
+        }
+        const bytes = grid.solid.map((value) => (value === 1 ? 255 : 0));
+        const texture = new THREE.DataTexture(bytes, grid.columns, grid.rows, THREE.RedFormat, THREE.UnsignedByteType);
+        texture.needsUpdate = true;
+        this.occluderTexture = texture;
+        this.uniforms.occluders.value = texture;
+        this.uniforms.grid.value.set(grid.originX, grid.originY, grid.cellSize, 1);
+        this.uniforms.gridSize.value.set(grid.columns, grid.rows);
+    }
+    /** One mesh per live Light, placed over its footprint; a destroyed Light's mesh leaves now. */
+    syncLights(frame) {
+        this.uniforms.isometric.value = frame.projection === 'isometric' ? 1 : 0;
+        const live = new Set(frame.lights);
+        for (const [light, entry] of this.meshes) {
+            if (live.has(light))
+                continue;
+            entry.mesh.removeFromParent();
+            this.meshes.delete(light);
+        }
+        for (const light of frame.lights)
+            this.place(light, frame.projection);
+    }
+    place(light, projection) {
+        const entry = this.meshes.get(light) ?? this.createMesh(light);
+        const field = light.field();
+        entry.draw.position.set(field.x, field.y);
+        entry.draw.color.set(field.color[0], field.color[1], field.color[2]).multiplyScalar(field.intensity);
+        entry.draw.radius = field.radius;
+        entry.draw.bands = field.bands;
+        entry.draw.softness = field.softness;
+        entry.draw.castShadows = field.castShadows ? 1 : 0;
+        const center = projection === 'isometric' ? projectIsometric(field.x, field.y) : { x: field.x, y: field.y };
+        const footprint = lightFootprint(field.radius, projection);
+        entry.mesh.position.set(center.x, center.y, 0);
+        entry.mesh.scale.set(Math.max(footprint.width, 1e-6), Math.max(footprint.height, 1e-6), 1);
+        entry.mesh.visible = field.radius > 0 && field.intensity > 0;
+    }
+    createMesh(light) {
+        const mesh = new THREE.Mesh(this.geometry, this.material);
+        mesh.frustumCulled = false;
+        const draw = {
+            position: new THREE.Vector2(),
+            color: new THREE.Vector3(),
+            radius: 0,
+            bands: 0,
+            softness: 0,
+            castShadows: 1,
+        };
+        setLightDraw(mesh, draw);
+        this.scene.add(mesh);
+        const entry = { mesh, draw };
+        this.meshes.set(light, entry);
+        return entry;
+    }
+}

package/dist/lit-frame.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three/webgpu';
+import type { Game, GameResolution } from './game.js';
+import type { SpriteBatches } from './sprite-batches.js';
+/** What a frame is drawn with besides the Game's public state: its renderer and Sprite Batches. */
+export interface FrameSurface {
+    readonly game: Game;
+    readonly renderer: THREE.WebGPURenderer;
+    readonly spriteBatches: SpriteBatches;
+    /** The fixed internal resolution, null to fill the canvas. */
+    readonly resolution: GameResolution | null;
+}
+/**
+ * What the occluder grid is built from: the solid tiles' revision and every
+ * Tilemap's origin, so moving a Tilemap rebuilds it too (review) — still
+ * never per frame while nothing changes.
+ */
+export declare function occluderSignature(game: Game): string;
+/**
+ * Draws one frame (issue #78, ADR 0026). Off path (B4): an unlit scene with
+ * no Post Effect is one render straight into the canvas, exactly as before,
+ * and nothing here is ever built. Lit: the scene without its Emissive
+ * drawables, then the light-map multiplied over it, then the Emissive
+ * drawables. With a Post Effect, all of that goes into a target drawn like the
+ * canvas and
+ * one pass writes it to the canvas.
+ */
+export declare class FrameComposer {
+    private readonly surface;
+    private lightMap;
+    private postPass;
+    private readonly size;
+    constructor(surface: FrameSurface);
+    draw(): void;
+    dispose(): void;
+    /** The light-map's (and the Post Effects') size: the internal resolution, else the drawing buffer (B2). */
+    private frameSize;
+    /** Letterbox bars: clear the whole canvas, then render inside the scissor. */
+    private clearLetterbox;
+    /** The scene through its Sprite Batches (ADR 0024), for the camera's current layers. */
+    private drawScene;
+    /** The scene for one layer mask, restoring the camera's own mask after. */
+    private drawLayers;
+    /** Scene, light-map, Emissive drawables, into whatever target is bound now. */
+    private drawLit;
+    private composeLight;
+    /** The frame into the Post Effects' canvas-like target, then one pass to the canvas (CA-11). */
+    private drawThroughPost;
+}

package/dist/lit-frame.js

@@ -0,0 +1,174 @@
+import * as THREE from 'three/webgpu';
+import { Tilemap } from './components/tilemap.js';
+import { LightMap } from './light-map.js';
+import { buildOccluderGrid } from './occluder-grid.js';
+import { PostPass } from './post-pass.js';
+import { EMISSIVE_LAYER } from './render-layers.js';
+import { ambientIsFull, ambientMultiplier, occluderRevision } from './scene-lighting.js';
+/** Layer 0 alone: every drawable that is not Emissive. */
+const LIT_MASK = 1;
+const EMISSIVE_MASK = 1 << EMISSIVE_LAYER;
+/**
+ * What the occluder grid is built from: the solid tiles' revision and every
+ * Tilemap's origin, so moving a Tilemap rebuilds it too (review) — still
+ * never per frame while nothing changes.
+ */
+export function occluderSignature(game) {
+    const origins = occluderSources(game.entities).map(({ originX, originY }) => `${originX},${originY}`);
+    return `${occluderRevision(game.lighting)}|${origins.join(';')}`;
+}
+/** Every Tilemap of the scene as an occluder source (inference 8). */
+function occluderSources(entities) {
+    const sources = [];
+    for (const entity of entities) {
+        for (const component of entity.components) {
+            if (!(component instanceof Tilemap))
+                continue;
+            sources.push({
+                originX: entity.position.x,
+                originY: entity.position.y,
+                cellSize: component.cellSize,
+                mapWidth: component.mapWidth,
+                mapHeight: component.mapHeight,
+                cells: component.cells,
+                solidTiles: component.solidTiles,
+            });
+        }
+    }
+    return sources;
+}
+/**
+ * Draws one frame (issue #78, ADR 0026). Off path (B4): an unlit scene with
+ * no Post Effect is one render straight into the canvas, exactly as before,
+ * and nothing here is ever built. Lit: the scene without its Emissive
+ * drawables, then the light-map multiplied over it, then the Emissive
+ * drawables. With a Post Effect, all of that goes into a target drawn like the
+ * canvas and
+ * one pass writes it to the canvas.
+ */
+export class FrameComposer {
+    surface;
+    lightMap = null;
+    postPass = null;
+    size = new THREE.Vector2();
+    constructor(surface) {
+        this.surface = surface;
+    }
+    draw() {
+        // Full Ambient Light: the light-map would be 1 everywhere, so nothing to multiply.
+        // A 3D scene never builds one: its lights are three's own (ADR 0027).
+        const { game } = this.surface;
+        const lit = game.space === '2d' && game.lighting.active && !ambientIsFull(game.lighting);
+        const post = game.post.active;
+        if (!lit && !post) {
+            this.clearLetterbox();
+            this.drawScene();
+            return;
+        }
+        const { width, height } = this.frameSize();
+        if (!post) {
+            this.clearLetterbox();
+            this.drawLit(width, height);
+            return;
+        }
+        this.drawThroughPost(width, height, lit);
+    }
+    dispose() {
+        this.lightMap?.dispose();
+        this.lightMap = null;
+        this.postPass?.dispose();
+        this.postPass = null;
+    }
+    /** The light-map's (and the Post Effects') size: the internal resolution, else the drawing buffer (B2). */
+    frameSize() {
+        const { renderer, resolution } = this.surface;
+        if (resolution)
+            return { width: Math.max(1, Math.round(resolution.width)), height: Math.max(1, Math.round(resolution.height)) };
+        renderer.getDrawingBufferSize(this.size);
+        return { width: Math.max(1, this.size.x), height: Math.max(1, this.size.y) };
+    }
+    /** Letterbox bars: clear the whole canvas, then render inside the scissor. */
+    clearLetterbox() {
+        const { renderer, resolution } = this.surface;
+        if (!resolution)
+            return;
+        renderer.setScissorTest(false);
+        renderer.setClearColor(0x000000, 1);
+        renderer.clear(true, false, false);
+        renderer.setScissorTest(true);
+    }
+    /** The scene through its Sprite Batches (ADR 0024), for the camera's current layers. */
+    drawScene() {
+        const { spriteBatches, renderer } = this.surface;
+        const { scene, camera, space } = this.surface.game;
+        // A 3D scene has no sprites to batch: it draws straight, the depth buffer ordering it.
+        if (space === '3d') {
+            renderer.render(scene, camera);
+            return;
+        }
+        spriteBatches.drawFrame(scene, camera, () => renderer.render(scene, camera));
+    }
+    /** The scene for one layer mask, restoring the camera's own mask after. */
+    drawLayers(mask) {
+        const layers = this.surface.game.camera.layers;
+        const own = layers.mask;
+        layers.mask = mask;
+        try {
+            this.drawScene();
+        }
+        finally {
+            layers.mask = own;
+        }
+    }
+    /** Scene, light-map, Emissive drawables, into whatever target is bound now. */
+    drawLit(width, height) {
+        this.drawLayers(LIT_MASK);
+        this.composeLight(width, height);
+    }
+    composeLight(width, height) {
+        const { renderer } = this.surface;
+        const { scene, camera, lighting } = this.surface.game;
+        this.lightMap ??= new LightMap();
+        this.lightMap.render(renderer, camera, {
+            width,
+            height,
+            ambient: ambientMultiplier(lighting),
+            lights: lighting.lights,
+            projection: this.surface.game.projection,
+            occluderRevision: occluderSignature(this.surface.game),
+            occluders: () => buildOccluderGrid(occluderSources(this.surface.game.entities)),
+        });
+        const autoClear = renderer.autoClear;
+        const background = scene.background;
+        renderer.autoClear = false;
+        scene.background = null;
+        try {
+            this.lightMap.multiplyOver(renderer);
+            this.drawLayers(EMISSIVE_MASK);
+        }
+        finally {
+            renderer.autoClear = autoClear;
+            scene.background = background;
+        }
+    }
+    /** The frame into the Post Effects' canvas-like target, then one pass to the canvas (CA-11). */
+    drawThroughPost(width, height, lit) {
+        const { renderer } = this.surface;
+        const { post } = this.surface.game;
+        this.postPass ??= new PostPass();
+        this.postPass.resize(width, height);
+        // The target stores what the canvas would, so the scene's own (canvas) background clears it.
+        renderer.setRenderTarget(this.postPass.target);
+        try {
+            if (lit)
+                this.drawLit(width, height);
+            else
+                this.drawScene();
+        }
+        finally {
+            renderer.setRenderTarget(null);
+        }
+        this.clearLetterbox();
+        this.postPass.draw(renderer, { vignette: post.vignette, colorGrade: post.colorGrade });
+    }
+}

package/dist/occluder-grid.d.ts

@@ -0,0 +1,19 @@
+import type { OccluderGrid } from './light-field.js';
+/** What a Tilemap contributes to occlusion: its logical grid and which of its tiles are solid. */
+export interface OccluderSource {
+    originX: number;
+    originY: number;
+    cellSize: number;
+    mapWidth: number;
+    mapHeight: number;
+    cells: readonly number[];
+    solidTiles: readonly number[];
+}
+/**
+ * Every Tilemap's solid tiles rasterized onto one logical grid (inference 8):
+ * the finest cell size among them, spanning all their maps. With a single
+ * Tilemap — or several sharing a cell size and an aligned origin — each grid
+ * cell is exactly one tile. Null when no solid tile is placed anywhere: the
+ * lights then cast no shadow at all.
+ */
+export declare function buildOccluderGrid(sources: readonly OccluderSource[]): OccluderGrid | null;

package/dist/occluder-grid.js

@@ -0,0 +1,50 @@
+/** Floating-point slack so a tile edge lying on a grid line covers no neighbouring cell. */
+const EDGE = 1e-6;
+function solidBoxes(source) {
+    const solid = new Set(source.solidTiles);
+    const width = Math.max(0, Math.floor(source.mapWidth));
+    const height = Math.max(0, Math.floor(source.mapHeight));
+    const size = source.cellSize;
+    const boxes = [];
+    if (!(size > 0) || solid.size === 0)
+        return boxes;
+    for (let index = 0; index < width * height; index += 1) {
+        if (!solid.has(source.cells[index] ?? -1))
+            continue;
+        const minX = source.originX + (index % width) * size;
+        const minY = source.originY + Math.floor(index / width) * size;
+        boxes.push({ minX, minY, maxX: minX + size, maxY: minY + size });
+    }
+    return boxes;
+}
+/**
+ * Every Tilemap's solid tiles rasterized onto one logical grid (inference 8):
+ * the finest cell size among them, spanning all their maps. With a single
+ * Tilemap — or several sharing a cell size and an aligned origin — each grid
+ * cell is exactly one tile. Null when no solid tile is placed anywhere: the
+ * lights then cast no shadow at all.
+ */
+export function buildOccluderGrid(sources) {
+    const contributing = sources.map((source) => ({ source, boxes: solidBoxes(source) })).filter(({ boxes }) => boxes.length > 0);
+    if (contributing.length === 0)
+        return null;
+    const cellSize = Math.min(...contributing.map(({ source }) => source.cellSize));
+    const originX = Math.min(...contributing.map(({ source }) => source.originX));
+    const originY = Math.min(...contributing.map(({ source }) => source.originY));
+    const right = Math.max(...contributing.map(({ source }) => source.originX + Math.floor(source.mapWidth) * source.cellSize));
+    const top = Math.max(...contributing.map(({ source }) => source.originY + Math.floor(source.mapHeight) * source.cellSize));
+    const columns = Math.max(1, Math.ceil((right - originX) / cellSize - EDGE));
+    const rows = Math.max(1, Math.ceil((top - originY) / cellSize - EDGE));
+    const solid = new Uint8Array(columns * rows);
+    for (const { boxes } of contributing) {
+        for (const box of boxes) {
+            const fromColumn = Math.max(0, Math.floor((box.minX - originX) / cellSize + EDGE));
+            const toColumn = Math.min(columns, Math.ceil((box.maxX - originX) / cellSize - EDGE));
+            const fromRow = Math.max(0, Math.floor((box.minY - originY) / cellSize + EDGE));
+            const toRow = Math.min(rows, Math.ceil((box.maxY - originY) / cellSize - EDGE));
+            for (let row = fromRow; row < toRow; row += 1)
+                solid.fill(1, row * columns + fromColumn, row * columns + toColumn);
+        }
+    }
+    return { originX, originY, cellSize, columns, rows, solid };
+}

package/dist/particle-batch.js

@@ -3,6 +3,7 @@ import { reportRejection } from './report-rejection.js';
 import { ParticlePool, particleValueAt, } from './particle-pool.js';
 import { projectIsometric } from './projection.js';
 import { refreshParticleSortBounds } from './particle-sort-bounds.js';
+import { TRANSPARENT_TEXEL_ALPHA } from './render-layers.js';
 function createGeometry(capacity) {
     const geometry = new THREE.BufferGeometry();
     const uvs = new Float32Array(capacity * 8);
@@ -38,8 +39,8 @@ export class ParticleBatch {
         this._layer = Number.isFinite(layer) ? layer : 0;
         this.material = new THREE.MeshBasicMaterial({
             color: 0xffffff,
-            transparent: true,
-            vertexColors: true,
+            // alphaTest: see TRANSPARENT_TEXEL_ALPHA (an Emissive behind shows through transparent texels).
+            transparent: true, alphaTest: TRANSPARENT_TEXEL_ALPHA, vertexColors: true,
             depthTest: true,
             depthWrite: true,
             blending: blend === 'additive' ? THREE.AdditiveBlending : THREE.NormalBlending,

package/dist/physics-3d/body-contacts.d.ts

@@ -0,0 +1,10 @@
+import type { Game } from '../game.js';
+import type { PhysicsWorld } from './physics-world.js';
+/**
+ * After the physics step (CA-15): every component on an entity with a solid
+ * Collider that implements `onBodyContact` hears about each other entity it
+ * touches, once per step, with the normal pointing from it to the other. The
+ * common scene, where no component listens, allocates nothing here: the
+ * narrow phase is read only for an entity that has a receiver.
+ */
+export declare function dispatchBodyContacts(game: Game, world: PhysicsWorld): void;

package/dist/physics-3d/body-contacts.js

@@ -0,0 +1,59 @@
+/** Adds zero so a negated zero reads as 0, not -0. */
+const clean = (value) => value + 0;
+/** The contact one Rapier manifold makes for `record` against `other`, or null when it holds no solver contact point. */
+function manifoldContact(sides, manifold, flipped) {
+    const [record, other] = sides;
+    const point = manifold.numSolverContacts() > 0 ? manifold.solverContactPoint(0) : null;
+    if (!point)
+        return null;
+    // The manifold's normal points from its first shape to its second; `flipped` says that first shape is the other one, so it is negated to point from ours.
+    const n = manifold.normal();
+    const sign = flipped ? -1 : 1;
+    return {
+        entity: record.entity,
+        other: other.entity,
+        normal: { x: clean(sign * n.x), y: clean(sign * n.y), z: clean(sign * n.z) },
+        point: { x: point.x, y: point.y, z: point.z },
+    };
+}
+/** The solid contacts of one body this step, one per other entity, read from Rapier's narrow phase. */
+function contactsOf(world, record) {
+    const contacts = new Map();
+    world.raw.contactPairsWith(record.shape, (shape) => {
+        const other = world.recordOfCollider(shape.handle);
+        if (!other || other === record || contacts.has(other))
+            return;
+        world.raw.contactPair(record.shape, shape, (manifold, flipped) => {
+            const contact = contacts.has(other) ? null : manifoldContact([record, other], manifold, flipped);
+            if (contact)
+                contacts.set(other, contact);
+        });
+    });
+    return [...contacts.values()];
+}
+const listens = (component) => typeof component.onBodyContact === 'function';
+function deliver(contacts, receivers) {
+    for (const contact of contacts) {
+        if (!contact.entity.alive || !contact.other.alive)
+            continue;
+        for (const component of receivers)
+            component.onBodyContact?.(contact);
+    }
+}
+/**
+ * After the physics step (CA-15): every component on an entity with a solid
+ * Collider that implements `onBodyContact` hears about each other entity it
+ * touches, once per step, with the normal pointing from it to the other. The
+ * common scene, where no component listens, allocates nothing here: the
+ * narrow phase is read only for an entity that has a receiver.
+ */
+export function dispatchBodyContacts(game, world) {
+    for (const entity of game.entities) {
+        if (game.physics.world !== world)
+            return;
+        const record = world.recordOf(entity);
+        if (!record || record.sensor || !entity.alive || !entity.components.some(listens))
+            continue;
+        deliver(contactsOf(world, record), entity.components.filter(listens));
+    }
+}

package/dist/physics-3d/body-sync.d.ts

@@ -0,0 +1,52 @@
+import type { Collider } from '../components/collider.js';
+import { RigidBody } from '../components/rigid-body.js';
+import type { Entity } from '../entity.js';
+import type { RapierBody, RapierCollider, RapierModule, RapierWorld } from './rapier-module.js';
+/** Rapier's three body types, as the Runtime Snapshot names them. */
+export type BodyKind = 'fixed' | 'dynamic' | 'kinematic';
+/** What a body is built from: the entity and the Collider and RigidBody components it has. */
+export interface BodyParts {
+    readonly entity: Entity;
+    readonly collider: Collider;
+    readonly rigid: RigidBody | null;
+}
+/** One entity's body in the world: its components and the Rapier handles built from them. */
+export interface BodyRecord {
+    readonly entity: Entity;
+    readonly collider: Collider;
+    readonly rigid: RigidBody | null;
+    readonly kind: BodyKind;
+    /** Whether the Rapier collider was built as a sensor; frozen here because `Collider.sensor` is a plain field a script may flip later. */
+    readonly sensor: boolean;
+    readonly body: RapierBody;
+    readonly shape: RapierCollider;
+    /** Whether a kinematic body stands on something after the last step; written by the character controller. */
+    grounded: boolean;
+    /** A kinematic body's vertical velocity (units per second), integrated by the character controller. */
+    vy: number;
+    /** A kinematic body's movement over the last step, per second. */
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** Why this collider cannot become a Rapier shape, or null when it can. */
+export declare function colliderProblem(collider: Collider): string | null;
+/** Why this RigidBody cannot become a Rapier body, or null when it can (the mirror of `colliderProblem`). */
+export declare function rigidBodyProblem(rigid: RigidBody): string | null;
+/**
+ * Builds the entity's body and collider from its components and puts them in
+ * the world. Static bodies are created once and never follow the entity; a
+ * dynamic body is Rapier's from here on. The caller has checked the parts
+ * with `colliderProblem` and `rigidBodyProblem`.
+ */
+export declare function createBody(R: RapierModule, world: RapierWorld, parts: BodyParts): BodyRecord;
+/** A body's linear velocity: Rapier's for a dynamic one, the measured movement of a kinematic one, none for a fixed one. */
+export declare function bodyVelocity(record: BodyRecord): {
+    x: number;
+    y: number;
+    z: number;
+};
+/** After a step: a moving body's pose becomes its entity's (a sleeping dynamic body has not moved). */
+export declare function syncBodyPose(record: BodyRecord): void;