@cimplify/sdk 0.108.0 → 0.110.2

package/dist/features-CZB4rmcD.d.ts

@@ -0,0 +1,118 @@
+declare const ENGINE_AUDIO_EXPORT_NAMES: readonly ["engine_audio_bound", "engine_audio_load_pcm", "engine_audio_load_wav", "engine_audio_release", "engine_audio_create_bus", "engine_audio_set_bus_gain", "engine_audio_set_bus_filter", "engine_audio_set_duck", "engine_audio_play", "engine_audio_stop", "engine_audio_set_voice_gain", "engine_audio_set_voice_rate", "engine_audio_is_playing", "engine_audio_set_listener", "engine_audio_place", "engine_audio_set_voice_spatial", "engine_audio_registers", "engine_audio_update", "engine_audio_meter", "engine_audio_suspend", "engine_audio_resume", "engine_audio_reset"];
+declare const ENGINE_AUDIO_OPTIONAL_EXPORTS: readonly ["engine_audio_replace", "engine_audio_set_sound_limit", "engine_audio_set_voice_budget", "engine_audio_set_voice_filter", "engine_audio_set_limiter", "engine_audio_now", "engine_audio_play_at", "engine_audio_stop_at", "engine_audio_set_voice_binaural", "engine_audio_set_voice_occlusion", "engine_audio_occlude", "engine_audio_music_tempo", "engine_audio_music_play", "engine_audio_music_layer", "engine_audio_music_stinger", "engine_audio_music_stop", "engine_audio_music_position", "engine_audio_capture", "engine_audio_set_voice_loop", "engine_audio_create_convolver", "engine_audio_set_bus_send", "engine_audio_create_reverb", "engine_audio_stream_open", "engine_audio_stream_feed", "engine_audio_stream_space", "engine_audio_stream_play", "engine_audio_stream_gain", "engine_audio_stream_flush", "engine_audio_stream_time", "engine_audio_stream_close", "engine_audio_stream_open_opus", "engine_audio_stream_seek", "engine_audio_stream_loop", "engine_audio_stream_duration", "engine_audio_lockstep", "engine_audio_clock", "engine_audio_create_emitters", "engine_audio_feed_emitters", "engine_audio_release_emitters", "engine_audio_relay_create", "engine_audio_relay_pump", "engine_audio_relay_receive"];
+type AudioExport = (...args: number[]) => number;
+type EngineAudioExports = Readonly<Record<(typeof ENGINE_AUDIO_EXPORT_NAMES)[number], AudioExport>> & Readonly<Partial<Record<(typeof ENGINE_AUDIO_OPTIONAL_EXPORTS)[number], AudioExport>>>;
+interface AssetTaker {
+    take(asset: string, priority?: number, stall?: boolean): Promise<Uint8Array>;
+    has?(asset: string): boolean;
+}
+interface EngineAudioRelay {
+    pump(): void;
+    suspend?(): void;
+    resume?(): void;
+}
+
+declare const WORKLET_PROCESSOR_NAME = "cimplify-audio";
+interface WorkletProcessorOptions {
+    readonly module: WebAssembly.Module;
+    readonly voices: number;
+    readonly sizes: readonly number[];
+    readonly inputWords: number;
+    readonly reportQuanta: number;
+    readonly inbound: SharedArrayBuffer | null;
+    readonly outbound: SharedArrayBuffer | null;
+}
+declare const WORKLET_PROCESSOR_SOURCE = "\nconst RING_HEADER_WORDS = 2;\nconst RING_WRITE = 0;\nconst RING_READ = 1;\n\nclass CimplifyAudioProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const o = options.processorOptions;\n    const instance = new WebAssembly.Instance(o.module, {});\n    this.x = instance.exports;\n    const sizes = new Uint32Array(this.x.memory.buffer, this.x.worklet_sizes(), o.sizes.length);\n    for (let k = 0; k < o.sizes.length; k++) sizes[k] = o.sizes[k];\n    this.host = this.x.worklet_create(sampleRate, o.voices, o.inputWords);\n    this.capacity = this.x.worklet_input_words(this.host);\n    this.pending = 0;\n    this.queue = [];\n    this.queued = 0;\n    this.reportQuanta = o.reportQuanta;\n    this.quanta = 0;\n    this.buffer = null;\n    this.inbound = o.inbound === null ? null : new Int32Array(o.inbound);\n    this.outbound = o.outbound === null ? null : new Int32Array(o.outbound);\n    if (this.inbound === null) {\n      this.port.onmessage = (event) => {\n        this.queue.push(event.data);\n      };\n    }\n  }\n\n  views() {\n    const buffer = this.x.memory.buffer;\n    if (this.buffer === buffer) return;\n    this.buffer = buffer;\n    this.input = new Uint32Array(buffer, this.x.worklet_input(this.host), this.capacity);\n    this.left = new Float32Array(buffer, this.x.worklet_output(this.host, 0), 4096);\n    this.right = new Float32Array(buffer, this.x.worklet_output(this.host, 1), 4096);\n  }\n\n  fromRing() {\n    const ring = this.inbound;\n    const capacity = ring.length - RING_HEADER_WORDS;\n    const write = Atomics.load(ring, RING_WRITE);\n    let read = Atomics.load(ring, RING_READ);\n    let available = (write - read) | 0;\n    const room = this.capacity - this.pending;\n    if (available > room) available = room;\n    for (let k = 0; k < available; k++) {\n      this.input[this.pending + k] = ring[RING_HEADER_WORDS + ((read + k) & (capacity - 1))];\n    }\n    this.pending += available;\n    Atomics.store(ring, RING_READ, (read + available) | 0);\n  }\n\n  fromQueue() {\n    while (this.queue.length > 0 && this.pending < this.capacity) {\n      const head = this.queue[0];\n      const take = Math.min(head.length - this.queued, this.capacity - this.pending);\n      this.input.set(head.subarray(this.queued, this.queued + take), this.pending);\n      this.pending += take;\n      this.queued += take;\n      if (this.queued === head.length) {\n        this.queue.shift();\n        this.queued = 0;\n      }\n    }\n  }\n\n  ingest() {\n    this.views();\n    if (this.inbound !== null) this.fromRing();\n    else this.fromQueue();\n    if (this.pending === 0) return;\n    const used = this.x.worklet_ingest(this.host, this.pending);\n    if (used > 0) {\n      this.input.copyWithin(0, used, this.pending);\n      this.pending -= used;\n    }\n  }\n\n  report() {\n    const words = this.x.worklet_report(this.host);\n    this.views();\n    const report = new Uint32Array(this.x.memory.buffer, this.x.worklet_report_buffer(this.host), words);\n    if (this.outbound === null) {\n      this.port.postMessage(report.slice());\n      return;\n    }\n    const ring = this.outbound;\n    const capacity = ring.length - RING_HEADER_WORDS;\n    const write = Atomics.load(ring, RING_WRITE);\n    const read = Atomics.load(ring, RING_READ);\n    if (capacity - ((write - read) | 0) < words) return;\n    for (let k = 0; k < words; k++) ring[RING_HEADER_WORDS + ((write + k) & (capacity - 1))] = report[k];\n    Atomics.store(ring, RING_WRITE, (write + words) | 0);\n  }\n\n  process(inputs, outputs) {\n    this.ingest();\n    const out = outputs[0];\n    const frames = out[0].length;\n    this.x.worklet_render(this.host, frames);\n    this.views();\n    out[0].set(this.left.subarray(0, frames));\n    if (out.length > 1) out[1].set(this.right.subarray(0, frames));\n    this.ingest();\n    this.quanta += 1;\n    if (this.quanta >= this.reportQuanta) {\n      this.quanta = 0;\n      this.report();\n    }\n    return true;\n  }\n}\n\nregisterProcessor(\"cimplify-audio\", CimplifyAudioProcessor);\n";
+
+declare const ENGINE_MIX_RATE = 48000;
+interface WorkletSizes {
+    readonly arenaFloats: number;
+    readonly streamFrames: number;
+    readonly reverbs: number;
+    readonly reverbPartitions: number;
+    readonly banks: number;
+    readonly emitters: number;
+}
+declare const DEFAULT_WORKLET_SIZES: WorkletSizes;
+interface WorkletPort {
+    onmessage: ((event: {
+        readonly data: Uint32Array;
+    }) => void) | null;
+    postMessage(message: Uint32Array, transfer?: Transferable[]): void;
+}
+interface WorkletNodeLike {
+    readonly port: WorkletPort;
+    connect(destination: unknown): unknown;
+}
+interface WorkletContextLike {
+    readonly sampleRate: number;
+    readonly destination: unknown;
+    readonly audioWorklet: {
+        addModule(url: string): Promise<void>;
+    };
+    readonly state?: string;
+    suspend?(): Promise<void>;
+    resume?(): Promise<void>;
+}
+interface WorkletEngine {
+    readonly exports: EngineAudioExports;
+    readonly memory: {
+        readonly buffer: ArrayBufferLike;
+    };
+    allocate(bytes: number): number;
+    release(pointer: number, bytes: number): void;
+}
+interface WorkletAudioOptions {
+    readonly context: WorkletContextLike;
+    readonly module: WebAssembly.Module | PromiseLike<WebAssembly.Module>;
+    readonly idlePumps?: number;
+    readonly voices?: number;
+    readonly sizes?: WorkletSizes;
+    readonly shared?: boolean;
+    readonly pumpWords?: number;
+    readonly ringWords?: number;
+    readonly reportQuanta?: number;
+    readonly moduleUrl?: (source: string) => string;
+    readonly createNode?: (context: WorkletContextLike, name: string, options: WorkletProcessorOptions) => WorkletNodeLike;
+}
+declare function sharedMemoryAvailable(): boolean;
+declare class WorkletAudio implements EngineAudioRelay {
+    readonly handle: number;
+    readonly shared: boolean;
+    private readonly engine;
+    private readonly staging;
+    private readonly stagingWords;
+    private readonly inbound;
+    private readonly outbound;
+    private readonly backlog;
+    private readonly reports;
+    private readonly context;
+    private readonly idlePumps;
+    private node;
+    private failed;
+    private meterView;
+    private quiet;
+    private idled;
+    private hidden;
+    private constructor();
+    static create(engine: WorkletEngine, options: WorkletAudioOptions): WorkletAudio;
+    get idle(): boolean;
+    suspend(): void;
+    resume(): void;
+    private silent;
+    private settle;
+    get ready(): boolean;
+    get error(): unknown;
+    private attach;
+    private send;
+    private drainBacklog;
+    private receive;
+    private collect;
+    pump(): void;
+}
+
+interface EngineGraphicsOptions {
+    readonly pointShadows?: boolean;
+}
+
+export { type AssetTaker as A, DEFAULT_WORKLET_SIZES as D, type EngineGraphicsOptions as E, type WorkletAudioOptions as W, ENGINE_MIX_RATE as a, WORKLET_PROCESSOR_NAME as b, WORKLET_PROCESSOR_SOURCE as c, WorkletAudio as d, type WorkletSizes as e, sharedMemoryAvailable as s };

package/dist/fit-BWiE7rgA.d.mts

@@ -0,0 +1,44 @@
+import { R as Rgb, I as IdentityBase, a as IdentityParams } from './params-DxFb5G_U.mjs';
+
+interface CapturedColours {
+    readonly skin: Rgb;
+    readonly hair: Rgb | null;
+    readonly eye: Rgb | null;
+}
+
+interface IdentityCapture {
+    readonly landmarks: Float32Array;
+    readonly aspect: number;
+    readonly colours: CapturedColours | null;
+}
+interface IdentityFitOptions {
+    readonly stylise?: number;
+    readonly residual?: boolean;
+    readonly body?: Float32Array;
+    readonly hairStyle?: number;
+    readonly brows?: number;
+    readonly facialHair?: number;
+    readonly continuousTone?: boolean;
+}
+interface IdentityCamera {
+    readonly scale: number;
+    readonly rows: Float64Array;
+    readonly translation: readonly [number, number];
+}
+interface IdentityFit {
+    readonly params: IdentityParams;
+    readonly error: number;
+    readonly camera: IdentityCamera;
+}
+declare class IdentityFitter {
+    readonly base: IdentityBase;
+    private readonly anchors;
+    private readonly faceBasis;
+    private readonly bodyBasis;
+    constructor(base: IdentityBase);
+    anchorPositions(face: Float32Array | Float64Array, body: Float32Array | Float64Array, out: Float64Array): void;
+    observations(capture: IdentityCapture): Float64Array;
+    fit(capture: IdentityCapture, options?: IdentityFitOptions): IdentityFit;
+}
+
+export { type CapturedColours as C, type IdentityCapture as I, IdentityFitter as a, type IdentityFitOptions as b, type IdentityFit as c };

package/dist/fit-DK0oT7zO.d.ts

@@ -0,0 +1,44 @@
+import { R as Rgb, I as IdentityBase, a as IdentityParams } from './params-DxFb5G_U.js';
+
+interface CapturedColours {
+    readonly skin: Rgb;
+    readonly hair: Rgb | null;
+    readonly eye: Rgb | null;
+}
+
+interface IdentityCapture {
+    readonly landmarks: Float32Array;
+    readonly aspect: number;
+    readonly colours: CapturedColours | null;
+}
+interface IdentityFitOptions {
+    readonly stylise?: number;
+    readonly residual?: boolean;
+    readonly body?: Float32Array;
+    readonly hairStyle?: number;
+    readonly brows?: number;
+    readonly facialHair?: number;
+    readonly continuousTone?: boolean;
+}
+interface IdentityCamera {
+    readonly scale: number;
+    readonly rows: Float64Array;
+    readonly translation: readonly [number, number];
+}
+interface IdentityFit {
+    readonly params: IdentityParams;
+    readonly error: number;
+    readonly camera: IdentityCamera;
+}
+declare class IdentityFitter {
+    readonly base: IdentityBase;
+    private readonly anchors;
+    private readonly faceBasis;
+    private readonly bodyBasis;
+    constructor(base: IdentityBase);
+    anchorPositions(face: Float32Array | Float64Array, body: Float32Array | Float64Array, out: Float64Array): void;
+    observations(capture: IdentityCapture): Float64Array;
+    fit(capture: IdentityCapture, options?: IdentityFitOptions): IdentityFit;
+}
+
+export { type CapturedColours as C, type IdentityCapture as I, IdentityFitter as a, type IdentityFitOptions as b, type IdentityFit as c };

package/dist/five-a-side-Bv1AOUy3.d.mts

@@ -0,0 +1,115 @@
+import { G as Game, S as SeededRandom, R as RoomTransport } from './game-Bx8onkhX.mjs';
+import { F as FrameTime } from './backend-gUCzs5Kg.mjs';
+import { G as GameScene } from './fluid-DLlEj2cs.mjs';
+import { h as GenreTemplate } from './template-AhCdB1kW.mjs';
+
+declare const PITCH5: {
+    readonly halfLength: 15;
+    readonly halfWidth: 9;
+    readonly goalHalfWidth: 2.5;
+    readonly perTeam: 5;
+    readonly playerSpeed: 6.5;
+    readonly controlledSpeed: 7.5;
+    readonly ballFriction: 1.4;
+    readonly kickSpeed: 17;
+    readonly passSpeed: 11;
+    readonly controlRadius: 0.7;
+    readonly dribbleOffset: 0.55;
+    readonly shootRange: 11;
+    readonly kickCooldown: 0.35;
+    readonly kickoffSeconds: 1;
+    readonly bounce: 0.6;
+};
+declare const PLAYERS: number;
+declare const BALL: number;
+declare const ENTITIES: number;
+declare const INPUT_X = 0;
+declare const INPUT_Z = 1;
+declare const INPUT_KICK = 2;
+declare class FiveASideSim {
+    readonly xz: Float32Array<ArrayBuffer>;
+    readonly velocity: Float32Array<ArrayBuffer>;
+    readonly score: Int32Array<ArrayBuffer>;
+    readonly input: Float32Array<ArrayBuffer>;
+    readonly remote: Float32Array<ArrayBuffer>;
+    remoteActive: boolean;
+    remoteControlled: number;
+    controlled: number;
+    owner: number;
+    tick: number;
+    goals: number;
+    private kickoff;
+    private readonly timers;
+    private readonly scratch;
+    private readonly random;
+    constructor(random: SeededRandom);
+    step(time: FrameTime): void;
+    resetPositions(kicking: number): void;
+    private applyKickoff;
+    private pickControlled;
+    private pickRemote;
+    nearestToBall(team: number): number;
+    private movePlayer;
+    private aiShot;
+    private kickBy;
+    private resolveKick;
+    private claim;
+    private moveBall;
+    private scoreFor;
+}
+interface SnapshotRoomSeam {
+    readonly transport: RoomTransport;
+    readonly authority: boolean;
+}
+declare class FiveASide implements GameScene<Game> {
+    readonly name = "five-a-side";
+    sim: FiveASideSim | null;
+    readonly rendered: Float32Array<ArrayBuffer>;
+    private readonly seam;
+    private authorityNet;
+    private publisher;
+    private receiver;
+    private move;
+    private moveZ;
+    private kickAction;
+    private homeSlot;
+    private awaySlot;
+    private boxes;
+    private pitch;
+    private remoteInput;
+    private scores;
+    private readonly guestInput;
+    private guestTick;
+    private lastGoals;
+    constructor(seam?: SnapshotRoomSeam | null);
+    get goals(): number;
+    enter(game: Game): void;
+    exit(game: Game): void;
+    get score(): Int32Array;
+    fixedUpdate(game: Game): void;
+    private readInput;
+    private showScore;
+    update(): void;
+    private drawPitch;
+    private draw;
+}
+declare const fiveASideTemplate: GenreTemplate<FiveASide>;
+
+declare const fiveASide_BALL: typeof BALL;
+declare const fiveASide_ENTITIES: typeof ENTITIES;
+type fiveASide_FiveASide = FiveASide;
+declare const fiveASide_FiveASide: typeof FiveASide;
+type fiveASide_FiveASideSim = FiveASideSim;
+declare const fiveASide_FiveASideSim: typeof FiveASideSim;
+declare const fiveASide_INPUT_KICK: typeof INPUT_KICK;
+declare const fiveASide_INPUT_X: typeof INPUT_X;
+declare const fiveASide_INPUT_Z: typeof INPUT_Z;
+declare const fiveASide_PITCH5: typeof PITCH5;
+declare const fiveASide_PLAYERS: typeof PLAYERS;
+type fiveASide_SnapshotRoomSeam = SnapshotRoomSeam;
+declare const fiveASide_fiveASideTemplate: typeof fiveASideTemplate;
+declare namespace fiveASide {
+  export { fiveASide_BALL as BALL, fiveASide_ENTITIES as ENTITIES, fiveASide_FiveASide as FiveASide, fiveASide_FiveASideSim as FiveASideSim, fiveASide_INPUT_KICK as INPUT_KICK, fiveASide_INPUT_X as INPUT_X, fiveASide_INPUT_Z as INPUT_Z, fiveASide_PITCH5 as PITCH5, fiveASide_PLAYERS as PLAYERS, type fiveASide_SnapshotRoomSeam as SnapshotRoomSeam, fiveASide_fiveASideTemplate as fiveASideTemplate };
+}
+
+export { BALL as B, ENTITIES as E, FiveASide as F, INPUT_KICK as I, PITCH5 as P, type SnapshotRoomSeam as S, FiveASideSim as a, INPUT_X as b, INPUT_Z as c, PLAYERS as d, fiveASideTemplate as e, fiveASide as f };

package/dist/five-a-side-EC51SJY1.d.ts

@@ -0,0 +1,115 @@
+import { G as Game, S as SeededRandom, R as RoomTransport } from './game-fgQy2YIm.js';
+import { F as FrameTime } from './backend-gUCzs5Kg.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+import { h as GenreTemplate } from './template-BkEGVTQj.js';
+
+declare const PITCH5: {
+    readonly halfLength: 15;
+    readonly halfWidth: 9;
+    readonly goalHalfWidth: 2.5;
+    readonly perTeam: 5;
+    readonly playerSpeed: 6.5;
+    readonly controlledSpeed: 7.5;
+    readonly ballFriction: 1.4;
+    readonly kickSpeed: 17;
+    readonly passSpeed: 11;
+    readonly controlRadius: 0.7;
+    readonly dribbleOffset: 0.55;
+    readonly shootRange: 11;
+    readonly kickCooldown: 0.35;
+    readonly kickoffSeconds: 1;
+    readonly bounce: 0.6;
+};
+declare const PLAYERS: number;
+declare const BALL: number;
+declare const ENTITIES: number;
+declare const INPUT_X = 0;
+declare const INPUT_Z = 1;
+declare const INPUT_KICK = 2;
+declare class FiveASideSim {
+    readonly xz: Float32Array<ArrayBuffer>;
+    readonly velocity: Float32Array<ArrayBuffer>;
+    readonly score: Int32Array<ArrayBuffer>;
+    readonly input: Float32Array<ArrayBuffer>;
+    readonly remote: Float32Array<ArrayBuffer>;
+    remoteActive: boolean;
+    remoteControlled: number;
+    controlled: number;
+    owner: number;
+    tick: number;
+    goals: number;
+    private kickoff;
+    private readonly timers;
+    private readonly scratch;
+    private readonly random;
+    constructor(random: SeededRandom);
+    step(time: FrameTime): void;
+    resetPositions(kicking: number): void;
+    private applyKickoff;
+    private pickControlled;
+    private pickRemote;
+    nearestToBall(team: number): number;
+    private movePlayer;
+    private aiShot;
+    private kickBy;
+    private resolveKick;
+    private claim;
+    private moveBall;
+    private scoreFor;
+}
+interface SnapshotRoomSeam {
+    readonly transport: RoomTransport;
+    readonly authority: boolean;
+}
+declare class FiveASide implements GameScene<Game> {
+    readonly name = "five-a-side";
+    sim: FiveASideSim | null;
+    readonly rendered: Float32Array<ArrayBuffer>;
+    private readonly seam;
+    private authorityNet;
+    private publisher;
+    private receiver;
+    private move;
+    private moveZ;
+    private kickAction;
+    private homeSlot;
+    private awaySlot;
+    private boxes;
+    private pitch;
+    private remoteInput;
+    private scores;
+    private readonly guestInput;
+    private guestTick;
+    private lastGoals;
+    constructor(seam?: SnapshotRoomSeam | null);
+    get goals(): number;
+    enter(game: Game): void;
+    exit(game: Game): void;
+    get score(): Int32Array;
+    fixedUpdate(game: Game): void;
+    private readInput;
+    private showScore;
+    update(): void;
+    private drawPitch;
+    private draw;
+}
+declare const fiveASideTemplate: GenreTemplate<FiveASide>;
+
+declare const fiveASide_BALL: typeof BALL;
+declare const fiveASide_ENTITIES: typeof ENTITIES;
+type fiveASide_FiveASide = FiveASide;
+declare const fiveASide_FiveASide: typeof FiveASide;
+type fiveASide_FiveASideSim = FiveASideSim;
+declare const fiveASide_FiveASideSim: typeof FiveASideSim;
+declare const fiveASide_INPUT_KICK: typeof INPUT_KICK;
+declare const fiveASide_INPUT_X: typeof INPUT_X;
+declare const fiveASide_INPUT_Z: typeof INPUT_Z;
+declare const fiveASide_PITCH5: typeof PITCH5;
+declare const fiveASide_PLAYERS: typeof PLAYERS;
+type fiveASide_SnapshotRoomSeam = SnapshotRoomSeam;
+declare const fiveASide_fiveASideTemplate: typeof fiveASideTemplate;
+declare namespace fiveASide {
+  export { fiveASide_BALL as BALL, fiveASide_ENTITIES as ENTITIES, fiveASide_FiveASide as FiveASide, fiveASide_FiveASideSim as FiveASideSim, fiveASide_INPUT_KICK as INPUT_KICK, fiveASide_INPUT_X as INPUT_X, fiveASide_INPUT_Z as INPUT_Z, fiveASide_PITCH5 as PITCH5, fiveASide_PLAYERS as PLAYERS, type fiveASide_SnapshotRoomSeam as SnapshotRoomSeam, fiveASide_fiveASideTemplate as fiveASideTemplate };
+}
+
+export { BALL as B, ENTITIES as E, FiveASide as F, INPUT_KICK as I, PITCH5 as P, type SnapshotRoomSeam as S, FiveASideSim as a, INPUT_X as b, INPUT_Z as c, PLAYERS as d, fiveASideTemplate as e, fiveASide as f };