lecodes-sdk 0.20.0 → 0.20.2

package/dist/types/gl/Texture.d.ts

@@ -1,5 +1,28 @@
 import { type FetchResponse, type File } from "../runtime/fetch";
+/** `Texture.load` options. */
+export type TextureLoadOptions = {
+    /** `true` (default): colour, stored sRGB. `false`: data (normal map, mask, heightmap) — kept linear. */
+    srgb?: boolean;
+    /** Ignore `Texture.maxSize` for this texture (a lightmap page, a lookup table). */
+    fullSize?: boolean;
+};
 export declare class Texture {
+    static _maxSize: number;
+    /** Engine-wide cap on texture size (a "texture quality" setting), 0 = none. A KTX2 wider or
+     *  taller than this loses its top mip levels on load (nothing resampled, less memory and
+     *  bandwidth), a glTF PNG/JPEG is downsampled. Reaches textures loaded AFTER it is set — a loaded
+     *  level keeps its textures — so set it up front (`SceneOptions.maxTextureSize`, or before the
+     *  level loads) and apply a menu change on the next level load. Lightmap pages are exempt
+     *  (`TextureLoadOptions.fullSize`). A host may pin it (desktop `CREATOR_TEXTURE_MAX_SIZE`). */
+    static _anisotropy: number;
+    /** Engine-wide anisotropic filtering, 1 (off) … 16 (default 2; `SceneOptions.anisotropy` sets it up
+     *  front). A sampler is baked when its texture is bound, so like `maxSize` this reaches textures
+     *  loaded AFTER it — set it before the level loads. Measured on a lightmapped interior at 720p:
+     *  4× costs ~20 % of the frame over 1× on an integrated GPU. A host may pin it. */
+    static get anisotropy(): number;
+    static set anisotropy(level: number);
+    static get maxSize(): number;
+    static set maxSize(size: number);
     readonly width: number;
     readonly height: number;
     /** Horizontal wrap mode (U). */
@@ -23,5 +46,10 @@ export declare class Texture {
     }): Texture;
     /** Re-upload a rectangle of a `fromPixels` texture (same channel count). */
     update(x: number, y: number, width: number, height: number, data: Uint8Array): void;
-    static load(source: string | FetchResponse | File): Promise<Texture>;
+    /** Decode an image (PNG / JPG, or a KTX2 the core transcodes) into a texture. `srgb` (default
+     *  true) says the bytes are COLOUR, stored sRGB so the GPU linearises them on sample; pass
+     *  `false` for DATA — a normal map, a mask, a heightmap — which must come back as stored (a
+     *  flat normal read through sRGB bends by ~35°). A KTX2 decides by its own header. Image
+     *  textures get a mip chain (trilinear) on hosts that build one. */
+    static load(source: string | FetchResponse | File, options?: TextureLoadOptions): Promise<Texture>;
 }

package/dist/types/gl/animation/AnimationClip.d.ts

@@ -22,6 +22,19 @@ export type ClipInfo = {
     duration: number;
     trackCount: number;
 };
+/** What `AnimationClip.from(clip, …)` derives from a clip. */
+export type DeriveOptions = {
+    /** The clip MIRRORED — left ↔ right, the motion on the other side of the body (a stop that brakes on the
+     *  left foot brakes on the right). Derived on the rig of the clip's own file (joints pair by name, the
+     *  sagittal plane comes from the rest pose), so the result is the same on every model: its contacts,
+     *  phase, root motion and heading are the mirrored ones, its name is `<name>_M`. Only clips from a GLB
+     *  carry a rig; a curve-built clip cannot be mirrored. */
+    mirror?: boolean;
+    /** Start of the window, seconds of the source (default 0). */
+    from?: number;
+    /** End of the window, seconds of the source (default the clip's end). */
+    to?: number;
+};
 export declare class AnimationClip {
     /** Source name (the clip's name inside its file; `"clip"` for procedural clips). Informational —
      *  an Animator addresses clips by the key YOU give it. */
@@ -33,8 +46,8 @@ export declare class AnimationClip {
     private constructor();
     /** Mark a moment of the clip (SECONDS from its start) with an event name: `kick.addEvent(0.4, 'hit')`
      *  → `anim.on('hit', (clip, layer) => …)` fires when the playhead crosses it, loops included.
-     *  Events are part of the clip: every model playing it gets them; `slice()` keeps the ones inside
-     *  the range, re-timed. Chainable. */
+     *  Events are part of the clip: every model playing it gets them; `AnimationClip.from(clip, { from, to })`
+     *  keeps the ones inside the window, re-timed. Chainable. */
     addEvent(time: number, name: string): this;
     private _pushEvents;
     /** Load ONE clip from a GLB: the file's only/first clip, or the one named / at the given index. */
@@ -43,18 +56,18 @@ export declare class AnimationClip {
     static loadAll(source: string | FetchResponse): Promise<Record<string, AnimationClip>>;
     /** Build a clip from curves in code — no DCC needed. Keys are `[time, value]`; a track binds to the
      *  node of that name when the clip is used by an Animator (bones, or any child node). */
-    static from(def: ClipDef): AnimationClip;
-    /** A sub-range of this clip as a NEW clip — `[start, end]` seconds of the source, re-timed to 0
-     *  (`end` defaults to the clip's end; array-slice semantics). Cut a too-long take down to the
-     *  action, or carve several sub-clips out of one packed timeline:
+    static fromCurves(def: ClipDef): AnimationClip;
+    /** A NEW clip derived from `clip`: its mirror (`{ mirror: true }` — the other side of the body), a window
+     *  of it (`{ from, to }` seconds of the source, re-timed to 0; array-slice semantics), or both. Cut a
+     *  too-long take down to the action, carve several sub-clips out of one packed timeline, get the
+     *  left-footed stop from the right-footed one:
      *
-     *    clips: { Kick: kick.slice(0.2, 1.1) }
+     *    clips: { Kick: AnimationClip.from(kick, { from: 0.2, to: 1.1 }), StopM: AnimationClip.from(stop, { mirror: true }) }
      *
-     *  Keys outside the range are dropped and exact boundary values are interpolated in, so the
-     *  sliced clip starts and ends precisely on the source's pose at the cut points. Everything
-     *  downstream (blend spaces, events' 0–1 times, root motion, phase sync) sees a normal clip of
-     *  the new duration. */
-    slice(start: number, end?: number): AnimationClip;
+     *  A window drops the keys outside it and interpolates exact boundary values in, so the clip starts and
+     *  ends precisely on the source's pose at the cut points. Everything downstream (blend spaces, events'
+     *  times, root motion, foot contacts, phase sync) sees a normal clip. */
+    static from(clip: AnimationClip, options: DeriveOptions): AnimationClip;
     private static _label;
     private static _loadSet;
 }

package/dist/types/gl/animation/core.d.ts

@@ -6,18 +6,17 @@ import { Vec3 } from "../../math/vec";
 import type { Node } from "../Node";
 /** A position on a blend axis (1D) or plane (2D). */
 export type BlendPosition = number | readonly [number, number];
-/** The transition time (seconds) a play / playLoop without `fade` uses. */
-export declare const DEFAULT_FADE = 0.2;
 export type PlayOptions = {
-    /** Transition seconds — how long the difference to the pose the layer SHOWED takes to decay
-     *  (default 0.2; `0` = cut). Also the transition back at the end unless `fadeOut` overrides it. */
+    /** Transition seconds — how long the difference to the pose the layer SHOWED (its loop, a one-shot,
+     *  or rest) takes to decay. Default `0` = cut: a fade is always asked for, never implied. Also the
+     *  transition back to the loop at the end unless `fadeOut` overrides it. */
     fade?: number;
     /** Transition seconds for the way in only (overrides `fade`). */
     fadeIn?: number;
-    /** One-shots: the transition BACK at the end (overrides `fade`). It starts this long before the
-     *  clip ends — while it still plays — so the hand-over lands on the last pose, not after it. On a
-     *  layer with no loop to return to, giving `fadeOut` releases the layer at the end instead of
-     *  holding the last frame. */
+    /** One-shots: the transition BACK to the loop at the end (overrides `fade`; `0` = cut at the end).
+     *  It starts this long before the clip ends — while it still plays — so the hand-over lands on the
+     *  last pose, not after it. On a layer with no loop the clip HOLDS its last frame (a rock that broke
+     *  stays broken) — `anim.stop({ fade })` is the way back to rest. */
     fadeOut?: number;
     /** Playback rate for this clip (default 1). */
     speed?: number;
@@ -39,8 +38,8 @@ export type StopOptions = {
     fade?: number;
 };
 export type LoopOptions = {
-    /** Transition seconds from whatever the layer shows — its previous loop, or a one-shot still
-     *  playing (default 0.2; `0` = cut). */
+    /** Transition seconds from whatever the layer shows — its previous loop, a one-shot still playing,
+     *  or rest. Default `0` = cut: a loop wanting a transition asks for one (`{ fade: 0.2 }`). */
     fade?: number;
     /** Playback rate of the loop's clips (default 1). */
     speed?: number;
@@ -165,6 +164,12 @@ export type ClipInfo = {
     turnAt(time: number): number;
     /** the root's own speed at `time`, m/s — how fast the clip is moving the body right there */
     speedAt(time: number): number;
+    /** the PELVIS' yaw relative to the clip's heading at `time` (rad, + = left, wrapped to ±π): the stance twist
+     *  the heading leaves out — an idle stands ~43° off the course it starts along, a stop's tail turns into that
+     *  stance while the heading holds. A controller that switches clips mid-pose can keep the PELVIS continuous
+     *  (turn the node by the difference between the two clips' values) where keeping the course would swing
+     *  the body. Without a baked heading: the pelvis' yaw at frame 0 throughout. */
+    pelvisYawAt(time: number): number;
     /** the unit travel direction at `time` ([x, z], model space, held through stills) — integrate
      *  direction × d(travel) to reconstruct the root's 2D path (a treadmill display, a turn's arc) */
     directionAt(time: number): [number, number];

package/dist/types/gl/state.d.ts

@@ -1,5 +1,4 @@
 import type { Scene } from "./Scene";
 export declare const glState: {
     activeScene: Scene | null;
-    frame: number;
 };

package/dist/types/inject.d.ts

@@ -23,6 +23,10 @@ export { WebSocket } from "./runtime/net";
 export { Net, NetPlayer, Replicated, NetEntity, type NetMessage, type NetRole, type NetStatus, type NetEvents, type NetLaunch, type NetInput, type NetKind, type NetTransform } from "./net";
 export { __rpc, __channel, __serverOnly, RpcError, type ClientChannel } from "./runtime/rpc";
 export { AudioPlayer, VideoPlayer } from "./runtime/media";
+export { Sound, type SoundOptions } from "./audio/Sound";
+export { Voice, type VoiceEvents } from "./audio/Voice";
+export { Bus, REVERB_PRESETS, type ReverbPreset, type ReverbParams, type EchoParams } from "./audio/Bus";
+export { audio, type PlaySoundOptions, type SpatialOptions, type Rolloff, type AudioStats } from "./audio/audio";
 export { openFilePicker, files, type FileData } from "./runtime/files";
 export { share } from "./runtime/share";
 export { ClickEvent, TouchStartEvent, LongPressEvent } from "./runtime/touch";
@@ -84,6 +88,9 @@ export { Model } from "./gl/Model";
 export { Shape } from "./gl/Shape";
 export { Physics } from "./gl/Physics";
 export { Trigger } from "./gl/Trigger";
+export { AudioSource, type AudioCone } from "./gl/AudioSource";
+export { AudioZone } from "./gl/AudioZone";
+export { SceneAudio } from "./gl/SceneAudio";
 export { CharacterController } from "./gl/CharacterController";
 export { Vehicle } from "./gl/Vehicle";
 export type { DriveLayout, DifferentialMode, EngineConfig, SteeringConfig, AeroConfig } from "./gl/Vehicle";
@@ -121,8 +128,11 @@ export { Geometry } from "./gl/Geometry";
 export { InstancedMesh } from "./gl/InstancedMesh";
 export type { InstanceTransform } from "./gl/InstancedMesh";
 export { Texture } from "./gl/Texture";
+export type { TextureLoadOptions } from "./gl/Texture";
 export { Camera } from "./gl/Camera";
 export { Ray } from "./gl/Ray";
 export { Plane } from "./gl/Plane";
 export { Noise } from "./gl/Noise";
 export { Particles, Trail, curve, colorCurve } from "./gl/Particles";
+export { DecalSet } from "./gl/DecalSet";
+export type { DecalOptions, DecalSetOptions, DecalSpawnOptions, DecalPlacement } from "./gl/DecalSet";

package/dist/types/runtime/input.d.ts

@@ -8,6 +8,7 @@ export declare const InputChannel: {
     readonly WheelY: 5;
     readonly PointerLocked: 6;
     readonly GamepadCount: 7;
+    readonly PointerOnUI: 8;
     readonly GamepadBase: 16;
     readonly GamepadStride: 16;
     readonly PadConnected: 0;
@@ -64,6 +65,11 @@ export declare const mouse: {
      *  gesture (call it in a 'keydown' handler for MouseLeft); hosts drop it on focus loss and
      *  re-acquire on focus. Escape does NOT unlock by itself on native hosts — call `unlock()`. */
     readonly locked: boolean;
+    /** The primary button went down on a UI element (a button, a scrollable, an input, a modal
+     *  backdrop) and is still held. Stays true wherever the cursor drifts until the release, so
+     *  `if (!Input.mouse.onUI) look(Input.mouse.delta)` never turns a HUD drag into camera look.
+     *  Always false while `locked`. A press that fell through to the scene reads false. */
+    readonly onUI: boolean;
     lock(): boolean;
     unlock(): void;
 };
@@ -108,6 +114,11 @@ export declare const Input: {
          *  gesture (call it in a 'keydown' handler for MouseLeft); hosts drop it on focus loss and
          *  re-acquire on focus. Escape does NOT unlock by itself on native hosts — call `unlock()`. */
         readonly locked: boolean;
+        /** The primary button went down on a UI element (a button, a scrollable, an input, a modal
+         *  backdrop) and is still held. Stays true wherever the cursor drifts until the release, so
+         *  `if (!Input.mouse.onUI) look(Input.mouse.delta)` never turns a HUD drag into camera look.
+         *  Always false while `locked`. A press that fell through to the scene reads false. */
+        readonly onUI: boolean;
         lock(): boolean;
         unlock(): void;
     };

package/dist/types/ui/UIImage.d.ts

@@ -2,6 +2,7 @@ import type { FetchResponse } from "../runtime/fetch";
 import type { SvgSourceValue as SvgSource } from "../runtime/misc";
 import type { File } from "../runtime/fetch";
 import { Canvas } from "../canvas/Canvas";
+import type { Scene2D } from "../g2/Scene2D";
 import { type Color, type ElementStyle, type UIElementBase } from "./UINode";
 export type UIImageStyle = ElementStyle & {
     borderRadius?: number;
@@ -13,12 +14,21 @@ export type UIImageStyle = ElementStyle & {
 export type CanvasImageSource = {
     canvasSurface: number;
 };
-/** Accepted image sources. A Canvas is baked to a surface marker on assign. */
-export type ImageSource = string | FetchResponse | File | SvgSource | Canvas;
-/** The stored/resolved image source (a Canvas is resolved to a surface marker). */
-export type ResolvedImageSource = string | FetchResponse | File | SvgSource | CanvasImageSource;
+/** A live 2D scene as an image source: the host draws the scene into the node's box every frame
+ *  (the scene's camera, projected into the box). No intrinsic size — give the node a width and
+ *  height. */
+export type Scene2DImageSource = {
+    scene2d: number;
+};
+/** Accepted image sources. A Canvas is baked to a surface marker on assign; a Scene2D becomes a
+ *  live-scene marker. */
+export type ImageSource = string | FetchResponse | File | SvgSource | Canvas | Scene2D;
+/** The stored/resolved image source (a Canvas is resolved to a surface marker, a Scene2D to a
+ *  live-scene marker). */
+export type ResolvedImageSource = string | FetchResponse | File | SvgSource | CanvasImageSource | Scene2DImageSource;
 /** An image element. Sources: URL / `asset(...)`, fetch response / File, an SVG source
- *  (`assetIcon`), or a live Canvas (`canvas.update()` refreshes the node in place). */
+ *  (`assetIcon`), a live Canvas (`canvas.update()` refreshes the node in place), or a live Scene2D
+ *  (drawn into the box every frame — a minimap). */
 export interface UIImage extends UIElementBase<UIImageStyle> {
     readonly type: "image";
     /** The image source — writable to swap the picture in place. */