reze-engine 0.63.0 → 0.65.0

package/dist/engine.d.ts

@@ -8,6 +8,8 @@ import { type AssetReader } from "./asset-reader";
 import { type ParamKey } from "./param-track";
 import { type DissolveCycle, type EffectWindow } from "./effect-schedule";
 import { type ModelParentKey } from "./parent-keys";
+import { type NativeLook } from "./unity/looks";
+import { type NativeStagePackage, type NativeStageReader } from "./unity/stage";
 import { type HdrImage } from "./hdr";
 import { type LyricLine, type LyricRect } from "./shaders/lyrics-api";
 import { type BoneOverlayOptions, type JointOverlayOptions, type OverlayPrimitive, type RigidbodyOverlayOptions } from "./overlay";
@@ -128,6 +130,9 @@ type ParentTrack = {
 type SunOptions = {
     /** Linear color of the sun lamp (Blender: Light > Color). */
     color?: Vec3;
+    /** The rendering layers it keys, as bits; every layer by default. A
+     *  directional light from setLights takes the layers the sun leaves. */
+    layers?: number;
     /** Lamp power in Blender units (Blender: Light > Strength). */
     strength?: number;
     /** Direction sunlight travels (points FROM sun TO scene, Blender: -light.rotation.Z). */
@@ -217,15 +222,21 @@ type CameraOptions = {
     /** Vertical field of view in radians. */
     fov?: number;
 };
-/** EEVEE Bloom panel (3D Viewport > Render > Bloom). Fields map 1:1 to Blender's UI. */
+/** Bloom — Aether Gazer's own (shaders/passes/bloom.ts): a soft-knee prefilter,
+ *  a Gaussian chain down to a few pixels, and a scatter blend back up, added to
+ *  the scene before the view transform. The defaults ARE the game. */
 export type BloomOptions = {
     enabled: boolean;
+    /** Brightest-channel level where the glow starts (the game's per-scene
+     *  threshold). The soft knee is always half of it. */
     threshold: number;
-    knee: number;
-    radius: number;
+    /** 0..1: how far each level leans toward the wider one on the way up — low is
+     *  a tight halo, high a wide haze. The game: 0.77. */
+    scatter: number;
+    /** Tint on the glow; white is the game. */
     color: Vec3;
+    /** Multiplier on the glow added in the composite; 1 is the game. */
     intensity: number;
-    clamp: number;
 };
 export declare const DEFAULT_BLOOM_OPTIONS: BloomOptions;
 /** Camera depth of field — a bokeh gather in the composite pass. Costs nothing
@@ -253,24 +264,27 @@ export type DepthOfFieldOptions = {
     quality: "performance" | "balanced" | "cinematic";
 };
 export declare const DEFAULT_DEPTH_OF_FIELD_OPTIONS: DepthOfFieldOptions;
-/** Blender Color Management / View (rendering.txt: Filmic, exposure, gamma). `look` is reserved for future curve tweaks. */
+/** How the scene-linear frame becomes a display image: exposure, then a tone
+ *  transform, then display gamma. */
 export type ViewTransformOptions = {
-    /** Stops applied before Filmic: `linear *= 2^exposure`. */
+    /** Stops applied before the transform: `linear *= 2^exposure`. */
     exposure: number;
-    /** After Filmic, display gamma (`pow(rgb, 1/gamma)`). */
+    /** After the transform, display gamma (`pow(rgb, 1/gamma)`). */
     gamma: number;
     /**
-     * Which display transform the frame is formed with.
+     * Which display transform the frame is formed with (composite.ts, viewTransform).
      *
-     * "standard" is Blender's Standard: the sRGB encoding and nothing else, which
-     * is what NPR and anime work uses — the colours the graph computes are the
-     * colours that land, with no film curve reinterpreting them. Both of the
-     * reference Wuthering Waves projects render this way.
+     * "soft" — Aether Gazer's own final curve, (1 - e^(-2.5x))^1.4. The default.
+     * "neutral" — Unity URP's Neutral, the Khronos PBR Neutral operator: colour
+     *   passes through until the top fifth, which rolls off.
+     * "aces" — Unity URP's ACES (RRT + ODT approximation from the Core RP).
+     * "none" — the sRGB encoding and nothing else.
      *
-     * "filmic" is Blender 3.6's Filmic, Medium High Contrast, baked as a LUT.
+     * All four end in the sRGB encoding.
      */
-    transform: "agx" | "filmic" | "standard";
+    transform: ViewTransformName;
 };
+export type ViewTransformName = "soft" | "neutral" | "aces" | "none";
 export declare const DEFAULT_VIEW_TRANSFORM: ViewTransformOptions;
 /** Color grading applied to the tonemapped scene (ASC CDL — see grade() in
  *  composite.ts). The three tonal controls are expressed as COLORS with
@@ -363,9 +377,9 @@ export type EngineOptions = {
     /** Canvas background (display-space sRGB 0–1), composited under the scene after
      *  tonemapping. Omit/null = transparent canvas (see setBackgroundColor). */
     background?: Vec3 | null;
-    /** Initial EEVEE-style bloom; tune at runtime with `setBloomOptions`. */
+    /** Initial bloom; tune at runtime with `setBloomOptions`. */
     bloom?: Partial<BloomOptions>;
-    /** View transform (exposure/gamma) applied in composite before/after Filmic. */
+    /** View transform (exposure, tone transform, gamma) applied in the composite. */
     view?: Partial<ViewTransformOptions>;
     onRaycast?: RaycastCallback;
     /** See {@link GizmoDragCallback}. */
@@ -537,16 +551,19 @@ interface ModelInstance {
     indexBuffer: GPUBuffer;
     jointsBuffer: GPUBuffer;
     weightsBuffer: GPUBuffer;
+    /** The outline hull's own stream — smoothed normal + PMX edge scale per
+     *  vertex (outline-normals.ts). Made with the first edge-flagged material,
+     *  so a model with no outline never pays for it. */
+    outlineVertexBuffer?: GPUBuffer;
     skinMatrixBuffer: GPUBuffer;
     drawCalls: DrawCall[];
     shadowDrawCalls: DrawCall[];
     shadowBindGroups: GPUBindGroup[];
     mainPerInstanceBindGroup: GPUBindGroup;
-    /** Its own light — fill, sun and options — when setModelFill, setModelSun or
-     *  setModelFlatSky gave it one: a 48-byte ModelLight, and the CPU copy it is
-     *  written from. */
-    lightBuffer: GPUBuffer | null;
-    modelLight: Float32Array | null;
+    /** Its ObjectLight — rendering layers, its own ambient, its fill — and the CPU copy it
+     *  is written from. Every model has one: its layers decide its lights. */
+    lightBuffer: GPUBuffer;
+    objectLight: Float32Array<ArrayBuffer>;
     pickPerInstanceBindGroup: GPUBindGroup;
     pickDrawCalls: PickDrawCall[];
     /** Environment geometry added via addStage — no physics, no IK, and it
@@ -684,7 +701,27 @@ export type SceneLight = {
     aim?: XYZ;
     angle?: number;
     innerAngle?: number;
+    /**
+     * "directional": light along `aim` from infinitely far, as the sun is —
+     * position and radius unused; up to three, beside the sun. Otherwise a spot
+     * where an aim is given and a point where none is.
+     */
+    kind?: "point" | "spot" | "directional";
+    /**
+     * The rendering layers it reaches, as bits (RENDERING_LAYER_*). Omitted
+     * reaches every layer. A stage's daylight on RENDERING_LAYER_DEFAULT and the
+     * cast's key on RENDERING_LAYER_CHARACTER is how a game lights the two apart.
+     */
+    layers?: number;
 };
+/**
+ * Rendering layers, as the game's pipeline (URP's rendering layers) uses them:
+ * every drawing carries layer bits and a light reaches it only where its mask
+ * shares one. A stage, prop or plane draws on DEFAULT; the cast on DEFAULT and
+ * CHARACTER, the bits Aether Gazer's characters carry (0x40000001).
+ */
+export declare const RENDERING_LAYER_DEFAULT = 1;
+export declare const RENDERING_LAYER_CHARACTER: number;
 export declare class Engine {
     private static instance;
     static getInstance(): Engine;
@@ -700,6 +737,8 @@ export declare class Engine {
     private cameraConfig;
     private lightUniformBuffer;
     private lightData;
+    private lightDataWords;
+    private sunLayers;
     private castShadow;
     private castShadowTexture;
     private castShadowView;
@@ -828,7 +867,6 @@ export declare class Engine {
     private mainPerFrameBindGroupLayout;
     private mainPerInstanceBindGroupLayout;
     /** What a model with no fill of its own binds: zero light. */
-    private noFillBuffer;
     private mainPerMaterialBindGroupLayout;
     private outlinePerFrameBindGroupLayout;
     private outlinePerMaterialBindGroupLayout;
@@ -1191,6 +1229,7 @@ export declare class Engine {
      *  premultiplied quantity and a blur has to move them together. */
     private mirrorMaskMipViews;
     private mirrorMaskBlurBindGroups;
+    private mirrorDownsamplePipeline;
     private mirrorMaskDownsamplePipeline;
     /** Two blocks the ground reads its clip from: the camera's is inert, the
      *  mirror's carries the live plane. Which one a draw sees is decided by which
@@ -1348,12 +1387,24 @@ export declare class Engine {
     /** Scene seconds, advanced by the frame delta — NOT wall time, so an offline
      *  export samples the same path the editor showed. */
     private sceneClock;
+    /** Models dressed in the game's own materials (unity/looks.ts); built on the
+     *  first look installed. */
+    private nativeLooks;
+    /** The scene pass's host for the game's shaders, and the shadow atlas's. */
+    private nativeHost;
+    private nativeShadowHost;
+    /** A game stage drawn by its own shaders (unity/stage.ts). */
+    private nativeStage;
+    /** The frame's Unity globals, computed once for every native draw. */
+    private nativeGlobals;
+    private nativeFallback;
+    /** A 1x1 depth map at the far plane: a game shader's shadow lookup into a
+     *  map the scene does not have reads lit. */
+    private nativeNoShadowView;
     private trailAccum;
     /** Trail samples owed this frame, computed once so every trail on every
      *  character samples in lockstep and their paths stay comparable. */
     private trailDue;
-    private agxLutTexture;
-    private agxFallbackTexture;
     /** The scene's own grade (setStageGrade): the cube as handed over, kept so a
      *  call before init() still lands, and its texture once uploaded. */
     private stageGradeCube;
@@ -1378,29 +1429,44 @@ export declare class Engine {
     private readonly pipelineDescs;
     private readonly singleSided;
     private readonly singleSidedMirror;
+    /** Twins whose async build is in flight, so a draw asks for each once. */
+    private readonly sidedPending;
+    private readonly sidedPendingMirror;
+    private readonly shaderModuleCache;
+    private readonly pipelineCache;
+    private readonly bindGroupLayoutCache;
+    private readonly pipelineLayoutCache;
+    private readonly gpuObjectIds;
+    private gpuObjectNext;
+    /** Init's pipelines, built async and in parallel; init awaits them. Null
+     *  outside init, where a pipeline job builds the way it always did. */
+    private initPipelineJobs;
     private readonly steppedHeld;
     private readonly steppedTick;
     private steppedLastClock;
-    private bloomBlitUniformBuffer;
-    private bloomUpsampleUniformBuffer;
-    private readonly bloomBlitUniformData;
-    private readonly bloomUpsampleUniformData;
-    private bloomBlitPipeline;
-    private bloomDownsamplePipeline;
+    private bloomPrefilterBindGroupLayout;
+    private bloomBlurBindGroupLayout;
+    /** Single-attachment pass; colorAttachments[0].view set per bloom step. */
+    private bloomPassDescriptor;
+    private bloomPrefilterPipeline;
+    private bloomBlurHPipeline;
+    private bloomBlurVPipeline;
     private bloomUpsamplePipeline;
-    private bloomBlitBindGroupLayout;
-    private bloomDownsampleBindGroupLayout;
     private bloomUpsampleBindGroupLayout;
+    private bloomUniformBuffer;
+    private readonly bloomUniformData;
     private bloomDownTexture;
     private bloomUpTexture;
-    private bloomMipCount;
-    private bloomDownMipViews;
-    private bloomUpMipViews;
-    private bloomBlitBindGroup;
-    private bloomDownsampleBindGroups;
+    private bloomLevels;
+    private bloomDownViews;
+    private bloomUpViews;
+    private bloomPrefilterBindGroup;
+    private bloomBlurHBindGroups;
+    private bloomBlurVBindGroups;
     private bloomUpsampleBindGroups;
-    /** Single-attachment pass; colorAttachments[0].view set per bloom step. */
-    private bloomPassDescriptor;
+    /** The game's prefilter clamps at 6550.4 — a tenth of the half-float ceiling
+     *  (its BloomPass _Params.y of 100 never reaches the shader). */
+    private static readonly BLOOM_CLAMP;
     private static readonly BLOOM_MAX_LEVELS;
     private groundVertexBuffer?;
     private groundIndexBuffer?;
@@ -1408,13 +1474,11 @@ export declare class Engine {
     /** The user's own "no ground" switch — see setGroundVisible. Distinct from
      *  hasGround, which records whether a ground was ever built. */
     private groundHidden;
-    private shadowMapTextures;
-    private shadowMapDepthViews;
+    /** The sun's shadow atlas: every cascade in its own tile (shadow-cascades.ts). */
+    private shadowAtlasTexture;
+    private shadowAtlasView;
     private brdfLutTexture;
     private brdfLutView;
-    private filmicLutTexture;
-    private filmicLutView;
-    private static readonly FILMIC_LUT_WIDTH;
     private shadowDepthPipeline;
     private shadowLightVPBuffer;
     private shadowCascadeVPBuffers;
@@ -1478,10 +1542,10 @@ export declare class Engine {
     private bloomSettings;
     private viewTransform;
     constructor(canvas: HTMLCanvasElement, options?: EngineOptions);
-    /** Merge partial bloom with EEVEE defaults (same as constructor). */
+    /** Merge partial bloom with the defaults (same as constructor). */
     static mergeBloomDefaults(partial?: Partial<BloomOptions>): BloomOptions;
     static mergeViewTransformDefaults(partial?: Partial<ViewTransformOptions>): ViewTransformOptions;
-    /** Current bloom settings (Blender names; tint is a copied `Vec3`). */
+    /** Current bloom settings (tint is a copied `Vec3`). */
     getBloomOptions(): BloomOptions;
     getViewTransformOptions(): ViewTransformOptions;
     private colorGrading;
@@ -1547,6 +1611,8 @@ export declare class Engine {
      * it was written, expensive where it was reported.
      */
     private bloomContributes;
+    /** viewU[6].y per transform — see viewTransform in composite.ts. */
+    private static readonly VIEW_TRANSFORM_ID;
     private writeCompositeViewUniforms;
     /**
      * Set the canvas background color (display-space sRGB, 0–1 per channel — the
@@ -1724,7 +1790,7 @@ export declare class Engine {
      */
     private renderMirrorPass;
     /**
-     * Fill the mirror's mip levels — the bloom pyramid's own 13-tap downsample,
+     * Fill the mirror's mip levels — a 13-tap downsample (MIRROR_DOWNSAMPLE_WGSL),
      * one pass per level. Only when the blur dial is up: at zero the ground
      * samples level 0 exactly and the chain would be work nobody reads.
      */
@@ -1932,7 +1998,13 @@ export declare class Engine {
      * lighting. Cleared, the world's own sky comes back.
      */
     setBackdropEquirect(source: ImageBitmap | HTMLImageElement | HTMLCanvasElement | null): void;
-    private makeCompositePipeline;
+    /**
+     * The scene composite's pair (gamma = 1, gamma ≠ 1), async and from the
+     * shader cache. Its source depends only on which field mounts the scene
+     * samples, so there are four at most, and an effect install that keeps the
+     * mounts it had gets the pair already built.
+     */
+    private compositePipelines;
     /**
      * Install the scene's WGSL effect (shadertoy-style), rendered per-pixel in the
      * composite pass. ONE effect per scene, and the code says where it mounts by
@@ -2242,7 +2314,13 @@ export declare class Engine {
     private getModelBodyFocus;
     private writeDepthOfFieldUniforms;
     setBloomOptions(patch: Partial<BloomOptions>): void;
+    private ensureBloomPipelines;
+    /** The game's chain at the current canvas size (AGSimPostFX.Bloom): half
+     *  size, then floor(log2(longest side)) - 1 levels, each half the last. */
+    private buildBloomTargets;
     private writeBloomUniforms;
+    /** The game's chain, pass for pass (AGSimPostFX.Bloom). */
+    private renderBloom;
     init(): Promise<void>;
     /** The frost tile the ground samples instead of evaluating fbm per pixel. */
     private groundNoiseTexture;
@@ -2258,17 +2336,8 @@ export declare class Engine {
      */
     private bakeGroundNoise;
     private bakeBrdfLut;
-    /**
-     * Decompress and upload Blender's AgX cube.
-     *
-     * Deliberately off the critical path: it is 723 KB once inflated, and a frame
-     * rendered before it lands should show the scene under whatever transform is
-     * already there rather than wait. Until then binding 10 holds a 1×1×1 stand-in,
-     * which is only ever sampled if someone selects AgX in that window.
-     */
-    private loadAgxLut;
-    private bakeFilmicLut;
     private createRenderPipeline;
+    private renderPipelineDesc;
     private createPipelines;
     private setupResize;
     /** When set, render resolution is pinned to this size instead of tracking the
@@ -2810,10 +2879,6 @@ export declare class Engine {
      * back restores the scene the user had rather than an engine default.
      */
     setGroundVisible(on: boolean): void;
-    /** Per cascade: does its map currently hold nothing but the cleared far plane?
-     *  Set by the cascade loop, which skips a cascade that is unwanted and already
-     *  cleared rather than re-clearing it every frame. */
-    private shadowCascadeCleared;
     /**
      * Moves a model to a new key. Nothing about it is rebuilt — same GPU
      * buffers, same style groups, same physics — only which string the rest
@@ -2826,11 +2891,21 @@ export declare class Engine {
      * the name everything else in the app still expects.
      */
     renameModel(oldName: string, newName: string): void;
+    /**
+     * One model's own ambient: the irradiance arriving at it, as the 27 floats of
+     * folded SH setWorldAmbient takes (ibl.ts), in place of the world's. Null
+     * gives it the world's again.
+     *
+     * The game's pipeline lights every renderer by its own probe sample, and a
+     * character by an ambient of its own; a loader that carries those hands them
+     * in here. Linear radiance, strength included.
+     */
+    setModelAmbient(name: string, sh: ArrayLike<number> | null): boolean;
     /**
      * Light one model with more than the world gives it: a FILL, linear RGB times
      * its surface colour, added after its material graph. Null takes it away again.
      *
-     * After the graph, not in its ambient: an NPR ramp read an ambient fill as
+     * After the graph, not in its ambient: an NPR ramp reads an ambient fill as
      * light, so sliding it moved her shadows and flipped whole regions across a
      * hard step. Added after, it brightens her evenly and every shadow stays put.
      *
@@ -2838,39 +2913,15 @@ export declare class Engine {
      * lit by their lamps and a near-black ambient, while its characters take a
      * flat base light of their own — so a stage whose World is right for the room
      * leaves a face turned from the lamps in the dark. This is that second light,
-     * for the models the host counts as cast.
-     */
-    setModelFill(name: string, fill: Vec3 | null): boolean;
-    /**
-     * A model's own sun: the colour and strength the scene's sun has FOR THIS
-     * MODEL, in place of the scene's. Null gives it the scene's sun back.
-     *
-     * The other half of lighting a stage and its cast apart. A game's stage is
-     * lit by its own daylight — Aether Gazer's kitchen at twenty times white —
-     * while its characters take a key light of their own that the stage never
-     * states. So a stage carries the sun it was lit by, and the scene's sun
-     * stays the cast's. Direction and shadow are still the scene's: one sun
-     * casts, and it casts the same way on both.
-     */
-    setModelSun(name: string, sun: Vec3 | null): boolean;
-    /**
-     * Light one model by the sky's AVERAGE rather than its shape: the world's
-     * colour and brightness from every direction alike. False gives it the
-     * directional sky back.
-     *
-     * For a cast under an anime look. An HDRI's sky is brighter and warmer one
-     * way than another, and taken at each normal it shades a face with soft
-     * realistic gradients that no toon ramp drew — PBR on an anime face. Aether
-     * Gazer gives its characters one flat base light instead. World strength and
-     * colour still reach her; only the shape is gone. A flat World is its own
-     * average, so without an HDRI this changes nothing.
-     */
-    setModelFlatSky(name: string, flat: boolean): boolean;
-    /** One part of a model's light, at `at` (0 the fill, 4 the sun, 8 its
-     *  options) in its ModelLight; w says whether that part is set. All unset
-     *  releases the buffer and the model takes the shared zero stand-in again. */
-    private writeModelLight;
-    /** The per-model group: its skinning matrices and its light, or the zero stand-in. */
+     * for the models the host counts as cast. A model drawn by the game's own
+     * shaders (src/unity) lights itself and takes none of it.
+     */
+    setModelFill(name: string, fill: {
+        x: number;
+        y: number;
+        z: number;
+    } | null): boolean;
+    /** The per-model group: its skinning matrices and its ObjectLight. */
     private perInstanceBindGroup;
     removeModel(name: string): void;
     getModelNames(): string[];
@@ -3619,6 +3670,7 @@ export declare class Engine {
      *  compiles, so the two are built from one description and cannot drift. */
     private groundShadowPipelineDesc;
     private buildGroundPipeline;
+    private groundPipelineConfig;
     private groundMirrorPipeline;
     private groundMirrorSoftPipeline;
     /** The ground's pipeline for the mirror pass, built on the first frame a
@@ -3794,6 +3846,14 @@ export declare class Engine {
      * compile fails is not installed and its materials stay ungrouped (fallback-on-error).
      */
     applyStyleGroups(modelName: string, groups: StyleGroup[]): Promise<ApplyStyleGroupsResult>;
+    /**
+     * Compile style groups' pipelines before any model needs them — a scene's
+     * groups while its bundle is still downloading. Installs nothing: the
+     * pipelines land in the shader cache, and applyStyleGroups later finds them
+     * there (or still in flight). A group that does not compile is skipped
+     * silently; its real install reports it.
+     */
+    prewarmStyleGroups(groups: readonly StyleGroup[]): Promise<void>;
     /** Add or replace a single style group by id. `opts` may carry a `previewNode` for the
      *  editor's node-output preview workflow. */
     upsertStyleGroup(modelName: string, group: StyleGroup, opts?: CompileOptions): Promise<ApplyStyleGroupResult>;
@@ -3894,6 +3954,11 @@ export declare class Engine {
     /** What setModelDissolve last set, or 1 for a model that has never dissolved. */
     getModelDissolve(modelName: string): number;
     private currentClaims;
+    /** A graph's own images (ShaderGraph.images), fetched and decoded once per URL. */
+    private graphImageCache;
+    private graphImage;
+    /** The group with its graph's images, where the group brings none of its own. */
+    private withGraphImages;
     private compileAndInstallGroup;
     private assignDrawCallGroups;
     private writeGroupDefaults;
@@ -3908,6 +3973,39 @@ export declare class Engine {
     /** A pipeline whose descriptor is kept, so a single-sided twin can be built
      *  from it on demand (see sidedPipeline). */
     private createModelPipeline;
+    private static readonly SHADER_CACHE_MAX;
+    private static readonly PIPELINE_CACHE_MAX;
+    private static trimCache;
+    /** A small stable id per GPU object, for cache keys. */
+    private gpuObjectId;
+    /** One module per WGSL source. */
+    private cachedShaderModule;
+    /** Drop a source whose module did not validate, so a retry reports afresh. */
+    private forgetShaderModule;
+    /** One bind group layout per entry list. */
+    private cachedBindGroupLayout;
+    /** One pipeline layout per bind group layout list. */
+    private cachedPipelineLayout;
+    private pipelineKey;
+    private cachedPipeline;
+    /** createRenderPipelineAsync, once per module + state. */
+    private cachedRenderPipeline;
+    /** createComputePipelineAsync, once per module + state. */
+    private cachedComputePipeline;
+    /**
+     * A pipeline init builds: async, in parallel with the rest, and in place by
+     * the time init returns (it awaits every job). Outside init — a pass built
+     * on first use — it is the synchronous build it always was.
+     */
+    private initRenderPipeline;
+    /** The compute twin of initRenderPipeline. */
+    private initComputePipeline;
+    /**
+     * Build a model pipeline's single-sided twin off the draw path (see
+     * sidedPipeline). Resolves once it is in place; never rejects — a twin that
+     * fails leaves the draw on its double-sided pipeline, as before it existed.
+     */
+    private buildSidedTwin;
     /**
      * The pipeline a draw should use once its double-sided flag is honoured.
      *
@@ -4097,6 +4195,38 @@ export declare class Engine {
      */
     private clearTrailHistory;
     private writeTrail;
+    /**
+     * Dress a model in the game's own materials — a look exported with ag-rip
+     * (translated shaders, their images, per-material passes and values, and a
+     * character rig) — or take it off with null. The materials it names are
+     * drawn by the game's shaders from then on; the rest keep their graphs, and
+     * every one still casts its shadow through the engine's pass.
+     */
+    setModelNativeLook(name: string, look: NativeLook | null): boolean;
+    /** Resolves once a model's native look can draw: every pass's pipeline is
+     *  compiled (async, at setModelNativeLook). Until then its dressed materials
+     *  sit out — a host reveals the model after this to avoid that gap. */
+    nativeLookReady(name: string): Promise<void>;
+    /** The hosts for the game's shaders: the scene pass's and the shadow atlas's,
+     *  with the stand-ins an empty slot reads. Built on first use. */
+    private ensureNativeHosts;
+    /**
+     * Load a game stage as the game draws it - a package ag-rip's
+     * stage_native.py exported (stage.json and the files beside it, read through
+     * `read` by their paths in it) - or remove the one loaded with null. Its
+     * scene settings (fog, tint, ambient, environment) become the game shaders'
+     * for the whole scene; its lights are the caller's to set, as lights.
+     */
+    setNativeStage(pkg: NativeStagePackage | null, read?: NativeStageReader, onProgress?: (done: number, total: number) => void): Promise<void>;
+    /** What went wrong in the game's shaders, and the names nothing supplied. */
+    nativeReport(): {
+        errors: string[];
+        missing: Record<string, number>;
+    };
+    private nativeFrameTextures;
+    private eyeArray;
+    /** Before the scene pass: the dressed models' skinning and the game's globals. */
+    private prepareNativeLooks;
     private updateSkinMatrices;
     private updateStats;
 }