@call-me-sensei/toonlab 0.3.1 → 0.4.20

package/types/character/walkableCharacterRuntime.d.ts

@@ -0,0 +1,343 @@
+export function createCharacterControllerProfile(input?: {}): Readonly<{
+    bodyCenterAtRest: any;
+    capsuleHalfHeight: any;
+    capsuleRadius: any;
+    floatHeight: any;
+    modelOffsetY: any;
+    springSag: any;
+    targetHeight: any;
+}>;
+/**
+ * High-level, framework-neutral composition of character loading, animation,
+ * controller offsets, uneven ground, and water interaction.
+ */
+export function createWalkableCharacterRuntime(options?: {}): Promise<Readonly<{
+    character: any;
+    collision: any;
+    readonly frame: any;
+    ground: Readonly<{
+        config: Readonly<{
+            bodyOffset: 1;
+            fallThroughDepth: 1.2;
+            groundedTolerance: 0.1;
+            lockGrounded: true;
+            lockTolerance: 0.34;
+            maxLockVerticalSpeed: 1.25;
+        }>;
+        ground: any;
+        update: (input?: {}) => Readonly<{
+            canJump: boolean;
+            correction: string;
+            enabled: boolean;
+            error: number;
+            groundHeight: any;
+            groundNormal: any;
+            position: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            revision: number;
+            targetY: any;
+            velocity: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+        }>;
+    }>;
+    locomotion: Readonly<{
+        config: Readonly<{
+            blendDamping: 10;
+            jumpBlendDamping: 14;
+            jumpDuration: 1.25;
+            landingGrace: 0.15;
+            runSpeed: 3.1;
+            sitBlendDamping: 8;
+            swimBlendDamping: 8;
+            swimSprintSpeed: 3;
+            swimStrokeGrace: 0.6;
+            walkSpeed: 1.45;
+        }>;
+        readonly frame: any;
+        reset: () => void;
+        update: (input?: {}, deltaInput?: number) => Readonly<{
+            events: readonly (Readonly<{
+                type: "land" | "jump-end";
+            }> | Readonly<{
+                type: "jump-start";
+            }>)[];
+            revision: number;
+            state: "idle" | "walk" | "run" | "jump" | "swim" | "dive" | "tread" | "sit" | "freestyle" | "airborne";
+            timeScales: Readonly<{
+                freestyle: number;
+                run: number;
+                swim: number;
+                walk: number;
+            }>;
+            weights: Readonly<{
+                dive: number;
+                freestyle: number;
+                idle: number;
+                jump: number;
+                run: number;
+                sit: number;
+                swim: number;
+                tread: number;
+                walk: number;
+            }>;
+        }>;
+    }>;
+    profile: Readonly<{
+        bodyCenterAtRest: any;
+        capsuleHalfHeight: any;
+        capsuleRadius: any;
+        floatHeight: any;
+        modelOffsetY: any;
+        springSag: any;
+        targetHeight: any;
+    }>;
+    renderPasses: any;
+    update: (input?: {}, delta?: number) => Readonly<{
+        collision: Readonly<{
+            corrected: boolean;
+            enabled: boolean;
+            position: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            radius: any;
+        }>;
+        ground: Readonly<{
+            canJump: boolean;
+            correction: string;
+            enabled: boolean;
+            error: number;
+            groundHeight: any;
+            groundNormal: any;
+            position: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            revision: number;
+            targetY: any;
+            velocity: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+        }>;
+        locomotion: Readonly<{
+            events: readonly (Readonly<{
+                type: "land" | "jump-end";
+            }> | Readonly<{
+                type: "jump-start";
+            }>)[];
+            revision: number;
+            state: "idle" | "walk" | "run" | "jump" | "swim" | "dive" | "tread" | "sit" | "freestyle" | "airborne";
+            timeScales: Readonly<{
+                freestyle: number;
+                run: number;
+                swim: number;
+                walk: number;
+            }>;
+            weights: Readonly<{
+                dive: number;
+                freestyle: number;
+                idle: number;
+                jump: number;
+                run: number;
+                sit: number;
+                swim: number;
+                tread: number;
+                walk: number;
+            }>;
+        }>;
+        position: Readonly<{
+            x: number;
+            y: number;
+            z: number;
+        }>;
+        profile: Readonly<{
+            bodyCenterAtRest: any;
+            capsuleHalfHeight: any;
+            capsuleRadius: any;
+            floatHeight: any;
+            modelOffsetY: any;
+            springSag: any;
+            targetHeight: any;
+        }>;
+        revision: number;
+        velocity: Readonly<{
+            x: number;
+            y: number;
+            z: number;
+        }>;
+        water: Readonly<{
+            active: false;
+            constraints: any;
+            depth: number;
+            diving: false;
+            gravityScale: 1;
+            groundHeight: number;
+            inWater: boolean;
+            planarSpeed: number;
+            position: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            revision: number;
+            sprinting: false;
+            state: "ground";
+            surfaced: false;
+            surfaceTargetY: any;
+            swimming: false;
+            transition: "enter" | "exit";
+            velocity: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            waterHeight: number;
+            waterLevel: number;
+        }> | Readonly<{
+            active: true;
+            constraints: Readonly<{
+                maxPlanarSpeed: number;
+                maxY: number;
+                minY: number;
+            }>;
+            depth: number;
+            diving: boolean;
+            facingError: number;
+            gravityScale: 0;
+            groundHeight: number;
+            inWater: boolean;
+            planarSpeed: number;
+            position: Readonly<{
+                y: number;
+                x: number;
+                z: number;
+            }>;
+            revision: number;
+            sprinting: boolean;
+            state: "surface" | "dive";
+            surfaced: boolean;
+            surfaceTargetY: number;
+            swimming: true;
+            transition: "enter" | "exit";
+            velocity: Readonly<{
+                x: number;
+                y: 0;
+                z: number;
+            }>;
+            waterHeight: number;
+            waterLevel: number;
+        }>;
+    }>;
+    water: Readonly<{
+        config: Readonly<{
+            bedClearance: 0.88;
+            enterDepth: 1.25;
+            enterSurfaceAllowance: 0.35;
+            exitDepth: 1.02;
+            facingMinimum: 0.12;
+            flowDamping: 2;
+            inputDamping: 6;
+            idleDamping: 3;
+            maxDelta: 0.05;
+            speed: 2;
+            sprintSpeed: 3;
+            diveSpeed: 1.7;
+            surfaceGain: 3.2;
+            surfaceOffset: 0.2;
+            surfaceTolerance: 0.35;
+            verticalSpeed: 1.7;
+        }>;
+        readonly swimming: boolean;
+        reset: () => void;
+        update: (input?: {}, deltaInput?: number) => Readonly<{
+            active: false;
+            constraints: any;
+            depth: number;
+            diving: false;
+            gravityScale: 1;
+            groundHeight: number;
+            inWater: boolean;
+            planarSpeed: number;
+            position: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            revision: number;
+            sprinting: false;
+            state: "ground";
+            surfaced: false;
+            surfaceTargetY: any;
+            swimming: false;
+            transition: "enter" | "exit";
+            velocity: Readonly<{
+                x: number;
+                y: number;
+                z: number;
+            }>;
+            waterHeight: number;
+            waterLevel: number;
+        }> | Readonly<{
+            active: true;
+            constraints: Readonly<{
+                maxPlanarSpeed: number;
+                maxY: number;
+                minY: number;
+            }>;
+            depth: number;
+            diving: boolean;
+            facingError: number;
+            gravityScale: 0;
+            groundHeight: number;
+            inWater: boolean;
+            planarSpeed: number;
+            position: Readonly<{
+                y: number;
+                x: number;
+                z: number;
+            }>;
+            revision: number;
+            sprinting: boolean;
+            state: "surface" | "dive";
+            surfaced: boolean;
+            surfaceTargetY: number;
+            swimming: true;
+            transition: "enter" | "exit";
+            velocity: Readonly<{
+                x: number;
+                y: 0;
+                z: number;
+            }>;
+            waterHeight: number;
+            waterLevel: number;
+        }>;
+    }>;
+    enforce(body: any): any;
+    dispose(options: any): void;
+    setAnimationEnabled(enabled: any): any;
+}>>;
+/** Safe replace-in-place owner for character picker and scene transitions. */
+export function createWalkableCharacterSlot({ createRuntime }?: {
+    createRuntime?: typeof createWalkableCharacterRuntime;
+}): Readonly<{
+    readonly current: any;
+    replace(options: any): Promise<any>;
+    dispose(): void;
+}>;
+export const DEFAULT_CHARACTER_CONTROLLER_PROFILE: Readonly<{
+    capsuleHalfHeight: 0.54;
+    capsuleRadius: 0.28;
+    floatHeight: 0.18;
+    springSag: 0.04;
+    targetHeight: 1.7;
+}>;

package/types/character/waterInteractionController.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Framework-neutral swim controller. The host supplies a water-query object,
+ * a ground sampler, controller facts, and a camera-relative move vector.
+ */
+export function createWaterInteractionController(options?: {}): Readonly<{
+    config: Readonly<{
+        bedClearance: 0.88;
+        enterDepth: 1.25;
+        enterSurfaceAllowance: 0.35;
+        exitDepth: 1.02;
+        facingMinimum: 0.12;
+        flowDamping: 2;
+        inputDamping: 6;
+        idleDamping: 3;
+        maxDelta: 0.05;
+        speed: 2;
+        sprintSpeed: 3;
+        diveSpeed: 1.7;
+        surfaceGain: 3.2;
+        surfaceOffset: 0.2;
+        surfaceTolerance: 0.35;
+        verticalSpeed: 1.7;
+    }>;
+    readonly swimming: boolean;
+    reset: () => void;
+    update: (input?: {}, deltaInput?: number) => Readonly<{
+        active: false;
+        constraints: any;
+        depth: number;
+        diving: false;
+        gravityScale: 1;
+        groundHeight: number;
+        inWater: boolean;
+        planarSpeed: number;
+        position: Readonly<{
+            x: number;
+            y: number;
+            z: number;
+        }>;
+        revision: number;
+        sprinting: false;
+        state: "ground";
+        surfaced: false;
+        surfaceTargetY: any;
+        swimming: false;
+        transition: "enter" | "exit";
+        velocity: Readonly<{
+            x: number;
+            y: number;
+            z: number;
+        }>;
+        waterHeight: number;
+        waterLevel: number;
+    }> | Readonly<{
+        active: true;
+        constraints: Readonly<{
+            maxPlanarSpeed: number;
+            maxY: number;
+            minY: number;
+        }>;
+        depth: number;
+        diving: boolean;
+        facingError: number;
+        gravityScale: 0;
+        groundHeight: number;
+        inWater: boolean;
+        planarSpeed: number;
+        position: Readonly<{
+            y: number;
+            x: number;
+            z: number;
+        }>;
+        revision: number;
+        sprinting: boolean;
+        state: "surface" | "dive";
+        surfaced: boolean;
+        surfaceTargetY: number;
+        swimming: true;
+        transition: "enter" | "exit";
+        velocity: Readonly<{
+            x: number;
+            y: 0;
+            z: number;
+        }>;
+        waterHeight: number;
+        waterLevel: number;
+    }>;
+}>;
+/** Apply the current swim target before the physics step. */
+export function applyWaterInteractionFrame(body: any, frame: any, { wake }?: {
+    wake?: boolean;
+}): any;
+/** Re-apply swim constraints after third-party controller forces run. */
+export function enforceWaterInteractionFrame(body: any, frame: any, { wake }?: {
+    wake?: boolean;
+}): any;
+export const DEFAULT_WATER_INTERACTION_CONFIG: Readonly<{
+    bedClearance: 0.88;
+    enterDepth: 1.25;
+    enterSurfaceAllowance: 0.35;
+    exitDepth: 1.02;
+    facingMinimum: 0.12;
+    flowDamping: 2;
+    inputDamping: 6;
+    idleDamping: 3;
+    maxDelta: 0.05;
+    speed: 2;
+    sprintSpeed: 3;
+    diveSpeed: 1.7;
+    surfaceGain: 3.2;
+    surfaceOffset: 0.2;
+    surfaceTolerance: 0.35;
+    verticalSpeed: 1.7;
+}>;

package/types/cloud/ambientSkyBaker.d.ts

@@ -0,0 +1,18 @@
+export class AmbientSkyBaker {
+    zenithRadiance: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    horizonRadiance: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    groundBounceRadiance: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    sunTransmittance: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    _lastRayleigh: number;
+    _lastTurbidity: number;
+    _lastMultipleScattering: number;
+    _lastSunIntensity: number;
+    _lastGroundBounceAlbedo: THREE.Color;
+    _lastSunDirection: THREE.Vector3;
+    _view: THREE.Vector3;
+    _horizon: THREE.Vector3;
+    _out: THREE.Vector3;
+    _skyDiffuse: THREE.Vector3;
+    update(atmosphere: any, sun: any, cloudLighting: any): boolean;
+}
+import * as THREE from 'three';

package/types/cloud/cloudLighting.d.ts

@@ -0,0 +1,38 @@
+// Source inference fallback: public names retained with permissive signatures.
+export const CLOUD_DEEP_CONTRIBUTION: any;
+export const CLOUD_DEEP_EXTINCTION_SCALE: any;
+export const CLOUD_GROUND_HEMISPHERE_FRACTION: any;
+export const CLOUD_MOON_RIM_PATH: any;
+export const CLOUD_MULTISCATTER_ECCENTRICITY: any;
+export const CLOUD_MULTISCATTER_EXTINCTION: any;
+export const CLOUD_MULTISCATTER_SCATTER: any;
+export const CLOUD_PHASE_BACKWARD_G: any;
+export const CLOUD_PHASE_BASE_G: any;
+export const CLOUD_PHASE_BLEND: any;
+export const CLOUD_PHASE_FORWARD_G: any;
+export const CLOUD_PHASE_SILVER_INTENSITY: any;
+export const CLOUD_PHASE_SILVER_SPREAD: any;
+export const CLOUD_POWDER_EXPONENT: any;
+export function applyCloudBlueShadowNode(...args: any[]): any;
+export function applyCloudInnerPaintNode(...args: any[]): any;
+export function applyCloudLightBlendNode(...args: any[]): any;
+export function applyCloudShadowWashNode(...args: any[]): any;
+export function applyCloudStyleNode(...args: any[]): any;
+export function applyCloudTimePaletteNode(...args: any[]): any;
+export function applyCloudToneNode(...args: any[]): any;
+export function applyCloudTopLightNode(...args: any[]): any;
+export function applyCloudWhiteTopNode(...args: any[]): any;
+export function beerLambertNode(...args: any[]): any;
+export function cloudAmbientNode(...args: any[]): any;
+export function cloudBaseShadowNode(...args: any[]): any;
+export function cloudDirectionalAttenuationNode(...args: any[]): any;
+export function cloudDirectionalScatteringNode(...args: any[]): any;
+export function cloudGroundBounceNode(...args: any[]): any;
+export function cloudGroundRadianceNode(...args: any[]): any;
+export function cloudMoonDirectionalNode(...args: any[]): any;
+export function cloudMoonRimNode(...args: any[]): any;
+export function cloudPhaseNode(...args: any[]): any;
+export function cloudSkyAmbientNode(...args: any[]): any;
+export function cloudSunTransmittanceNode(...args: any[]): any;
+export function createCloudLightingModel(...args: any[]): any;
+export function powderNode(...args: any[]): any;

package/types/cloud/cloudParams.d.ts

@@ -0,0 +1,18 @@
+// Source inference fallback: public names retained with permissive signatures.
+export const CLOUD_EVOLUTION_AXIS: any;
+export const CLOUD_PARAMS_FIELD_SCHEMA: any;
+export const CLOUD_PARAM_GROUPS: any;
+export const CLOUD_PARAM_GROUP_IDS: any;
+export class CloudCirrus { constructor(...args: any[]); [key: string]: any; }
+export class CloudFade { constructor(...args: any[]); [key: string]: any; }
+export class CloudHaze { constructor(...args: any[]); [key: string]: any; }
+export class CloudLighting { constructor(...args: any[]); [key: string]: any; }
+export class CloudParamGroup { constructor(...args: any[]); [key: string]: any; }
+export class CloudParams { constructor(...args: any[]); [key: string]: any; }
+export class CloudShape { constructor(...args: any[]); [key: string]: any; }
+export class CloudWind { constructor(...args: any[]); [key: string]: any; }
+export const DEFAULT_CLOUD_PARAMS: any;
+export const MAX_MARCH_DIST_MARGIN: any;
+export function cloudParamsToLive(...args: any[]): any;
+export function createCloudParams(...args: any[]): any;
+export function normalizeCloudParams(...args: any[]): any;

package/types/cloud/cloudReprojection.d.ts

@@ -0,0 +1,15 @@
+// Source inference fallback: public names retained with permissive signatures.
+export const CLOUD_AMORTIZATION_BLOCK: any;
+export const CLOUD_HISTORY_CLAMP_RADIUS: any;
+export const CLOUD_HISTORY_CUT_COSINE: any;
+export const CLOUD_HISTORY_CUT_DISTANCE: any;
+export const CLOUD_HISTORY_FAR_DEPTH: any;
+export const CLOUD_HISTORY_FRESH_BLEND: any;
+export const CLOUD_HISTORY_STALE_BLEND: any;
+export const CLOUD_HISTORY_WARMUP_FRAMES: any;
+export const CLOUD_HIT_DISTANCE_MAX: any;
+export const CLOUD_HIT_DISTANCE_MISS: any;
+export const CLOUD_HIT_DISTANCE_MISS_THRESHOLD: any;
+export function cloudHistoryJitterOffsets(...args: any[]): any;
+export function cloudHistoryWarmupFrames(...args: any[]): any;
+export function createCloudReprojection(...args: any[]): any;