hilo3d 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/Hilo3d.d.ts

@@ -2622,229 +2622,189 @@ declare class Ray {
     private pointAt;
 }
 
-declare const STATE_TYPES: Readonly<{
-    TRANSLATE: "Translation";
-    POSITION: "Translation";
-    TRANSLATION: "Translation";
-    SCALE: "Scale";
-    ROTATE: "Rotation";
-    ROTATION: "Rotation";
-    QUATERNION: "Quaternion";
-    WEIGHTS: "Weights";
-}>;
-type BuiltInAnimationStateType = (typeof STATE_TYPES)[keyof typeof STATE_TYPES];
-type AnimationStateType = BuiltInAnimationStateType | (string & {});
-type AnimationStateHandler = (node: Node, state: unknown) => void;
-type AnimationInterpolationType = 'LINEAR' | 'STEP' | 'CUBICSPLINE';
-interface AnimationStatesParameters {
-    nodeName?: string;
-    type?: AnimationStateType;
-    interpolationType?: AnimationInterpolationType;
-    keyTime?: number[];
-    states?: unknown[];
-}
-type InterpolatedValue = number | number[] | Vector3 | Quaternion;
-type InterpolationFunction = (first: unknown, second?: unknown, ratio?: number, timeRange?: number) => InterpolatedValue;
-/** A typed animation channel targeting one property of a scene node. */
-declare class AnimationStates {
-    static readonly interpolation: Record<AnimationInterpolationType, InterpolationFunction>;
-    static readonly StateType: Readonly<{
-        TRANSLATE: "Translation";
-        POSITION: "Translation";
-        TRANSLATION: "Translation";
-        SCALE: "Scale";
-        ROTATE: "Rotation";
-        ROTATION: "Rotation";
-        QUATERNION: "Quaternion";
-        WEIGHTS: "Weights";
-    }>;
-    private static readonly extraTypes;
-    private static readonly extraHandlers;
-    static getType(name: string): AnimationStateType;
-    static registerStateHandler(name: string, handler: AnimationStateHandler): void;
-    readonly id: string;
-    readonly isAnimationStates = true;
-    readonly className = "AnimationStates";
-    nodeName: string;
-    type: AnimationStateType;
-    interpolationType: AnimationInterpolationType;
-    keyTime: number[];
-    states: unknown[];
-    private originalWeightIndices;
-    constructor(params?: AnimationStatesParameters);
-    findIndexByTime(time: number): [number, number];
-    getStateByIndex(index: number): unknown;
-    private convertRotationState;
-    getState(time: number): unknown;
-    interpolation(first: unknown, second?: unknown, ratio?: number, timeRange?: number): InterpolatedValue;
-    updateNodeTranslation(node: Node, value: unknown): void;
-    updateNodeScale(node: Node, value: unknown): void;
-    updateNodeQuaternion(node: Node, value: unknown): void;
-    updateNodeWeights(node: Node, value: unknown): void;
-    updateNodeState(time: number, node?: Node): void;
-    clone(): AnimationStates;
-}
-
-interface AnimationClip {
-    start: number;
-    end: number;
-    animStatesList?: AnimationStates[];
+/** Properties supported by the numeric pose mixer. Custom channels use an explicit binding. */
+type AnimationProperty = 'translation' | 'rotation' | 'scale' | 'weights' | `custom:${string}`;
+/** glTF interpolation modes. Cubic data is laid out as in-tangent/value/out-tangent per key. */
+type AnimationInterpolation = 'LINEAR' | 'STEP' | 'CUBICSPLINE';
+/** Flat, numeric animation channel authoring data. Times are in seconds. */
+interface AnimationTrackParameters {
+    target: string;
+    property: AnimationProperty;
+    times: ArrayLike<number>;
+    values: ArrayLike<number>;
+    components?: number;
+    interpolation?: AnimationInterpolation;
+}
+/** Validated immutable channel data, shared by every character playing the clip. */
+declare class AnimationTrack {
+    readonly target: string;
+    readonly property: AnimationProperty;
+    readonly components: number;
+    readonly interpolation: AnimationInterpolation;
+    readonly startTime: number;
+    readonly endTime: number;
+    private readonly times;
+    private readonly values;
+    constructor(params: AnimationTrackParameters);
+    /** Samples into caller-owned storage without mutating keys or allocating scratch arrays. */
+    sample(time: number, output: Float32Array): void;
+}
+
+/** A semantic marker for footsteps, effects, sounds or interaction timing. Time is in clip-source seconds. */
+interface AnimationMarker {
+    name: string;
+    time: number;
 }
-interface AnimationParameters {
-    paused?: boolean;
-    currentLoopCount?: number;
-    loop?: number;
-    currentTime?: number;
-    timeScale?: number;
-    startTime?: number;
-    endTime?: number;
-    rootNode?: Node | null;
-    animStatesList?: AnimationStates[];
-    validAnimationIds?: Readonly<Record<string, boolean>> | null;
-    clips?: Record<string, AnimationClip | null>;
+/** Immutable clip descriptor. Optional start/end select a window of the shared tracks. */
+interface AnimationClipParameters {
+    name: string;
+    tracks: readonly AnimationTrack[];
+    start?: number;
+    end?: number;
+    markers?: readonly AnimationMarker[];
 }
-interface AnimationTimeRange {
-    startTime: number;
-    endTime: number;
+/** Shareable animation asset; playback clocks and pose bindings live on the Animation instance. */
+declare class AnimationClip {
+    readonly name: string;
+    readonly tracks: readonly AnimationTrack[];
+    readonly start: number;
+    readonly end: number;
+    readonly duration: number;
+    readonly markers: readonly AnimationMarker[];
+    constructor(params: AnimationClipParameters);
 }
-/**
- * 动画类
- */
-declare class Animation extends EventDispatcher {
-    static readonly _anims: Animation[];
-    /**
-     * tick
-     * @param dt - 一帧时间
-     */
-    static tick(dt: number): void;
-    isAnimation: boolean;
-    className: string;
-    /**
-     * 动画是否暂停
-     */
+
+/** Custom numeric channel adapter. Capture the reference value once; write receives reusable storage. */
+interface AnimationPropertyBinding {
+    reference: ArrayLike<number>;
+    write: (value: Float32Array) => void;
+}
+/** Resolve application channels while binding a character, never during pose evaluation. */
+type AnimationBindingResolver = (node: Node, property: AnimationProperty, components: number) => AnimationPropertyBinding;
+
+/** A threshold on a scalar parameter, such as character speed in metres per second. */
+interface AnimationBlendSample {
+    threshold: number;
+    clip: AnimationClip;
+}
+/** Immutable 1D motion asset. Adjacent clips share normalized gait phase, including unequal durations. */
+declare class AnimationBlendTree1D {
+    readonly name: string;
+    readonly parameter: string;
+    readonly samples: readonly AnimationBlendSample[];
+    constructor(name: string, parameter: string, samples: readonly AnimationBlendSample[]);
+}
+/** A state can play one clip or a continuously parameterized locomotion blend. */
+type AnimationMotion = AnimationClip | AnimationBlendTree1D;
+
+/** Semantic events are emitted only by the transition destination, after pose writeback. */
+interface AnimationEvent {
+    type: 'marker' | 'finished';
+    layer: string;
+    motion: string;
+    name: string;
+    /** Number of crossings coalesced into this event when a large delta spans multiple cycles. */
+    count: number;
+}
+/** Layer configuration. Masks are exact track target identifiers; unspecified targets have zero weight. */
+interface AnimationLayerParameters {
+    name: string;
+    motions: readonly AnimationMotion[];
+    weight?: number;
+    mode?: 'override' | 'additive';
+    mask?: Readonly<Record<string, number>>;
+    onEvent?: (event: AnimationEvent) => void;
+}
+/** Transition duration is in seconds. Synchronize transfers the current normalized phase. */
+interface AnimationPlayOptions {
+    fade?: number;
+    synchronize?: boolean;
+    loop?: boolean;
+}
+/** Per-character layer handle, created by Animation.addLayer(). */
+interface AnimationLayer {
+    /** Layer identifier. */
+    readonly name: string;
+    /** Composition rule. */
+    readonly mode: 'override' | 'additive';
+    /** Overall influence in [0, 1]. */
+    weight: number;
+    /** Nonnegative clock multiplier for this layer's motions. */
+    playbackRate: number;
+    /** Current transition destination. */
+    readonly currentMotion: string | undefined;
+    /** Unwrapped normalized destination clock. */
+    readonly normalizedTime: number;
+    /** Whether a one-shot is holding its terminal pose. */
+    readonly finished: boolean;
+    /** Select a motion, optionally fading from all current contributions. */
+    play(name: string, options?: AnimationPlayOptions): this;
+    /** Remove layer motion contributions over the given seconds. */
+    stop(fade?: number): void;
+    /** Seek without dispatching crossed events. */
+    seek(phase: number): void;
+}
+
+/** Character animation configuration. All clocks use seconds except the Ticker-compatible tick(). */
+interface AnimationParameters {
+    rootNode?: Node;
+    clips?: readonly AnimationClip[];
+    resolveBinding?: AnimationBindingResolver;
+}
+/** Character-local pose mixer. Assets are shared; bindings, clocks, layers and scratch storage are isolated. */
+declare class Animation {
+    private static readonly active;
+    private static serial;
+    private lastTick;
+    /** Advances automatically playing characters from a Ticker (milliseconds). */
+    static tick(milliseconds: number): void;
+    readonly isAnimation = true;
+    readonly className = "Animation";
+    private root;
+    private readonly clipAssets;
+    private readonly resolver;
+    private readonly bindings;
+    private readonly boundClips;
+    private readonly layerList;
+    private readonly layerDescriptors;
+    private readonly parameters;
+    private base;
+    private rate;
+    private destroyed;
     paused: boolean;
-    /**
-     * 动画当前播放次数
-     */
-    currentLoopCount: number;
-    /**
-     * 动画需要播放的次数，默认值为 Infinity 表示永远循环
-     */
-    loop: number;
-    /**
-     * 动画当前时间
-     */
-    currentTime: number;
-    /**
-     * 动画播放速度
-     */
-    timeScale: number;
-    /**
-     * 动画开始时间
-     */
-    startTime: number;
-    /**
-     * 动画结束时间，初始化后会根据 AnimationStates 来自动获取，也可以通过 play 来改变
-     */
-    endTime: number;
-    /**
-     * 动画整体的最小时间，初始化后会根据 AnimationStates 来自动获取
-     */
-    clipStartTime: number;
-    /**
-     * 动画整体的最大时间，初始化后会根据 AnimationStates 来自动获取
-     */
-    clipEndTime: number;
-    readonly id: string;
-    clips: Record<string, AnimationClip | null>;
-    nodeNameMap: Record<string, Node>;
-    private _rootNode;
-    /**
-     * 动画根节点，不指定根节点将无法正常播放动画
-     */
-    get rootNode(): Node | null;
-    /**
-     * 动画根节点，不指定根节点将无法正常播放动画
-     */
-    set rootNode(value: Node | null);
-    private _animStatesList;
-    /**
-     * 动画状态列表
-     */
-    get animStatesList(): AnimationStates[];
-    /**
-     * 动画状态列表
-     */
-    set animStatesList(value: AnimationStates[]);
-    /**
-     * AnimationId集合
-     */
-    validAnimationIds: Readonly<Record<string, boolean>> | null;
-    /**
-     * @param params - 创建对象的属性参数。可包含此类的所有属性。
-     */
     constructor(params?: AnimationParameters);
-    /**
-     * 添加动画剪辑
-     * @param name - 剪辑名字
-     * @param start - 动画开始时间
-     * @param end - 动画结束时间
-     * @param animStatesList - 动画帧列表
-     */
-    addClip(name: string, start: number, end: number, animStatesList: AnimationStates[]): void;
-    /**
-     * 移除动画剪辑
-     * @param name - 需要移除的剪辑名字
-     */
-    removeClip(name: string): void;
-    /**
-     * 获取动画列表的时间信息
-     * @param animStatesList - 动画列表
-     * @returns result `{ startTime, endTime }` 时间信息
-     */
-    getAnimStatesListTimeInfo(animStatesList: AnimationStates[]): AnimationTimeRange;
-    /**
-     * 初始化 clip time
-     */
-    private _initClipTime;
-    /**
-     * 初始化 node name map
-     */
-    _initNodeNameMap(): void;
-    /**
-     * tick
-     * @param dt -
-     */
-    tick(dt: number): void;
-    /**
-     * 更新动画状态
-     * @returns this
-     */
-    updateAnimStates(): this;
-    /**
-     * 播放动画(剪辑)
-     * @param startOrClipName - 动画开始时间，或者动画剪辑名字
-     * @param end - 动画结束时间，如果是剪辑的话不需要传
-     */
-    play(startOrClipName?: number | string, end?: number): void;
-    /**
-     * 停止动画，这个会将动画从Ticker中移除，需要重新调用play才能再次播放
-     */
-    stop(): void;
-    /**
-     * 暂停动画，这个不会将动画从Ticker中移除
-     */
+    /** Shared clip assets. To author additional motions use addLayer(). */
+    get clips(): readonly AnimationClip[];
+    /** Binding root. Rebinding a live mixer requires creating a new Animation or clone(). */
+    get rootNode(): Node | undefined;
+    set rootNode(value: Node | undefined);
+    /** Playback rate, including transitions; zero freezes time while allowing explicit pose evaluation. */
+    get timeScale(): number;
+    set timeScale(value: number);
+    /** Set a blend parameter immediately, or exponentially damp it using a half-life and elapsed seconds. */
+    setParameter(name: string, value: number, halfLife?: number, seconds?: number): void;
+    /** Current scalar parameter value, defaulting to zero. */
+    getParameter(name: string): number;
+    /** Append a layer in composition order. Resolve nodes and capture reference properties once. */
+    addLayer(params: AnimationLayerParameters): AnimationLayer;
+    private createLayer;
+    /** Play or crossfade a loaded clip on the default base layer and enroll in Animation.tick(). */
+    play(name?: string, options?: AnimationPlayOptions): AnimationLayer;
+    /** Advance from a millisecond Ticker. Manually controlled characters can call update(seconds). */
+    tick(milliseconds: number): void;
+    /** Evaluate one pose and write each bound property once. Call before physics/render transform collection. */
+    update(seconds: number): void;
+    /** Suspend automatic ticking, retaining the displayed pose and playback state. */
     pause(): void;
-    /**
-     * 恢复动画播放，只能针对 pause 暂停后恢复
-     */
+    /** Enroll in automatic ticking. Do not also update manually in the same frame. */
     resume(): void;
-    /**
-     * clone动画
-     * @param rootNode - 目标动画根节点
-     * @returns clone的动画对象
-     */
+    /** Stop all motions and automatic ticking, optionally restoring captured reference properties. */
+    stop(restore?: boolean): void;
+    /** Release node references and remove this instance from automatic ticking. Shared assets remain valid. */
+    destroy(): void;
+    /** Clone configuration with fresh clocks and bindings. Reference poses are copied from the source mixer. */
     clone(rootNode: Node): Animation;
+    private assertAlive;
 }
 
 /**
@@ -5811,6 +5771,12 @@ interface RendererContract {
     /** Record resource-ready renderer passes in one synchronous backend frame boundary. */
     renderFrame(callback: RendererFrameCallback): void;
     supportsTextureCompression(format: TextureCompressionFormat): boolean;
+    /**
+     * Upload or refresh managed textures through one Render Graph submission without drawing.
+     * Resolves after submission completion. Call outside an active render frame; failed frames
+     * leave backend revisions uncommitted. Source content must remain stable until this resolves.
+     */
+    uploadTextures(textures: readonly Texture<unknown>[]): Promise<void>;
     /** Create a WebGPU renderer-owned storage buffer. WebGL 2 rejects this operation. */
     createStorageBuffer(descriptor: Readonly<StorageBufferDescriptor>): StorageBuffer;
     createRenderTarget(parameters: RenderTargetParameters): RenderTarget;
@@ -5823,6 +5789,7 @@ interface RendererContract {
     waitForIdle(): Promise<void>;
     /** Explicit opt-in access to a backend extension; unknown names return null. */
     getExtension(name: string): object | null;
+    /** Release renderer caches and emit rhiResourcesReleased after fresh caches are available. */
     releaseGPUResources(): void;
     destroy(): void;
     on(type: string, listener: EventListener, once?: boolean): this;
@@ -5872,9 +5839,13 @@ type RendererListQueue = 'opaque' | 'transparent' | 'all';
 /**
  * Stable renderer-list sorting policy.
  *
- * `material-front-to-back` is valid for opaque/all queues and preserves camera ordering for the
- * transparent subqueue of `all`. `back-to-front` is valid for transparent queues. `none` retains
- * collection order within each draw class while explicit instancing may still group meshes.
+ * `material-front-to-back` groups opaque meshes by renderOrder, material, and geometry, then sorts
+ * their world origins by increasing camera-view distance within each group, with stable identity
+ * ties. Explicit instance batches keep their membership, sort their members front-to-back, and use
+ * the nearest member to order the batch among matching direct draws and batches. This policy is
+ * valid for opaque/all queues and preserves camera ordering for the transparent subqueue of `all`.
+ * `back-to-front` is valid for transparent queues. `none` retains collection order within each draw
+ * class while explicit instancing may still group meshes.
  */
 type RendererListSorting = 'material-front-to-back' | 'back-to-front' | 'none';
 /** Immutable selection used to prepare one or more scene draw ranges. */
@@ -5897,6 +5868,25 @@ interface RendererListDescriptor {
      */
     readonly excludeMeshes?: readonly Mesh[];
 }
+/** Explicit mesh selection whose draw order is preserved across all material queues. */
+interface OrderedRendererListDescriptor {
+    /** Current-frame results supplying the camera and lights, without restricting membership. */
+    readonly cullingResults: CullingResultsHandle;
+    /**
+     * Meshes to draw in the supplied order. Membership is snapshotted when the list is created;
+     * duplicate, destroyed, or incomplete meshes are rejected. Visibility, camera layers, frustum
+     * rejection, display sorting and planner-owned `useInstanced` batching are bypassed.
+     *
+     * World matrices follow the normal scene update contract. For meshes outside the invocation
+     * scene, update their root's world matrices before recording the list. Explicit per-mesh
+     * `instanceCount` and per-instance geometry streams remain supported.
+     */
+    readonly meshes: readonly Mesh[];
+    /** Optional material used for every selected mesh. */
+    readonly overrideMaterial?: MaterialInstance;
+    /** Semantic material pass compiled for every selected draw. Defaults to `forward`. */
+    readonly materialPass?: MaterialPassRole;
+}
 
 /** Physical dimension of a scriptable render-pipeline texture. */
 type RenderPipelineTextureDimension = '1d' | '2d' | '3d';
@@ -6191,7 +6181,11 @@ interface ScriptableRenderGraph {
     importRenderTarget(target: RenderTarget): RenderPipelineTargetResources;
     /** Acquire a renderer-local persistent target keyed by runtime-owned object identity. */
     acquirePersistentTarget(key: object, descriptor: Readonly<RenderPipelinePersistentTargetDescriptor>): RenderPipelineTargetResources;
-    /** Acquire one renderer-owned history ring; it rotates only after a successful write frame. */
+    /**
+     * Acquire one renderer-owned history ring. Only a submitted, live write retaining complete
+     * contents rotates the ring; a final discard invalidates the current slot and keeps the last
+     * stored history.
+     */
     acquireHistoryTexture(key: object, descriptor: Readonly<RenderPipelineHistoryTextureDescriptor>): RenderPipelineHistoryTextureResources;
     /** Invalidate submitted history before acquiring it in the active frame. */
     invalidateHistoryTexture(key: object): boolean;
@@ -6445,8 +6439,21 @@ interface RenderPipelineRequirements {
     /** Required texture-format roles. */
     readonly requiredTextureFormats?: readonly Readonly<RenderPipelineTextureRequirement>[];
 }
+/** Static camera and invocation constraints enforced before a pipeline records graph work. */
+interface RenderPipelineInvocationPolicy {
+    /** Accepted camera class; `any` includes perspective, orthographic, and custom cameras. */
+    readonly cameraType: 'any' | 'perspective';
+    /**
+     * Maximum calls to record() in one application frame, or `null` for no host-imposed limit.
+     * A renderFrame() callback shares this budget across surface and render-target invocations.
+     * This does not imply simultaneous GPU multiview rendering or independent temporal histories.
+     */
+    readonly maxInvocationsPerFrame: number | null;
+}
 /** Immutable creation inputs for one renderer-local pipeline runtime. */
 interface RenderPipelineCreateContext {
+    /** Create a renderer-owned target for a runtime; the runtime must destroy it on teardown. */
+    createRenderTarget(parameters: Readonly<RenderTargetParameters>): RenderTarget;
     /** Capabilities for the selected device generation. */
     readonly capabilities: RenderPipelineCapabilities;
     /**
@@ -6603,6 +6610,14 @@ interface RenderPipelineShadowOptions {
 }
 /** Frame-scoped recording context; retaining it after record() returns is an error. */
 interface RenderPipelineContext {
+    /**
+     * Record an auxiliary camera into a renderer-owned target in the same graph/submission.
+     * Call before this context's first cull or shadow recording. The callback is synchronous,
+     * receives its own camera/light/graph-handle scope, and cannot nest recordView(). The parent
+     * context is suspended during the callback. Failure aborts the complete application frame.
+     * This does not invoke the configured main-view pipeline or advance its temporal history.
+     */
+    recordView(camera: Camera, target: RenderTarget, record: (context: RenderPipelineContext) => unknown): void;
     /** Monotonic application frame index. */
     readonly frameIndex: number;
     /** Scene supplied to the current renderer invocation. */
@@ -6627,6 +6642,8 @@ interface RenderPipelineContext {
     cull(options?: Readonly<CullingOptions>): CullingResultsHandle;
     /** Select and sort a reusable draw list from current-frame culling results. */
     createRendererList(descriptor: Readonly<RendererListDescriptor>): RendererListHandle;
+    /** Draw an explicit mesh sequence through shared preparation without sorting or regrouping. */
+    createOrderedRendererList(descriptor: Readonly<OrderedRendererListDescriptor>): RendererListHandle;
     /**
      * Record the shared directional, spot, and point-light shadow atlas for these results.
      * Returns the exact graph texture and packed sampling data, or `null` when no shadow slice is
@@ -6671,6 +6688,12 @@ interface RenderPipelineFactory {
     readonly name: string;
     /** Static constraints snapshotted before asynchronous renderer creation. */
     readonly requirements?: Readonly<RenderPipelineRequirements>;
+    /**
+     * Camera and per-application-frame invocation constraints, snapshotted before creation.
+     * Omission accepts any camera with no host-imposed invocation limit. Violations abort the
+     * entire application frame before submission, even when the caller catches the error.
+     */
+    readonly invocationPolicy?: Readonly<RenderPipelineInvocationPolicy>;
     /** Create independent state for one Renderer. */
     create(context: RenderPipelineCreateContext): RenderPipeline | Promise<RenderPipeline>;
 }
@@ -6793,6 +6816,8 @@ declare class Renderer<Backend extends RendererBackend = RendererBackend> implem
     readonly renderToTarget: RendererContract['renderToTarget'];
     readonly onInit: (callback: (renderer: this) => void) => void;
     readonly waitForIdle: RendererContract['waitForIdle'];
+    /** Upload managed textures through a graph submission and await its fence, without drawing. */
+    readonly uploadTextures: RendererContract['uploadTextures'];
     readonly getExtension: RendererContract['getExtension'];
     readonly releaseGPUResources: RendererContract['releaseGPUResources'];
     readonly destroy: RendererContract['destroy'];
@@ -6864,6 +6889,8 @@ interface NodeParameters {
     sortingLayer?: number;
     /** Fine 2D display order within `sortingLayer`. Higher values render later. */
     zIndex?: number;
+    /** Keep this node's transparent subtree together in automatic renderer-list sorting. */
+    sortingGroup?: boolean;
     pointerEnabled?: boolean;
     pointerChildren?: boolean;
     useHandCursor?: boolean;
@@ -6901,6 +6928,7 @@ interface NodeParameters {
  * ```
  */
 declare class Node extends EventDispatcher {
+    #private;
     static readonly typeName: string;
     id: string;
     up: Vector3;
@@ -6979,6 +7007,7 @@ declare class Node extends EventDispatcher {
     layer: number;
     private sortingLayerValue;
     private zIndexValue;
+    private sortingGroupValue;
     /**
      * 可视对象是否接受交互事件。默认为接受交互事件，即true。
      */
@@ -7250,6 +7279,14 @@ declare class Node extends EventDispatcher {
     /** Fine 2D display order within `sortingLayer`. Higher values render later. */
     get zIndex(): number;
     set zIndex(value: number);
+    /**
+     * Treat this transparent subtree as one external sorting unit. Defaults to false.
+     * Groups sort by their own sortingLayer/zIndex, camera-view depth and stable scene order;
+     * descendant renderOrder values apply only inside the group. Nested groups remain atomic.
+     * Opaque queues and explicit ordered or unsorted renderer lists are unaffected.
+     */
+    get sortingGroup(): boolean;
+    set sortingGroup(value: boolean);
     /**
      * x轴坐标
      */
@@ -7382,7 +7419,8 @@ declare class Node extends EventDispatcher {
     /** 冒泡指针事件，并维护各 pointerId 的进入/离开状态。 */
     _firePointerEvent(event: NodePointerEvent): void;
     /**
-     * 销毁 Node 资源
+     * Destroy this hierarchy, invoking each child node's destroy override once.
+     * Child failures are aggregated after remaining descendants have been released and detached.
      * @param renderer - stage时可以不传
      * @param destroyTextures - 是否销毁材质的贴图，默认不销毁
      * @returns this
@@ -7441,8 +7479,167 @@ declare class SphericalHarmonics3 {
     copy(other: SphericalHarmonics3): this;
 }
 
+type CubeTextureImage = (TextureImageSource | null)[];
+interface CubeTextureParameters extends Omit<TextureParameters<CubeTextureImage>, 'target'> {
+    image?: CubeTextureImage | null;
+}
+/**
+ * 立方体纹理
+ * @example
+ * ```ts
+ * const loadQueue = new Hilo3d.LoadQueue([{
+ *     src: './textures/cube/right.jpg'
+ * }, {
+ *     src: './textures/cube/left.jpg'
+ * }, {
+ *     src: './textures/cube/top.jpg'
+ * }, {
+ *     src: './textures/cube/bottom.jpg'
+ * }, {
+ *     src: './textures/cube/front.jpg'
+ * }, {
+ *     src: './textures/cube/back.jpg'
+ * }]).on('complete', function () {
+ *     const result = loadQueue.getAllContent();
+ *     const skyboxMap = new Hilo3d.CubeTexture({
+ *         image: result
+ *     });
+ *     const skybox = new Hilo3d.Mesh({
+ *         geometry: new Hilo3d.BoxGeometry(),
+ *         material: new Hilo3d.BasicMaterial({
+ *             lightType: 'NONE',
+ *             diffuse: skyboxMap
+ *         })
+ *     });
+ *     stage.addChild(skybox);
+ * });
+ * ```
+ */
+declare class CubeTexture extends Texture<CubeTextureImage> {
+    isCubeTexture: boolean;
+    readonly className: string;
+    /**
+     * @param params - 初始化参数，所有params都会复制到实例上
+     * - `params.image`: 图片列表，共6张
+     */
+    constructor(params?: CubeTextureParameters);
+    private getImage;
+    private setImage;
+    /**
+     * 右侧的图片
+     */
+    get right(): HTMLImageElement | undefined;
+    /**
+     * 右侧的图片
+     */
+    set right(img: HTMLImageElement | undefined);
+    /**
+     * 左侧的图片
+     */
+    get left(): HTMLImageElement | undefined;
+    /**
+     * 左侧的图片
+     */
+    set left(img: HTMLImageElement | undefined);
+    /**
+     * 顶部的图片
+     */
+    get top(): HTMLImageElement | undefined;
+    /**
+     * 顶部的图片
+     */
+    set top(img: HTMLImageElement | undefined);
+    /**
+     * 底部的图片
+     */
+    get bottom(): HTMLImageElement | undefined;
+    /**
+     * 底部的图片
+     */
+    set bottom(img: HTMLImageElement | undefined);
+    /**
+     * 朝前的图片
+     */
+    get front(): HTMLImageElement | undefined;
+    /**
+     * 朝前的图片
+     */
+    set front(img: HTMLImageElement | undefined);
+    /**
+     * 朝后的图片
+     */
+    get back(): HTMLImageElement | undefined;
+    /**
+     * 朝后的图片
+     */
+    set back(img: HTMLImageElement | undefined);
+}
+
+/** Static inputs for an axis-aligned local specular reflection volume. */
+interface ReflectionProbeOptions {
+    /** World-space capture position, strictly inside the projection box. Copied at construction. */
+    readonly position: Readonly<Vector3>;
+    /** World-space minimum corner of the projection/influence box. Copied at construction. */
+    readonly boxMin: Readonly<Vector3>;
+    /** World-space maximum corner of the projection/influence box. Copied at construction. */
+    readonly boxMax: Readonly<Vector3>;
+    /** GGX-prefiltered cubemap. Omit to create a dynamic probe for ReflectionProbePipelineFactory. */
+    readonly texture?: CubeTexture;
+    /** Texture encoding; static RGBD inputs divide RGB by alpha. Defaults to linear. */
+    readonly encoding?: 'linear' | 'rgbd';
+    /** Width of the inward boundary fade in world units; defaults to 10% of the shortest side. */
+    readonly blendDistance?: number;
+    /** Non-negative radiance multiplier. Defaults to one. */
+    readonly intensity?: number;
+    /** Optional diagnostic name. */
+    readonly name?: string;
+}
+/** Immutable publication status for a local reflection probe. */
+interface ReflectionProbeDiagnostics {
+    /** Whether a complete static or submitted dynamic reflection is available. */
+    readonly ready: boolean;
+    /** Number of complete dynamic captures published, excluding discarded work. */
+    readonly captures: number;
+    /** Monotonic requested capture revision; changes only through requestUpdate(). */
+    readonly requestedRevision: number;
+    /** Last complete capture's requested revision. */
+    readonly capturedRevision: number;
+}
+/**
+ * Bounded world-space specular probe. Materials explicitly bind at most two probes and blend them
+ * per pixel. A dynamic probe belongs to one live capture runtime; authored cubemaps remain owned
+ * by the application. Probe transport is independent of diffuse DDGI.
+ */
+declare class ReflectionProbe {
+    #private;
+    /** Diagnostic label used for capture resources. */
+    readonly name: string;
+    /** Copied world-space capture position, ordered X/Y/Z. */
+    readonly position: readonly [number, number, number];
+    /** Copied world-space minimum corner, ordered X/Y/Z. */
+    readonly boxMin: readonly [number, number, number];
+    /** Copied world-space maximum corner, ordered X/Y/Z. */
+    readonly boxMax: readonly [number, number, number];
+    /** Inward smooth boundary-fade width in world units. */
+    readonly blendDistance: number;
+    /** Authored radiance encoding; dynamic capture always uses linear HDR. */
+    readonly encoding: 'linear' | 'rgbd';
+    /** Whether this probe needs a capture runtime instead of an authored cubemap. */
+    readonly dynamic: boolean;
+    constructor(options: Readonly<ReflectionProbeOptions>);
+    /** Radiance multiplier; zero disables this probe's contribution. */
+    get intensity(): number;
+    set intensity(value: number);
+    /** Request a complete new dynamic capture. In-progress captures finish before newer work. */
+    requestUpdate(): void;
+    /** Return immutable publication counters; partial captures never become ready results. */
+    getDiagnostics(): Readonly<ReflectionProbeDiagnostics>;
+}
+
 type PBRMaterialTextureInput = Texture<unknown> | MaterialTextureSlotInput | null;
 interface PBRMaterialParameters extends MaterialInstanceParameters {
+    /** One or two local specular volumes, blended per pixel with the environment fallback. */
+    readonly reflectionProbes?: readonly ReflectionProbe[];
     /** Compile the standard surface without lighting. */
     readonly unlit?: boolean;
     readonly baseColor?: Color;
@@ -7507,6 +7704,8 @@ declare class PBRMaterialBuilder {
 /** Physically based standard-surface material with immutable shader topology. */
 declare class PBRMaterial extends MaterialInstance {
     #private;
+    /** Immutable membership of this material's local reflection volumes. */
+    readonly reflectionProbes: readonly ReflectionProbe[];
     readonly isPBRMaterial = true;
     readonly className: string;
     readonly baseColor: Color;
@@ -8140,7 +8339,6 @@ type GLTFExtensionHandlerRegistry = Record<string, GLTFExtensionHandler>;
 interface GLTFParserParameters {
     src?: string;
     defaultScene?: GLTFIndex;
-    isMultiAnim?: boolean;
     isProgressive?: boolean;
     isUnQuantizeInShader?: boolean;
     isLoadAllTextures?: boolean;
@@ -8168,7 +8366,6 @@ declare class GLTFParser {
     json: GLTFRoot;
     src: string;
     defaultScene: GLTFIndex | undefined;
-    isMultiAnim: boolean;
     isProgressive: boolean;
     isUnQuantizeInShader: boolean;
     isLoadAllTextures: boolean;
@@ -8267,7 +8464,6 @@ declare class GLTFParser {
     private requireScalarAccessor;
     private validateKeyTimes;
     private validateAnimationOutput;
-    private animationRange;
     parseScene(): GLTFModel;
     getDefaultSceneName(): GLTFIndex;
     parseSkins(): void;
@@ -8278,10 +8474,10 @@ declare const WEB3D_quantized_attributes: {
     parse(extensionData: unknown, parser: GLTFParser, result: unknown, options: GLTFExtensionOptions): GeometryData;
 };
 declare const HILO_animation_clips: {
-    parseOnEnd(extensionData: unknown, parser: GLTFParser, result: unknown): GLTFModel;
+    parseOnEnd(extensionData: unknown, _parser: GLTFParser, result: unknown): GLTFModel;
 };
 declare const ALI_animation_clips: {
-    parseOnEnd(extensionData: unknown, parser: GLTFParser, result: unknown): GLTFModel;
+    parseOnEnd(extensionData: unknown, _parser: GLTFParser, result: unknown): GLTFModel;
 };
 declare const ALI_bounding_box: {
     parseOnEnd(extensionData: unknown, _parser: GLTFParser, result: unknown): GLTFModel;
@@ -8554,6 +8750,7 @@ interface StagePointerEvent extends NodePointerEvent {
  * ```
  */
 declare class Stage<Backend extends RendererBackend = RendererBackend> extends Node {
+    #private;
     static readonly typeName: string;
     isStage: boolean;
     className: string;
@@ -8709,6 +8906,7 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      * @param eventMode -
      */
     getMeshResultAtPoint(x: number, y: number, eventMode?: boolean): NodeRaycastInfo | null;
+    private grouped2DHit;
     private sortCameras;
     /**
      * 释放当前图形后端资源。
@@ -9996,12 +10194,88 @@ declare const UNIFORM_BLOCK_BINDINGS: Readonly<{
     readonly SkinningBlock: 7;
     readonly MorphBlock: 8;
     readonly MaterialTextureBlock: 9;
+    readonly ReflectionProbeBlock: 10;
 }>;
-declare const BUILTIN_UNIFORM_BLOCK_BINDING_COUNT = 10;
+declare const BUILTIN_UNIFORM_BLOCK_BINDING_COUNT = 11;
 /** Register an application block before linking programs. Binding points must be globally stable. */
 declare function registerUniformBlockBinding(name: string, bindingPoint?: number): number;
 declare function getUniformBlockBinding(name: string): number;
 
+/** WebGPU dynamic diffuse global illumination using a bounded world-space probe volume. */
+interface DynamicGlobalIlluminationOptions {
+    /** Position of the first probe. Defaults to (-4, 0, -4). */
+    readonly origin?: Readonly<Vector3>;
+    /** Positive world-space separation on each axis. Defaults to (1, 1, 1). */
+    readonly spacing?: Readonly<Vector3>;
+    /** Probe counts on X/Y/Z, each at least two; total limited to 4096. Defaults to [9, 5, 9]. */
+    readonly probeCounts?: readonly [number, number, number];
+    /** Uniform spherical rays per updated probe, one of 64, 128, 256. Defaults to 128. */
+    readonly raysPerProbe?: 64 | 128 | 256;
+    /** Strict maximum number of probes traced per frame. Defaults to 32. */
+    readonly maxProbesPerFrame?: number;
+    /** Maximum old-irradiance contribution in [0, 0.98]. Scene and light edits restart accumulation. */
+    readonly hysteresis?: number;
+    /** Diffuse indirect illumination multiplier in [0, 8]. Defaults to one. */
+    readonly intensity?: number;
+    /** World-space surface-normal visibility bias. Defaults to 0.08. */
+    readonly normalBias?: number;
+    /** World-space receiver-to-camera visibility bias. Defaults to 0.04. */
+    readonly viewBias?: number;
+    /** Maximum primary and directional-shadow ray distance. Defaults to 32 world units. */
+    readonly maxRayDistance?: number;
+    /** Linear RGB radiance for rays that miss the complete offscreen scene. */
+    readonly environment?: Readonly<Color>;
+    /** Fraction of the previously submitted diffuse bounce reused at hits, in [0, 0.95]. Defaults to 0.7. */
+    readonly bounceStrength?: number;
+    /** Clamp per-ray radiance before temporal integration to control fireflies. Defaults to 32. */
+    readonly maxRayRadiance?: number;
+    /** Relocate probes away from surfaces and out of solids within 45% of cell spacing. Defaults to true. */
+    readonly relocation?: boolean;
+    /** Maximum triangles in the CPU BVH and GPU ray scene. Defaults to 65536. */
+    readonly maxTriangles?: number;
+    /** Maximum world-space point, spot and directional lights; overflow fails clearly. Defaults to 32. */
+    readonly maxLights?: number;
+    /** Unsupported geometry/material handling. Defaults to error. */
+    readonly unsupported?: 'error' | 'exclude';
+    /** Texture handling for ray-hit diffuse/emissive factors. Defaults to error. */
+    readonly texturePolicy?: 'error' | 'exclude' | 'material-factor';
+}
+/** CPU-known counts for the last submitted DDGI frame; no implicit GPU readback. */
+interface DynamicGlobalIlluminationDiagnostics {
+    /** Total number of probes in the volume. */
+    readonly probeCount: number;
+    /** Scheduled probes whose ray updates were submitted. */
+    readonly updatedProbeCount: number;
+    /** Submitted primary rays; secondary light-visibility rays are not included. */
+    readonly tracedRayCount: number;
+    /** Current complete offscreen ray-scene triangle count. */
+    readonly sceneTriangleCount: number;
+    /** Current complete offscreen BVH node count. */
+    readonly sceneNodeCount: number;
+    /** Unsupported scene meshes deliberately omitted under the selected policy. */
+    readonly excludedMeshCount: number;
+    /** Textured meshes encountered during extraction; texturePolicy and excludedMeshCount describe their treatment. */
+    readonly texturedMeshCount: number;
+    /** Meshes changed during the last extraction. */
+    readonly changedMeshCount: number;
+    /** Last CPU scene update operation. */
+    readonly sceneUpdate: 'rebuild' | 'refit' | 'material';
+    /** Allocated persistent buffer bytes, including both probe-history slots. */
+    readonly residentBytes: number;
+    /** CPU bytes uploaded by the last successful frame, including parameters and lights. */
+    readonly uploadedBytes: number;
+    /** Subset of uploadedBytes used for changed triangles and BVH nodes. */
+    readonly sceneUploadedBytes: number;
+    /** Number of successful probe-update submissions. */
+    readonly submittedFrameCount: number;
+    /** Number of scheduled frames needed to visit every probe. */
+    readonly updateCycleFrames: number;
+    /** Exact light count included in ray-hit direct illumination. */
+    readonly lightCount: number;
+    /** Unsupported lights omitted only under the explicit exclude policy. */
+    readonly excludedLightCount: number;
+}
+
 /** Stable stages at which a forward feature may synchronously record graph work. */
 type ForwardRenderInjectionPoint = 'before-shadow' | 'after-shadow' | 'before-opaque' | 'after-opaque' | 'before-transparent' | 'after-transparent' | 'before-post-process' | 'after-post-process' | 'before-output';
 /** Static resource and device requirements declared before backend selection. */
@@ -10125,6 +10399,8 @@ declare class ForwardRenderPipelineFactory implements RenderPipelineFactory {
     #private;
     /** Stable factory name. */
     readonly name = "forward";
+    /** Accepts every camera class and repeated invocations within one application frame. */
+    readonly invocationPolicy: Readonly<RenderPipelineInvocationPolicy>;
     /** Merged static requirements from every feature configuration. */
     readonly requirements: Readonly<RenderPipelineRequirements>;
     /** Constructor-snapshotted feature configurations in insertion order. */
@@ -10138,1188 +10414,1217 @@ declare class ForwardRenderPipelineFactory implements RenderPipelineFactory {
     create(context: RenderPipelineCreateContext): RenderPipeline;
 }
 
-/** GPU-time-driven dynamic-resolution controls. */
-interface DynamicResolutionOptions {
-    /** Lowest internal resolution scale. Defaults to 0.5. */
-    readonly minScale?: number;
-    /** Highest internal resolution scale. Defaults to 1. */
-    readonly maxScale?: number;
-    /** Initial scale before enough GPU samples are available. Defaults to `maxScale`. */
-    readonly initialScale?: number;
-    /** Target summed profiled Render Graph render/compute duration in milliseconds. Defaults to 16.667. */
-    readonly targetFrameTimeMs?: number;
-    /** Symmetric no-change band around the target, as a ratio. Defaults to 0.1. */
-    readonly hysteresis?: number;
-    /** EWMA contribution of the newest GPU sample. Defaults to 0.2. */
-    readonly response?: number;
-    /** Quantized scale adjustment applied at each decision. Defaults to 0.05. */
-    readonly scaleStep?: number;
-    /** Successful GPU samples required before the first decision. Defaults to 6. */
-    readonly warmupFrames?: number;
-    /** Minimum GPU samples between scale changes. Defaults to 8. */
-    readonly settlingFrames?: number;
-}
-/** Temporal anti-aliasing, temporal upscaling, and optional dynamic-resolution controls. */
-interface TemporalAAOptions {
-    /**
-     * Internal scene resolution relative to the output. Values below one enable TAAU. When
-     * `dynamicResolution` is present this overrides that object's initial scale.
-     * Defaults to 1 and is constrained to the inclusive range 0.5–1.
-     */
-    readonly renderScale?: number;
-    /** GPU timestamp driven dynamic resolution. Omit or use false for a fixed render scale. */
-    readonly dynamicResolution?: Readonly<DynamicResolutionOptions> | false;
-    /** Maximum accepted history contribution after rejection. Defaults to 0.92. */
-    readonly historyWeight?: number;
-    /** Maximum relative previous-view-depth error. Defaults to 0.02. */
-    readonly depthThreshold?: number;
-    /** Standard-deviation extent used by YCoCg variance clipping. Defaults to 1.25. */
-    readonly varianceGamma?: number;
-    /** Resolve-only contrast restoration; history remains unsharpened. Defaults to 0.08. */
-    readonly sharpness?: number;
+/** One graph-buffer range consumed by a storage binding. */
+interface ComputeBufferBinding {
+    /** Frame-scoped graph buffer handle. */
+    readonly buffer: RenderGraphBufferHandle;
+    /** Four-byte-aligned offset into the buffer, defaulting to zero. */
+    readonly byteOffset?: number;
+    /** Four-byte-aligned bound range, defaulting to the remaining buffer. */
+    readonly byteLength?: number;
 }
-/** Stable adaptive-resolution telemetry for renderer diagnostics. */
-interface DynamicResolutionDiagnostics {
-    /** Current internal scene resolution relative to the output. */
-    readonly renderScale: number;
-    /** EWMA of accepted profiled Render Graph GPU work, or null before the first sample. */
-    readonly smoothedGPUFrameTimeMs: number | null;
-    /** Number of distinct ready GPU timeline samples accepted by this controller. */
-    readonly sampledFrameCount: number;
+/** One graph texture consumed by a sampled- or storage-texture binding. */
+interface ComputeTextureBinding {
+    /** Complete single-sample two-dimensional graph texture subresource. */
+    readonly texture: RenderGraphTextureAccessHandle;
+}
+/** A whole std140 uniform buffer or one explicitly selected range. */
+type ComputeUniformBufferBinding = UniformBuffer | UniformBufferRange;
+/** Direct or GPU-authored indirect dispatch dimensions. */
+type ComputeDispatch = Readonly<{
+    x: number;
+    y?: number;
+    z?: number;
+}> | Readonly<{
+    indirectBuffer: RenderGraphBufferHandle;
+    indirectOffset?: number;
+}>;
+/** Frame-scoped binding resources and dispatch parameters for one compute pass. */
+interface ComputeRenderPassParameters {
+    /** std140 uniform resources in sorted uniform-binding order. */
+    readonly uniformBuffers?: readonly ComputeUniformBufferBinding[];
+    /** Storage resources in sorted storage-buffer-binding order. */
+    readonly buffers: readonly ComputeBufferBinding[];
+    /** Texture resources in sorted sampled/storage-texture-binding order. */
+    readonly textures: readonly ComputeTextureBinding[];
+    /** Immutable samplers in sorted sampler-binding order. */
+    readonly samplers?: readonly ComputeSampler[];
+    /** Direct dimensions or an indirect argument buffer. */
+    readonly dispatch: ComputeDispatch;
 }
 /**
- * Temporal anti-aliasing, temporal upscaling, and GPU-time dynamic-resolution feature.
+ * Stable WebGPU compute pass backed by one immutable {@link ComputeKernel}.
  *
- * The feature records built-in opaque/masked motion and logarithmic view-depth data after opaque
- * shading, resolves only opaque scene color, then lets transparent rendering and Bloom compose
- * afterward. History uses submission-aware double buffers and is reset by camera cuts, resize,
- * projection discontinuities, visibility gaps, or device recovery.
+ * Binding arrays are positional within their resource category and follow the shader ABI after
+ * sorting by `(group, binding)`. Setup derives graph access directly from that ABI; callers cannot
+ * downgrade a writable storage binding to a read dependency.
  */
-declare class TemporalAA implements ForwardRenderPipelineFeature {
-    #private;
-    readonly name = "temporal-aa";
-    readonly injectionPoint: "after-opaque";
-    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
-    constructor(options?: Readonly<TemporalAAOptions>);
-    create(): ForwardRenderPipelineFeatureRuntime;
-    /** Read adaptive-resolution state when this feature is attached to exactly one live Renderer. */
-    readDynamicResolutionDiagnostics(): Readonly<DynamicResolutionDiagnostics>;
+declare class ComputeRenderPass implements ScriptableRenderPass<ComputeRenderPassParameters> {
+    /** Stable diagnostic pass name. */
+    readonly name: string;
+    /** Immutable compute pipeline and shader identity. */
+    readonly kernel: ComputeKernel;
+    constructor(kernel: ComputeKernel, name?: string);
+    /** Declare storage, texture, and indirect dependencies from the immutable shader ABI. */
+    setup(builder: ScriptableRenderPassBuilder, parameters: ComputeRenderPassParameters): void;
+    /** Command emission is supplied by the framework after the pass callback returns. */
+    execute(_context: ScriptableRenderPassContext, _parameters: ComputeRenderPassParameters): void;
 }
 
-/** Production controls for the WebGPU high-end hierarchical screen-space reflection path. */
-interface ScreenSpaceReflectionsOptions {
-    /** Reflection trace resolution relative to the internal scene. Defaults to 0.5. */
-    readonly resolutionScale?: number;
-    /** Maximum view-space ray length. Defaults to 80. */
-    readonly maxRayDistance?: number;
-    /** View-space surface thickness accepted as a hit. Defaults to 0.2. */
-    readonly thickness?: number;
-    /** Minimum view-space distance advanced by the finest hierarchy level. Defaults to 0.12. */
-    readonly stride?: number;
-    /** Maximum hierarchical iterations per reflected pixel. Defaults to 64. */
-    readonly maxSteps?: number;
-    /** Surfaces at or above this perceptual roughness stop tracing. Defaults to 0.85. */
-    readonly roughnessCutoff?: number;
-    /** Width of the screen-edge confidence fade in normalized coordinates. Defaults to 0.08. */
-    readonly edgeFade?: number;
-    /** Maximum accepted temporal history contribution. Defaults to 0.9. */
-    readonly historyWeight?: number;
-    /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
-    readonly depthThreshold?: number;
-    /** Linear HDR multiplier applied to SSR radiance, without scaling fallback removal. Defaults to 1. */
-    readonly intensity?: number;
+/** A keyed cache with optional object-identity lookup. */
+declare class Cache<Value = unknown> {
+    private readonly entries;
+    private objectIds;
+    /** @internal Renderer diagnostics only; not part of the public cache contract. */
+    get size(): number;
+    get(id: string): Value | undefined;
+    getObject(object: object): Value | undefined;
+    add(id: string, value: Value): void;
+    remove(id: string): void;
+    removeObject(object: object): void;
+    removeAll(): void;
+    each(callback: (value: Value, id: string) => void): void;
 }
 
-/** Quality preset used when an individual GTAO sampling control is omitted. */
-type GroundTruthAmbientOcclusionQuality = 'low' | 'medium' | 'high' | 'ultra';
-/** Normal source used for GTAO horizon integration and edge rejection. */
-type GroundTruthAmbientOcclusionNormalSource = 'material' | 'geometry' | 'hybrid';
-/** Production controls for ground-truth ambient occlusion. */
-interface GroundTruthAmbientOcclusionOptions {
-    /** Sampling preset. Individual resolution/direction/step controls override it. Defaults to high. */
-    readonly quality?: GroundTruthAmbientOcclusionQuality;
-    /** Internal AO resolution relative to opaque rendering. Defaults to the quality preset. */
-    readonly resolutionScale?: number;
-    /** View-space horizon-search radius. Defaults to 2. */
-    readonly radius?: number;
-    /** Fraction of the radius at which distance falloff begins. Defaults to 0.6. */
-    readonly falloffStart?: number;
-    /** View-space self-intersection rejection distance. Defaults to 0.05. */
-    readonly thickness?: number;
-    /** Blend between a thin depth field and a solid occluder. Defaults to 0.5. */
-    readonly thicknessBlend?: number;
-    /** Number of rotated horizon slices per pixel. Defaults to the quality preset. */
-    readonly directionCount?: 2 | 3 | 4 | 6 | 8;
-    /** Samples evaluated on each side of a horizon slice. Defaults to the quality preset. */
-    readonly stepCount?: 3 | 4 | 5 | 6 | 8 | 10 | 12;
-    /** Contrast applied to the physically normalized visibility. Defaults to 1.2. */
-    readonly power?: number;
-    /** Occlusion intensity before contrast. Defaults to 1. */
-    readonly intensity?: number;
-    /** Angular self-occlusion bias in radians. Defaults to 0.035. */
-    readonly bias?: number;
-    /** Radius of the additional contact-occlusion lobe, relative to radius. Defaults to 0.2. */
-    readonly contactRadiusScale?: number;
-    /** Strength of the contact-occlusion lobe. Defaults to 0.35. */
-    readonly contactStrength?: number;
-    /** Normal source used by the horizon search. Defaults to hybrid. */
-    readonly normalSource?: GroundTruthAmbientOcclusionNormalSource;
-    /** Geometric-normal contribution in hybrid mode. Defaults to 0.65. */
-    readonly geometricNormalWeight?: number;
-    /** Strength of bent-normal redirection. Defaults to 1. */
-    readonly bentNormalStrength?: number;
-    /** Strength of color-aware multi-bounce diffuse AO. Defaults to 1. */
-    readonly multiBounce?: number;
-    /** View distance where AO starts fading. Defaults to 100. */
-    readonly distanceFadeStart?: number;
-    /** View distance where AO is fully disabled. Defaults to 200. */
-    readonly distanceFadeEnd?: number;
-    /** Screen-edge fade width in AO pixels. Defaults to 2. */
-    readonly edgeFadePixels?: number;
-    /** Maximum accepted temporal contribution. Defaults to 0.9. */
-    readonly historyWeight?: number;
-    /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
-    readonly depthThreshold?: number;
-    /** Minimum normal agreement accepted by temporal reprojection. Defaults to 0.82. */
-    readonly normalThreshold?: number;
+interface ShaderParameters {
+    vs?: string;
+    fs?: string;
+    alwaysUse?: boolean;
 }
-/**
- * Portable production GTAO for the shared Forward pipeline.
- *
- * The feature records opaque depth, material attributes, and motion before shading, evaluates
- * rotated horizon visibility at configurable resolution, applies submission-aware temporal
- * rejection and edge-aware filtering, and binds the full-resolution result only to indirect PBR
- * lighting. Direct lights and emission remain unoccluded.
- */
-declare class GroundTruthAmbientOcclusion implements ForwardRenderPipelineFeature {
-    #private;
-    readonly name = "ground-truth-ambient-occlusion";
-    readonly injectionPoint: "before-opaque";
-    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
-    constructor(options?: Readonly<GroundTruthAmbientOcclusionOptions>);
-    create(): ForwardRenderPipelineFeatureRuntime;
+interface ShaderPrecisionProvider {
+    vertexPrecision: ShaderPrecision;
+    fragmentPrecision: ShaderPrecision;
 }
-
-/** Production controls for portable screen-space diffuse global illumination. */
-interface ScreenSpaceGlobalIlluminationOptions {
-    /** Internal tracing resolution relative to opaque rendering. Defaults to 0.5. */
-    readonly resolutionScale?: number;
-    /** Stochastic hemisphere rays traced per pixel. Defaults to 8. */
-    readonly rayCount?: 4 | 6 | 8 | 12;
-    /** Depth tests performed along each ray. Defaults to 8. */
-    readonly stepCount?: 6 | 8 | 10 | 12;
-    /** Maximum view-space ray distance. Defaults to 4. */
-    readonly maxRayDistance?: number;
-    /** View-space hit thickness used by ray/depth intersection. Defaults to 0.18. */
-    readonly thickness?: number;
-    /** Fraction of the trace distance at which contribution fading begins. Defaults to 0.72. */
-    readonly distanceFadeStart?: number;
-    /** Strength of the diffuse bounce added to linear scene color. Defaults to 1. */
-    readonly intensity?: number;
-    /** Saturation of transported radiance. Defaults to 1.1. */
-    readonly saturation?: number;
-    /** Firefly clamp for transported linear radiance. Defaults to 8. */
-    readonly maxRadiance?: number;
-    /** Maximum accepted temporal contribution. Defaults to 0.92. */
-    readonly historyWeight?: number;
-    /** Maximum relative reprojected view-depth error. Defaults to 0.025. */
-    readonly depthThreshold?: number;
-    /** Minimum normal similarity accepted by reprojection. Defaults to 0.82. */
-    readonly normalThreshold?: number;
-    /** Number of edge-aware a-trous denoise passes. Defaults to 3. */
-    readonly denoisePasses?: 1 | 2 | 3;
+interface ShaderRenderer extends ShaderPrecisionProvider {
+    resourceManager: RendererResourceManager;
 }
 /**
- * Portable production screen-space diffuse global illumination for the shared Forward pipeline.
- *
- * The feature traces stochastic view-space rays against opaque depth, transports linear HDR scene
- * radiance, rejects invalid history using motion/depth/normal data, applies variance clipping and
- * edge-aware a-trous filtering, then composites the result before transparent rendering.
+ * Shader类
  */
-declare class ScreenSpaceGlobalIllumination implements ForwardRenderPipelineFeature {
-    #private;
-    readonly name = "screen-space-global-illumination";
-    readonly injectionPoint: "after-opaque";
-    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
-    constructor(options?: Readonly<ScreenSpaceGlobalIlluminationOptions>);
-    create(): ForwardRenderPipelineFeatureRuntime;
-}
-
-/** Named performance/quality presets for froxel reconstruction and light visibility. */
-type VolumetricLightingQuality = 'low' | 'medium' | 'high' | 'ultra';
-/** Optional integrated-volume diagnostic shown in place of the composited HDR scene. */
-type VolumetricLightingDebugView = 'none' | 'radiance' | 'transmittance';
-/** One world-space spherical local fog-density volume. */
-interface VolumetricSphereFogVolume {
-    /** Discriminant selecting spherical density evaluation. */
-    readonly shape: 'sphere';
-    /** Mutable world-space center sampled at frame-record time. */
-    readonly center: Readonly<Vector3>;
-    /** Outer sphere radius in world units. */
-    readonly radius: number;
-    /** Density added inside the volume. */
-    readonly density: number;
-    /** Single-scattering albedo tint. Defaults to the global fog albedo. */
-    readonly albedo?: Readonly<Color>;
-    /** Fraction of the radius used for a smooth edge. Defaults to 0.2. */
-    readonly edgeFalloff?: number;
-}
-/** One axis-aligned world-space box local fog-density volume. */
-interface VolumetricBoxFogVolume {
-    /** Discriminant selecting axis-aligned box density evaluation. */
-    readonly shape: 'box';
-    /** Mutable world-space center sampled at frame-record time. */
-    readonly center: Readonly<Vector3>;
-    /** Mutable positive half extent sampled at frame-record time. */
-    readonly halfExtents: Readonly<Vector3>;
-    /** Density added inside the volume. */
-    readonly density: number;
-    /** Single-scattering albedo tint. Defaults to the global fog albedo. */
-    readonly albedo?: Readonly<Color>;
-    /** Fraction of the smallest half extent used for a smooth edge. Defaults to 0.2. */
-    readonly edgeFalloff?: number;
-}
-/** Local fog shapes injected into the camera-aligned froxel volume. */
-type VolumetricFogVolume = VolumetricSphereFogVolume | VolumetricBoxFogVolume;
-/** Production controls for WebGPU Clustered Forward+ froxel volumetric lighting. */
-interface VolumetricLightingOptions {
-    /** Preset used for unspecified reconstruction and shadow budgets. Defaults to high. */
-    readonly quality?: VolumetricLightingQuality;
-    /** Froxel XY and reconstruction resolution relative to the internal scene. Defaults to the preset. */
-    readonly resolutionScale?: number;
-    /** Depth-aware screen-space light visibility samples in [0, 8]. Defaults to the preset. */
-    readonly shadowSteps?: number;
-    /** Global extinction density in inverse world units. Defaults to 0.025. */
-    readonly density?: number;
-    /** World-space height at and below which global density is constant. Defaults to 0. */
-    readonly baseHeight?: number;
-    /** Exponential density falloff above baseHeight. Defaults to 0.12. */
-    readonly heightFalloff?: number;
-    /** Maximum integrated view distance in world units. Defaults to 120. */
-    readonly maxDistance?: number;
-    /** Global single-scattering albedo. Defaults to a cool neutral white. */
-    readonly albedo?: Readonly<Color>;
-    /** Henyey-Greenstein anisotropy in [-0.9, 0.9]. Positive values emphasize forward scatter. */
-    readonly anisotropy?: number;
-    /** Ambient light injected into the medium. Defaults to 0.12. */
-    readonly ambientStrength?: number;
-    /** Sub-froxel stochastic sample offset strength in [0, 1]. Defaults to 1. */
-    readonly jitterStrength?: number;
-    /** Maximum temporal history contribution in [0, 0.98]. Defaults to 0.9. */
-    readonly historyWeight?: number;
-    /** Maximum relative scene-depth disagreement accepted during reprojection. Defaults to 0.04. */
-    readonly depthThreshold?: number;
-    /** Optional world-space local fog volumes, limited to 32. */
-    readonly localVolumes?: readonly VolumetricFogVolume[];
-    /** Replace normal composition with an integrated radiance or extinction diagnostic. */
-    readonly debugView?: VolumetricLightingDebugView;
+declare class Shader {
+    readonly isShader = true;
+    readonly className = "Shader";
+    readonly id: string;
+    private _isDestroyed;
+    private _variantKey;
+    /**
+     * vs 顶点代码
+     */
+    vs: string;
+    /**
+     * vs 片段代码
+     */
+    fs: string;
+    static commonOptions: Record<string, number>;
+    /**
+     * 内部的所有shader块字符串，可以用来拼接glsl代码
+     */
+    static shaders: {
+        [k: string]: string;
+    };
+    /**
+     * 初始化
+     * @param renderer -
+     */
+    static init(renderer: ShaderPrecisionProvider): void;
+    /**
+     * Shader 缓存
+     */
+    static get cache(): Cache<Shader>;
+    /**
+     * Shader header缓存，一般不用管
+     */
+    static get headerCache(): Cache<string>;
+    /**
+     * 重置
+     */
+    static reset(): void;
+    /**
+     * 获取header缓存的key
+     * @param mesh - mesh
+     * @param material - 材质
+     * @param lightManager - lightManager
+     * @param fog - fog
+     * @param useLogDepth - 是否使用对数深度
+     */
+    static getHeaderKey(mesh: Mesh, material: MaterialInstance, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, role?: MaterialPassRole): string;
+    /**
+     * 获取header
+     * @param mesh -
+     * @param material -
+     * @param lightManager -
+     * @param fog -
+     */
+    static getHeader(mesh: Mesh, material: MaterialInstance, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, role?: MaterialPassRole): string;
+    private static getHeaderVariant;
+    private static trackHeaderVariantKey;
+    private static trackShaderVariant;
+    private static getCommonHeader;
+    /**
+     * 获取 shader
+     * @param mesh -
+     * @param material -
+     * @param isUseInstance -
+     * @param lightManager -
+     * @param fog -
+     * @param useLogDepth -
+     * @param renderer - Renderer precision provider used to build the portable shader preamble.
+     * @param linearOutput - Keep lighting in linear HDR space for floating-point scene targets.
+     * @param groundTruthAmbientOcclusion - Sample the pass-global GTAO visibility in PBR shading.
+     */
+    static getShader(mesh: Mesh, material: MaterialInstance, isUseInstance: boolean, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, renderer?: ShaderPrecisionProvider, linearOutput?: boolean, role?: MaterialPassRole, groundTruthAmbientOcclusion?: boolean): Shader | null;
+    /**
+     * 获取基础 shader
+     * @param material -
+     * @param isUseInstance -
+     * @param header - 已生成的 shader 宏定义
+     */
+    static getBasicShader(material: MaterialInstance, isUseInstance: boolean, header: string, renderer?: ShaderPrecisionProvider, role?: MaterialPassRole): Shader;
+    private static getNumericId;
+    /**
+     * 获取自定义shader
+     * @param vs - 顶点代码
+     * @param fs - 片段代码
+     * @param cacheKey - 如果有，会以此值缓存 shader
+     * @param useHeaderCache - 是否使用 header-aware 缓存命名空间；实际 header 始终参与缓存键
+     */
+    static getCustomShader(vs: string, fs: string, header?: string, cacheKey?: string, useHeaderCache?: boolean, renderer?: ShaderPrecisionProvider): Shader;
+    private static getRendererHeader;
+    private static assembleGLSL300;
+    /**
+     * 是否始终使用
+     */
+    alwaysUse: boolean;
+    /**
+     * @param params - 初始化参数，所有params都会复制到实例上
+     */
+    constructor(params?: ShaderParameters);
+    /**
+     * 没有被引用时销毁资源
+     * @param renderer -
+     * @returns this
+     */
+    destroyIfNoRef(renderer: ShaderRenderer): this;
+    /**
+     * 销毁资源
+     * @returns this
+     */
+    destroy(): this;
 }
 
-/** Luminance-metering pattern used by {@link AutoExposure}. */
-type AutoExposureMeteringMode = 'average' | 'center-weighted';
-/** GPU histogram, percentile metering, and eye-adaptation controls. */
-interface AutoExposureOptions {
-    /** Lowest log2 luminance represented by the histogram. Defaults to -12. */
-    readonly minimumLogLuminance?: number;
-    /** Highest log2 luminance represented by the histogram. Defaults to 16. */
-    readonly maximumLogLuminance?: number;
-    /** Dark-tail percentile excluded from metering in [0, 0.49]. Defaults to 0.02. */
-    readonly lowPercentile?: number;
-    /** Bright-tail percentile retained by metering in [0.51, 1]. Defaults to 0.98. */
-    readonly highPercentile?: number;
-    /** Minimum automatically selected EV in [-15, 15]. Defaults to -8. */
-    readonly minimumEV?: number;
-    /** Maximum automatically selected EV in [-15, 15]. Defaults to 8. */
-    readonly maximumEV?: number;
-    /** Exposure compensation in EV stops. Defaults to 0. */
-    readonly compensation?: number;
-    /** Middle-gray target luminance in [0.01, 0.5]. Defaults to 0.18. */
-    readonly keyValue?: number;
-    /** Adaptation speed when exposure increases, in inverse seconds. Defaults to 1.5. */
-    readonly speedUp?: number;
-    /** Adaptation speed when exposure decreases, in inverse seconds. Defaults to 3. */
-    readonly speedDown?: number;
-    /** Histogram sampling stride in pixels. Defaults to 2. */
-    readonly sampleStride?: number;
-    /** Metering pattern. Defaults to center-weighted. */
-    readonly metering?: AutoExposureMeteringMode;
+/** Immutable shader and binding configuration for a fullscreen pass instance. */
+interface FullscreenRenderPassOptions {
+    /** Optional diagnostic pass name. */
+    readonly name?: string;
+    /** GLSL ES 3.00 shader with no vertex attributes. */
+    readonly shader: Shader;
+    /** Fixed raster, depth, blend, and culling state. */
+    readonly pipelineState: Readonly<MaterialPipelineState>;
+    /** std140 buffers in reflected uniform-block order. */
+    readonly uniformBuffers?: readonly UniformBuffer[];
 }
-/** On-demand values written by the latest submitted exposure reduction. */
-interface AutoExposureDiagnostics {
-    /** Adapted exposure in EV stops. */
-    readonly actualEV: number;
-    /** Histogram-derived target exposure in EV stops. */
-    readonly targetEV: number;
-    /** Percentile-clipped geometric mean luminance. */
-    readonly averageLuminance: number;
-    /** Weighted histogram sample count. */
-    readonly sampleCount: number;
+/** Frame-scoped graph resources and dynamic state for one fullscreen draw. */
+interface FullscreenRenderPassParameters {
+    /** Sampled textures in reflected sampler order; numeric depth uses nearest sampling. */
+    readonly inputTextures: readonly RenderGraphTextureAccessHandle[];
+    /** Color attachments in fragment-output location order. */
+    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
+    /** Optional depth/stencil attachment. */
+    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
+    /** Optional execution viewport in physical attachment pixels. */
+    readonly viewport?: RendererViewport;
+    /** Optional execution scissor in physical attachment pixels. */
+    readonly scissor?: RendererViewport;
+    /** Optional unsigned stencil reference. */
+    readonly stencilReference?: number;
 }
 /**
- * WebGPU histogram auto exposure with percentile clipping and submission-aware eye adaptation.
+ * Draws a `gl_VertexID` fullscreen triangle with graph textures resolved during prepare.
  *
- * The feature records after HDR post-processing and before the display transform, so Bloom and
- * authored emissive energy share one exposure. It performs no per-frame CPU readback.
+ * The vertex shader must declare no vertex attributes. GLSL samplers and registered std140
+ * blocks are matched to the fixed arrays captured by this pass instance. Color inputs use the
+ * shared linear sampler; ordinary depth inputs are specialized to numeric depth and use the
+ * shared non-filtering sampler on both rendering backends.
  */
-declare class AutoExposure implements ForwardRenderPipelineFeature {
-    #private;
-    readonly name = "auto-exposure";
-    readonly injectionPoint: "after-post-process";
-    readonly requirements: Readonly<{
-        sampledSceneColor: true;
-        sampledDepth: false;
-        requiredCapabilities: readonly ("compute-pass" | "storage-buffer" | "storage-texture")[];
-        requiredTextureFormats: readonly (Readonly<{
-            format: "rgba16float";
-            use: "filterable-sampled";
-        }> | Readonly<{
-            format: "rgba16float";
-            use: "storage";
-        }> | Readonly<{
-            format: "rgba16float";
-            use: "color-attachment";
-        }>)[];
-        requiredLimits: Readonly<{
-            maxBindingsPerBindGroup: 5;
-            maxStorageBuffersPerShaderStage: 3;
-            maxStorageTexturesPerShaderStage: 1;
-            maxSampledTexturesPerShaderStage: 1;
-            maxComputeInvocationsPerWorkgroup: number;
-        }>;
-    }>;
-    constructor(options?: Readonly<AutoExposureOptions>);
-    create(context: RenderPipelineCreateContext): ForwardRenderPipelineFeatureRuntime;
-    /** Read the latest adapted values when attached to exactly one live renderer. */
-    readDiagnostics(): Promise<Readonly<AutoExposureDiagnostics>>;
-}
-
-/** GPU receiver-driven shadow-page allocation and directional clipmap controls. */
-interface VirtualShadowMapOptions {
-    /** Square virtual resolution for every directional clipmap level. Defaults to 4096. */
-    readonly virtualResolution?: number;
-    /** Square physical page edge in pixels. Defaults to 128. */
-    readonly pageSize?: number;
-    /** Shared physical depth-page capacity. Defaults to 32. */
-    readonly physicalPageCount?: number;
-    /** Maximum missing or invalidated pages rendered by one frame. Defaults to 16. */
-    readonly maxPageUpdatesPerFrame?: number;
-    /** Camera-centered directional clipmap levels. Defaults to 4. */
-    readonly directionalClipmapLevels?: number;
-    /** Full world-space width covered by the finest clipmap. Defaults to 64. */
-    readonly firstDirectionalClipmapExtent?: number;
+declare class FullscreenRenderPass implements ScriptableRenderPass<FullscreenRenderPassParameters> {
+    /** Stable diagnostic pass name. */
+    readonly name: string;
+    /** Shader compiled through the shared GLSL-to-backend pipeline. */
+    readonly shader: Shader;
+    /** Fixed material state for the fullscreen triangle. */
+    readonly pipelineState: Readonly<MaterialPipelineState>;
+    /** Uniform buffers in reflected block order. */
+    readonly uniformBuffers: readonly UniformBuffer[];
+    constructor(options: Readonly<FullscreenRenderPassOptions>);
+    /** Declare sampled inputs and raster attachments. */
+    setup(builder: ScriptableRenderPassBuilder, parameters: FullscreenRenderPassParameters): void;
+    /** Apply optional dynamic state; the framework emits the prepared triangle afterward. */
+    execute(context: ScriptableRenderPassContext, parameters: FullscreenRenderPassParameters): void;
 }
-/** On-demand counters copied only when diagnostics are explicitly requested. */
-interface VirtualShadowMapDiagnostics {
-    /** Unique logical pages requested by the latest submitted receiver pass. */
-    readonly requestedPageCount: number;
-    /** Physical pages whose depth contents were refreshed by the latest submitted frame. */
-    readonly renderedPageCount: number;
-    /** Requested or dirty pages postponed by the configured update/physical-page budgets. */
-    readonly deferredPageCount: number;
-    /** Valid physical residency records retained after the latest submitted allocation. */
-    readonly residentPageCount: number;
-    /** Resident physical pages remapped to another logical identity. */
-    readonly evictionCount: number;
-    /** Unique logical pages touched by changed caster coverage. */
-    readonly invalidatedPageCount: number;
-    /** Configured physical depth-page capacity. */
-    readonly physicalPageCapacity: number;
-    /** Configured camera-centered clipmap levels per directional light. */
-    readonly directionalClipmapLevelCount: number;
+/** Fullscreen graph-texture present pass with one fixed linear sampler. */
+declare class PresentRenderPass extends FullscreenRenderPass {
+    constructor(name?: string);
 }
 
-/** Rendering budgets for the physical atmosphere and volumetric clouds. */
-type AtmosphereWeatherQuality = 'low' | 'medium' | 'high' | 'ultra';
-/** Optional diagnostic texture shown in place of the weather composition. */
-type AtmosphereWeatherDebugView = 'none' | 'transmittance' | 'multi-scattering' | 'sky-view' | 'weather-map' | 'cloud-radiance' | 'cloud-transmittance' | 'cloud-shadow';
-/**
- * Mutable state sampled by the weather renderer at frame-record time.
- *
- * Updating these values does not recreate pipelines. Call `invalidateHistory()` after a
- * discontinuous preset or time-of-day jump; continuous animation may update `timeSeconds` and
- * `sunDirection` every frame without resetting history.
- */
-declare class AtmosphereWeatherState {
-    #private;
-    /** Normalized world-space direction from the scene toward the sun. */
-    readonly sunDirection: Vector3;
-    /** Procedural weather animation time in seconds. */
-    timeSeconds: number;
-    /** Fractional cloud coverage in [0, 1]. */
-    cloudCoverage: number;
-    /** Cloud optical-density multiplier in [0, 4]. */
-    cloudDensity: number;
-    /** Cumulonimbus/storm shaping in [0, 1]. */
-    storminess: number;
-    /** Horizontal wind direction; Y is ignored. */
-    readonly windDirection: Vector3;
-    /** Wind speed in world units per second. */
-    windSpeed: number;
-    /** Monotonic discontinuity revision consumed by temporal cloud history. */
-    get historyRevision(): number;
-    /** Reset cloud temporal history after a discontinuous authored state change. */
-    invalidateHistory(): this;
+/** Public vertex formats accepted by the portable RHI without exposing its namespace. */
+type GPUDrivenVertexFormat = 'uint8x2' | 'uint8x4' | 'sint8x2' | 'sint8x4' | 'unorm8x2' | 'unorm8x4' | 'snorm8x2' | 'snorm8x4' | 'uint16x2' | 'uint16x4' | 'sint16x2' | 'sint16x4' | 'unorm16x2' | 'unorm16x4' | 'snorm16x2' | 'snorm16x4' | 'float16x2' | 'float16x4' | 'float32' | 'float32x2' | 'float32x3' | 'float32x4' | 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4' | 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4';
+/** One attribute sourced from a graph vertex buffer. */
+interface GPUDrivenVertexAttribute {
+    /** Vertex-shader input location. */
+    readonly shaderLocation: number;
+    /** Portable scalar or vector representation in the source buffer. */
+    readonly format: GPUDrivenVertexFormat;
+    /** Byte offset from the start of one vertex or instance element. */
+    readonly byteOffset: number;
 }
-/** Rayleigh, Mie, ozone, sun, and aerial-perspective configuration. */
-interface PhysicalAtmosphereOptions {
-    /** Planet radius in world units. Defaults to 6,360,000. */
-    readonly planetRadius?: number;
-    /** Atmosphere height above the planet surface. Defaults to 100,000. */
-    readonly atmosphereHeight?: number;
-    /** World-space planet center. Defaults to `(0, -planetRadius, 0)`. */
-    readonly planetCenter?: Readonly<Vector3>;
-    /** Rayleigh density scale height. Defaults to 8,000. */
-    readonly rayleighScaleHeight?: number;
-    /** Mie density scale height. Defaults to 1,200. */
-    readonly mieScaleHeight?: number;
-    /** Mie phase anisotropy in [0, 0.95]. Defaults to 0.8. */
-    readonly mieAnisotropy?: number;
-    /** Ozone layer center altitude. Defaults to 25,000. */
-    readonly ozoneCenterHeight?: number;
-    /** Ozone triangular half-width. Defaults to 15,000. */
-    readonly ozoneWidth?: number;
-    /** Solar illuminance multiplier. Defaults to 20. */
-    readonly sunIlluminance?: number;
-    /** Linear sun tint. Defaults to warm white. */
-    readonly sunColor?: Readonly<Color>;
-    /** Angular sun-disc radius in degrees. Defaults to 0.27. */
-    readonly sunAngularRadius?: number;
-    /** Maximum aerial-perspective distance. Defaults to 160,000. */
-    readonly aerialPerspectiveDistance?: number;
-    /** Ground albedo used by the multi-scattering approximation. */
-    readonly groundAlbedo?: Readonly<Color>;
+/** Immutable layout for one graph vertex-buffer slot. */
+interface GPUDrivenVertexBufferLayout {
+    /** Bytes between consecutive vertex or instance elements. */
+    readonly arrayStride: number;
+    /** Whether the buffer advances per vertex or per instance. */
+    readonly stepMode?: 'vertex' | 'instance';
+    /** Attributes sourced from this buffer slot. */
+    readonly attributes: readonly GPUDrivenVertexAttribute[];
 }
-/** Procedural weather map, cloud shell, ray-march, lighting, and temporal controls. */
-interface VolumetricCloudOptions {
-    /** Cloud-base altitude above the planet surface. Defaults to 1,500. */
-    readonly baseHeight?: number;
-    /** Cloud-layer thickness. Defaults to 8,500. */
-    readonly thickness?: number;
-    /** Horizontal weather-map scale in world units. Defaults to 120,000. */
-    readonly weatherScale?: number;
-    /** Detail-noise scale in world units. Defaults to 7,000. */
-    readonly detailScale?: number;
-    /** Cloud-light forward-scattering anisotropy. Defaults to 0.72. */
-    readonly anisotropy?: number;
-    /** Silver-lining strength in [0, 4]. Defaults to 1.25. */
-    readonly silverLining?: number;
-    /** Ambient sky-light strength in [0, 4]. Defaults to 0.65. */
-    readonly ambientStrength?: number;
-    /** Temporal history contribution in [0, 0.98]. Defaults to 0.92. */
-    readonly historyWeight?: number;
-    /** Screen-space cloud-shadow coverage in world units. Defaults to 80,000. */
-    readonly shadowDistance?: number;
+/** Direct procedural draw or GPU-authored indirect argument source. */
+type GPUDrivenDraw = Readonly<{
+    kind: 'draw';
+    vertexCount: number;
+    instanceCount?: number;
+    firstVertex?: number;
+    firstInstance?: number;
+}> | Readonly<{
+    kind: 'draw-indirect';
+    buffer: RenderGraphBufferHandle;
+    byteOffset?: number;
+}> | Readonly<{
+    kind: 'draw-indexed-indirect';
+    buffer: RenderGraphBufferHandle;
+    byteOffset?: number;
+}>;
+/** Fixed shader, raster state, and vertex-input ABI for one GPU-driven pass. */
+interface GPUDrivenRenderPassOptions {
+    /** Optional diagnostic pass name. */
+    readonly name?: string;
+    /** WebGPU storage-aware GLSL ES 3.10 graphics shader. */
+    readonly shader: StorageGraphicsShader;
+    /** Raster/depth/blend state only; resource bindings come from pass parameters. */
+    readonly pipelineState: Readonly<MaterialPipelineState>;
+    /** Immutable positional vertex-buffer ABI; omit for vertex pulling. */
+    readonly vertexLayouts?: readonly GPUDrivenVertexBufferLayout[];
+    /** Index format required by indexed indirect draws. */
+    readonly indexFormat?: 'uint16' | 'uint32';
+}
+/** Frame-scoped graph resources consumed by one GPU-driven draw. */
+interface GPUDrivenRenderPassParameters {
+    /** std140 resources in sorted uniform-buffer ABI order. */
+    readonly uniformBuffers?: readonly (UniformBuffer | UniformBufferRange)[];
+    /** Readonly storage resources in sorted storage-buffer ABI order. */
+    readonly buffers: readonly ComputeBufferBinding[];
+    /** Sampled graph textures in sorted sampled-texture ABI order. */
+    readonly textures?: readonly ComputeTextureBinding[];
+    /** Immutable samplers in sorted sampler ABI order. */
+    readonly samplers?: readonly ComputeSampler[];
+    /** Graph vertex buffers in the same order as `vertexLayouts`. */
+    readonly vertexBuffers?: readonly ComputeBufferBinding[];
+    /** Required only by `draw-indexed-indirect`. */
+    readonly indexBuffer?: ComputeBufferBinding;
+    /** Direct or GPU-authored indirect draw command. */
+    readonly draw: GPUDrivenDraw;
+    /** One or more color attachments matching continuous fragment output locations. */
+    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
+    /** Optional depth/stencil attachment and load/store policy. */
+    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
+    /** Optional dynamic viewport in physical attachment pixels. */
+    readonly viewport?: RendererViewport;
+    /** Optional dynamic scissor in physical attachment pixels. */
+    readonly scissor?: RendererViewport;
+    /** Optional unsigned dynamic stencil reference. */
+    readonly stencilReference?: number;
 }
-/** Complete physical atmosphere, cloud, and mutable weather-state configuration. */
-interface AtmosphereWeatherOptions {
-    /** Named sampling and reconstruction budget. Defaults to high. */
-    readonly quality?: AtmosphereWeatherQuality;
-    /** Mutable sun, cloud, wind, and time state. */
-    readonly state?: AtmosphereWeatherState;
-    /** Physical atmosphere constants. */
-    readonly atmosphere?: Readonly<PhysicalAtmosphereOptions>;
-    /** Volumetric clouds, or false to render atmosphere only. */
-    readonly clouds?: Readonly<VolumetricCloudOptions> | false;
-    /** Replace normal composition with one intermediate diagnostic. */
-    readonly debugView?: AtmosphereWeatherDebugView;
+/**
+ * WebGPU-only storage-aware raster pass for vertex pulling and direct/indirect procedural draws.
+ *
+ * The pass derives graph access from the immutable shader ABI. It never reads indirect arguments
+ * on the CPU and never exposes native WebGPU objects.
+ */
+declare class GPUDrivenRenderPass implements ScriptableRenderPass<GPUDrivenRenderPassParameters> {
+    /** Stable diagnostic pass name. */
+    readonly name: string;
+    /** Immutable storage-aware graphics shader. */
+    readonly shader: StorageGraphicsShader;
+    /** Material supplying raster, depth, stencil, and blend state. */
+    readonly pipelineState: Readonly<MaterialPipelineState>;
+    /** Snapshotted positional vertex-buffer ABI. */
+    readonly vertexLayouts: readonly Readonly<GPUDrivenVertexBufferLayout>[];
+    /** Index format for indexed indirect draws, when configured. */
+    readonly indexFormat: 'uint16' | 'uint32' | undefined;
+    constructor(options: Readonly<GPUDrivenRenderPassOptions>);
+    /** Declare shader resources, vertex/index/indirect inputs, and raster attachments. */
+    setup(builder: ScriptableRenderPassBuilder, parameters: GPUDrivenRenderPassParameters): void;
+    /** Apply optional dynamic state; the framework emits the prepared draw afterward. */
+    execute(context: ScriptableRenderPassContext, parameters: GPUDrivenRenderPassParameters): void;
 }
 
-/** One lower-detail geometry selected when its projected bounding radius is small enough. */
-interface GPUSceneLOD {
-    /** Indexed triangle geometry with float32 position/normal and any material-required UV/tangent streams. */
-    readonly geometry: Geometry;
-    /** Maximum projected radius in physical pixels at which this LOD is selected. */
-    readonly maximumProjectedRadius: number;
+/** Fixed pass-global bind group reserved by storage-aware scene variants. */
+declare const SCENE_STORAGE_BIND_GROUP = 3;
+/** One graph-buffer range bound to a readonly scene storage declaration. */
+interface SceneStorageBufferBinding {
+    /** Setup-scoped graph buffer read by the raster shader. */
+    readonly buffer: RenderGraphBufferHandle;
+    /** Byte offset within the graph resource, defaulting to zero. */
+    readonly byteOffset?: number;
+    /** Bound byte length, defaulting to the remaining resource range. */
+    readonly byteLength?: number;
 }
-/** One material/geometry family consumed by the GPU Scene fixed-bucket indirect path. */
-interface GPUSceneBucket {
-    /** Highest-detail indexed triangle geometry. */
-    readonly geometry: Geometry;
+/**
+ * WebGPU-only shader override for an ordinary renderer list.
+ *
+ * The shader remains GLSL ES 3.10 compiled through the engine/Naga path and must place every
+ * readonly storage binding in {@link SCENE_STORAGE_BIND_GROUP}. Groups zero through two remain
+ * available to the existing pass/material/mesh uniform and sampled-resource ABI. This contract is
+ * explicit: it does not automatically rewrite built-in Basic/PBR shader source.
+ */
+interface SceneStorageShaderVariant {
+    /** Default storage-aware shader and the canonical pass-global storage ABI. */
+    readonly shader: StorageGraphicsShader;
     /**
-     * Opaque or alpha-masked built-in metallic/roughness PBR material evaluated by the shared
-     * surface/BRDF contract. Base-color, opacity, metallic, roughness, combined
-     * metallic-roughness, occlusion, emission, and normal maps support UV0/UV1 and material UV
-     * matrices. Layered extensions, custom compilation, parallax/environment inputs, blending,
-     * alpha-to-coverage, and non-default depth modes fail closed.
+     * Optional exact per-mesh variants applied without splitting the renderer list. This preserves
+     * global transparent sorting while allowing geometry/material topology to select its compiled
+     * shader. Every mapped shader must expose the same group-three readonly-storage ABI as
+     * the default shader.
      */
-    readonly material: PBRMaterial;
-    /** Optional coarse levels ordered from smallest to largest projected-radius threshold. */
-    readonly lods?: readonly GPUSceneLOD[];
-}
-/** One concrete scene shader topology requested before the first application frame. */
-interface ClusteredMaterialVariantManifestEntry {
-    /** Exemplar carrying the exact geometry deformation and PBR material topology. */
-    readonly mesh: Mesh;
-    /** Also warm the receive-shadow variant. Defaults to the exemplar's current setting. */
-    readonly shadowed?: boolean;
-}
-/** Bounded startup manifest for clustered scene shader translation and diagnostics. */
-interface ClusteredMaterialVariantManifest {
-    /** Exact mesh/material exemplars whose native clustered variants are required at startup. */
-    readonly entries: readonly Readonly<ClusteredMaterialVariantManifestEntry>[];
-    /** Maximum unique native scene variants, including runtime discoveries. Defaults to 64. */
-    readonly maxVariants?: number;
-    /** Variants translated before yielding back to renderer initialization. Defaults to 4. */
-    readonly warmupBatchSize?: number;
+    readonly shaderByMesh?: ReadonlyMap<Mesh, StorageGraphicsShader>;
+    /** Positional ranges matching the shader's sorted readonly-storage binding order. */
+    readonly buffers: readonly Readonly<SceneStorageBufferBinding>[];
 }
-/** Construction options for the WebGPU high-end GPU Scene and Clustered Forward+ pipeline. */
-interface ClusteredForwardPlusPipelineOptions {
-    /**
-     * GPU Scene bucket families. Compatible opaque and alpha-masked meshes match by identity;
-     * other scene meshes remain renderable through the shared Forward compatibility path.
-     */
-    readonly buckets: readonly GPUSceneBucket[];
-    /**
-     * Stable fixed-bucket GPU Scene object capacity. Compatible excess PBR uses the direct native
-     * clustered lane; unsupported content uses Forward compatibility. Defaults to 16,384.
-     */
-    readonly maxObjects?: number;
-    /** GPU light-database capacity. Extra traversal-order lights are deterministically dropped. */
-    readonly maxLights?: number;
-    /** Global cluster light-index budget. Defaults to 1,048,576 indices. */
-    readonly maxLightIndices?: number;
-    /** Per-cluster allocation ceiling. Defaults to 96. */
-    readonly maxLightsPerCluster?: number;
-    /** Cluster tile width and height in physical pixels. Defaults to 32. */
-    readonly tileSize?: number;
-    /** Logarithmic view-depth slice count. Defaults to 24. */
-    readonly zSlices?: number;
-    /** Largest supported physical output width. Defaults to 2560. */
-    readonly maxViewportWidth?: number;
-    /** Largest supported physical output height. Defaults to 1440. */
-    readonly maxViewportHeight?: number;
-    /** Enable previous-frame Hi-Z occlusion. Defaults to true. */
-    readonly hiZ?: boolean;
-    /**
-     * GPU receiver-driven virtual directional shadows with arbitrary page-table remapping and
-     * camera-centered clipmaps. Requires `hiZ`; disabled by default.
-     */
-    readonly virtualShadows?: Readonly<VirtualShadowMapOptions> | false;
-    /** Bloom contribution mixed into the final display transform. Defaults to 0.7. */
-    readonly bloomStrength?: number;
-    /** Exposure multiplier applied before the ACES display transform. Defaults to 1. */
-    readonly exposure?: number;
-    /** HDR display curve. Defaults to ACES; filmic preserves a softer storm-sky shoulder. */
-    readonly toneMapping?: 'aces' | 'filmic';
-    /** GPU luminance histogram and temporal eye adaptation. Disabled by default. */
-    readonly autoExposure?: Readonly<AutoExposureOptions> | false;
-    /**
-     * Physical Rayleigh/Mie/ozone atmosphere, aerial perspective, procedural volumetric clouds,
-     * and cloud shadows. Disabled by default.
-     */
-    readonly atmosphere?: Readonly<AtmosphereWeatherOptions> | false;
-    /** Integrated temporal AA/TAAU. Disabled by default; `false` explicitly disables it. */
-    readonly temporalAA?: Readonly<TemporalAAOptions> | false;
-    /**
-     * Integrated ground-truth ambient occlusion. Disabled by default. The GPU Scene path reuses
-     * temporal motion data and therefore requires `temporalAA` when enabled.
-     */
-    readonly groundTruthAmbientOcclusion?: Readonly<GroundTruthAmbientOcclusionOptions> | false;
+/** Retained parameters consumed by {@link SceneRenderPass}. */
+interface SceneRenderPassParameters {
+    /** One setup-declared renderer list prepared through the shared mesh draw processor. */
+    readonly rendererList: RendererListHandle;
+    /** Continuous color attachments in fragment-output location order. */
+    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
+    /** Optional depth/stencil attachment shared by every draw in the list. */
+    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
+    /** Optional execution viewport in physical attachment pixels. */
+    readonly viewport?: RendererViewport;
+    /** Optional execution scissor in physical attachment pixels. */
+    readonly scissor?: RendererViewport;
+    /** Optional unsigned stencil reference set before drawing the list. */
+    readonly stencilReference?: number;
     /**
-     * Temporally accumulated screen-space diffuse global illumination. Disabled by default.
-     * The GPU Scene path reuses motion and material attributes and therefore requires `temporalAA`.
+     * Opaque scene color sampled by transmission/volume materials in this pass. The graph keeps
+     * this input distinct from the active color attachment, preventing raster feedback.
      */
-    readonly screenSpaceGlobalIllumination?: Readonly<ScreenSpaceGlobalIlluminationOptions> | false;
+    readonly opaqueTexture?: RenderGraphTextureAccessHandle;
     /**
-     * Hierarchical, temporally accumulated screen-space reflections. Disabled by default.
-     * Enabling this production path requires both `hiZ` and `temporalAA`.
+     * Screen-space ambient visibility sampled by built-in opaque PBR materials in this pass.
+     * This pass-global input is mutually exclusive with `opaqueTexture`; opaque shading
+     * consumes GTAO while later transmission shading consumes the captured opaque color.
      */
-    readonly screenSpaceReflections?: Readonly<ScreenSpaceReflectionsOptions> | false;
+    readonly ambientOcclusionTexture?: RenderGraphTextureAccessHandle;
+    /** Optional WebGPU-only storage-aware shader variant for the ordinary renderer-list path. */
+    readonly storageShaderVariant?: Readonly<SceneStorageShaderVariant>;
+}
+/**
+ * Stable scene pass backed by `SharedDrawPassParameters` and `MeshDrawProcessor`.
+ *
+ * The instance is reusable. Parameters remain caller-owned and must come from a
+ * {@link RenderPassParameterPool} when the pass is recorded every frame.
+ */
+declare class SceneRenderPass implements ScriptableRenderPass<SceneRenderPassParameters> {
+    /** Stable diagnostic pass name. */
+    readonly name: string;
+    constructor(name?: string);
+    /** Declare attachments and the renderer list without issuing commands. */
+    setup(builder: ScriptableRenderPassBuilder, parameters: SceneRenderPassParameters): void;
+    /** Apply optional dynamic state and draw the setup-declared renderer list. */
+    execute(context: ScriptableRenderPassContext, parameters: SceneRenderPassParameters): void;
+}
+
+/** Parameters consumed by {@link ShadowRenderPass}. */
+interface ShadowRenderPassParameters {
+    /** Shared culling results whose lights and visible shadow casters populate the atlas. */
+    readonly cullingResults: CullingResultsHandle;
+}
+/**
+ * Records the renderer's shared shadow-atlas pass set.
+ *
+ * A shadow atlas can expand to several graph passes, so this primitive records directly through
+ * {@link RenderPipelineContext} instead of masquerading as one `ScriptableRenderPass` node.
+ */
+declare class ShadowRenderPass {
+    /** Stable diagnostic name for shadow recording failures. */
+    readonly name: string;
+    constructor(name?: string);
+    /** Record all required atlas slices synchronously. */
+    record(context: RenderPipelineContext, parameters: Readonly<ShadowRenderPassParameters>): void;
+}
+
+/** Full selected-subresource copy parameters. Views may have different parent descriptors. */
+interface TextureCopyPassParameters {
+    /** Initialized single-sample copy source. */
+    readonly source: RenderGraphTextureAccessHandle;
+    /** Same-format, same-extent single-sample copy destination. */
+    readonly destination: RenderGraphTextureAccessHandle;
+}
+/** Portable full selected-subresource copy pass emitted through the selected RHI backend. */
+declare class TextureCopyPass implements ScriptableRenderPass<TextureCopyPassParameters> {
+    /** Stable diagnostic pass name. */
+    readonly name: string;
+    constructor(name?: string);
+    /** Declare the copy source and destination. */
+    setup(builder: ScriptableRenderPassBuilder, parameters: TextureCopyPassParameters): void;
+    /** Emit one portable full-texture copy. */
+    execute(context: ScriptableRenderPassContext, parameters: TextureCopyPassParameters): void;
+}
+
+/** GPU-time-driven dynamic-resolution controls. */
+interface DynamicResolutionOptions {
+    /** Lowest internal resolution scale. Defaults to 0.5. */
+    readonly minScale?: number;
+    /** Highest internal resolution scale. Defaults to 1. */
+    readonly maxScale?: number;
+    /** Initial scale before enough GPU samples are available. Defaults to `maxScale`. */
+    readonly initialScale?: number;
+    /** Target summed profiled Render Graph render/compute duration in milliseconds. Defaults to 16.667. */
+    readonly targetFrameTimeMs?: number;
+    /** Symmetric no-change band around the target, as a ratio. Defaults to 0.1. */
+    readonly hysteresis?: number;
+    /** EWMA contribution of the newest GPU sample. Defaults to 0.2. */
+    readonly response?: number;
+    /** Quantized scale adjustment applied at each decision. Defaults to 0.05. */
+    readonly scaleStep?: number;
+    /** Successful GPU samples required before the first decision. Defaults to 6. */
+    readonly warmupFrames?: number;
+    /** Minimum GPU samples between scale changes. Defaults to 8. */
+    readonly settlingFrames?: number;
+}
+/** Temporal anti-aliasing, temporal upscaling, and optional dynamic-resolution controls. */
+interface TemporalAAOptions {
     /**
-     * Camera-aligned froxel fog and volumetric local-light scattering. Disabled by default.
-     * This WebGPU path uses the complete 3D cluster light grid and submission-aware history.
+     * Internal scene resolution relative to the output. Values below one enable TAAU. When
+     * `dynamicResolution` is present this overrides that object's initial scale.
+     * Defaults to 1 and is constrained to the inclusive range 0.5–1.
      */
-    readonly volumetricLighting?: Readonly<VolumetricLightingOptions> | false;
-    /** Optional bounded material/deformation topology manifest translated during async creation. */
-    readonly variantManifest?: Readonly<ClusteredMaterialVariantManifest>;
+    readonly renderScale?: number;
+    /** GPU timestamp driven dynamic resolution. Omit or use false for a fixed render scale. */
+    readonly dynamicResolution?: Readonly<DynamicResolutionOptions> | false;
+    /** Maximum accepted history contribution after rejection. Defaults to 0.92. */
+    readonly historyWeight?: number;
+    /** Maximum relative previous-view-depth error. Defaults to 0.02. */
+    readonly depthThreshold?: number;
+    /** Standard-deviation extent used by YCoCg variance clipping. Defaults to 1.25. */
+    readonly varianceGamma?: number;
+    /** Resolve-only contrast restoration; history remains unsharpened. Defaults to 0.08. */
+    readonly sharpness?: number;
 }
-/** On-demand GPU counters plus current CPU database occupancy. */
-interface ClusteredForwardPlusDiagnostics {
-    /** Ordinary registered meshes currently occupying stable GPU Scene slots. */
-    readonly objectCount: number;
-    /** Visible-layer meshes routed through the shared Forward compatibility fallback. */
-    readonly fallbackObjectCount: number;
-    /** Alpha-blended PBR meshes shaded from the Clustered Forward+ light database. */
-    readonly clusteredTransparentObjectCount: number;
-    /** Non-bucket opaque PBR meshes using native clustered lighting with shared deformation. */
-    readonly clusteredDeformedObjectCount: number;
-    /** Enabled supported lights uploaded to the current GPU light database. */
-    readonly lightCount: number;
-    /** Enabled supported lights rejected by the configured light capacity. */
-    readonly droppedLightCount: number;
-    /** Objects written to a fixed visible bucket by the most recent submitted cull. */
-    readonly visibleObjectCount: number;
-    /** Objects rejected by conservative previous-frame Hi-Z occlusion. */
-    readonly occludedObjectCount: number;
-    /** Visible objects that selected a lower-detail geometry bucket. */
-    readonly lodObjectCount: number;
-    /** Light indices retained by the bounded cluster allocator. */
-    readonly clusterLightIndexCount: number;
-    /** Light-index entries truncated by per-cluster or global allocation limits. */
-    readonly clusterOverflowCount: number;
-    /** Whether conservative occlusion used a valid previous-frame Hi-Z pyramid. */
-    readonly hiZValid: boolean;
-    /** Current internal scene scale selected by fixed or dynamic temporal rendering. */
+/** Stable adaptive-resolution telemetry for renderer diagnostics. */
+interface DynamicResolutionDiagnostics {
+    /** Current internal scene resolution relative to the output. */
     readonly renderScale: number;
-    /** Smoothed profiled Render Graph render/compute GPU time, or null before samples are ready. */
+    /** EWMA of accepted profiled Render Graph GPU work, or null before the first sample. */
     readonly smoothedGPUFrameTimeMs: number | null;
-    /** Number of camera-aligned froxels injected by the latest submitted volumetric frame. */
-    readonly volumetricFroxelCount: number;
-    /** Whether the latest submitted volumetric resolve consumed temporal history. */
-    readonly volumetricHistoryUsed: boolean;
-    /** Eight-by-eight SSR trace tiles containing at least one eligible receiver. */
-    readonly screenSpaceReflectionActiveTileCount: number;
-    /** Eligible SSR receiver pixels classified by the latest submitted frame. */
-    readonly screenSpaceReflectionActivePixelCount: number;
-    /** Eligible SSR receiver pixels that produced a valid screen-space hit. */
-    readonly screenSpaceReflectionHitPixelCount: number;
-    /** Eligible SSR receiver pixels that missed or left the screen. */
-    readonly screenSpaceReflectionMissPixelCount: number;
-    /** SSR misses whose hierarchy crossing could not be validated precisely. */
-    readonly screenSpaceReflectionUncertainPixelCount: number;
-    /** SSR candidates rejected because the hit surface faced away from the ray. */
-    readonly screenSpaceReflectionBackfaceRejectedPixelCount: number;
-    /** SSR temporal pixels that consumed valid surface- or hit-domain history. */
-    readonly screenSpaceReflectionHistoryAcceptedPixelCount: number;
-    /** SSR temporal pixels that rejected every available history candidate. */
-    readonly screenSpaceReflectionHistoryRejectedPixelCount: number;
-    /** Latest adapted exposure in EV stops, or zero when auto exposure is disabled. */
-    readonly autoExposureEV: number;
-    /** Latest histogram-derived target exposure in EV stops, or zero when disabled. */
-    readonly autoExposureTargetEV: number;
-    /** Unique manifest variants translated before renderer creation completed. */
-    readonly warmedMaterialVariantCount: number;
-    /** Unique native variants admitted by the configured runtime budget. */
-    readonly activeMaterialVariantCount: number;
-    /** Runtime candidates rejected after the unique variant budget was exhausted. */
-    readonly materialVariantBudgetExceededCount: number;
-    /** Configured unique clustered scene-variant ceiling. */
-    readonly materialVariantBudget: number;
-    /** CPU translation wall time spent in asynchronous warmup. */
-    readonly materialVariantWarmupTimeMs: number;
-    /** Latest on-demand virtual-shadow counters, or null when virtual shadows are disabled. */
-    readonly virtualShadows: Readonly<VirtualShadowMapDiagnostics> | null;
+    /** Number of distinct ready GPU timeline samples accepted by this controller. */
+    readonly sampledFrameCount: number;
 }
 /**
- * WebGPU-only high-end factory combining G0 GPU Scene/Hi-Z and L0 Clustered Forward+.
+ * Temporal anti-aliasing, temporal upscaling, and GPU-time dynamic-resolution feature.
  *
- * Compatible registered bucket meshes bypass CPU frustum sorting and ordinary PreparedDraw
- * creation. Fixed indirect buckets accept opaque, unskinned, indexed triangle PBR geometry;
- * eligible deformed, layered, and globally sorted transparent PBR meshes use the native direct
- * storage-lighting lane. Material surface evaluation and the BRDF are shared with ordinary Forward
- * PBR; clustered variants replace only light-list selection and iteration. Unregistered meshes,
- * runtime-incompatible state, mixed compatibility-transparent queues, and object-capacity overflow
- * use the shared Forward path in the same frame.
- * Invalid initial bucket declarations and unsupported devices still fail closed.
+ * The feature records built-in opaque/masked motion and logarithmic view-depth data after opaque
+ * shading, resolves only opaque scene color, then lets transparent rendering and Bloom compose
+ * afterward. History uses submission-aware double buffers and is reset by camera cuts, resize,
+ * projection discontinuities, visibility gaps, or device recovery.
  */
-declare class ClusteredForwardPlusPipelineFactory implements RenderPipelineFactory {
+declare class TemporalAA implements ForwardRenderPipelineFeature {
     #private;
-    /** Stable diagnostic label for renderer initialization and graph tooling. */
-    readonly name = "GPU Scene + Clustered Forward+";
-    /** Fail-closed WebGPU capabilities, limits, and texture formats required by this profile. */
-    readonly requirements: Readonly<RenderPipelineRequirements>;
-    constructor(options: Readonly<ClusteredForwardPlusPipelineOptions>);
-    /** Create one independent renderer-local GPU Scene and clustered-lighting runtime. */
-    create(context: RenderPipelineCreateContext): Promise<RenderPipeline>;
-    /** Read on-demand GPU counters when this factory is attached to exactly one live Renderer. */
-    readDiagnostics(): Promise<Readonly<ClusteredForwardPlusDiagnostics>>;
+    readonly name = "temporal-aa";
+    readonly injectionPoint: "after-opaque";
+    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
+    constructor(options?: Readonly<TemporalAAOptions>);
+    create(): ForwardRenderPipelineFeatureRuntime;
+    /** Read adaptive-resolution state when this feature is attached to exactly one live Renderer. */
+    readDynamicResolutionDiagnostics(): Readonly<DynamicResolutionDiagnostics>;
+}
+
+/** Production controls for the WebGPU high-end hierarchical screen-space reflection path. */
+interface ScreenSpaceReflectionsOptions {
+    /** Reflection trace resolution relative to the internal scene. Defaults to 0.5. */
+    readonly resolutionScale?: number;
+    /** Maximum view-space ray length. Defaults to 80. */
+    readonly maxRayDistance?: number;
+    /** View-space surface thickness accepted as a hit. Defaults to 0.2. */
+    readonly thickness?: number;
+    /** Minimum view-space distance advanced by the finest hierarchy level. Defaults to 0.12. */
+    readonly stride?: number;
+    /** Maximum hierarchical iterations per reflected pixel. Defaults to 64. */
+    readonly maxSteps?: number;
+    /** Surfaces at or above this perceptual roughness stop tracing. Defaults to 0.85. */
+    readonly roughnessCutoff?: number;
+    /** Width of the screen-edge confidence fade in normalized coordinates. Defaults to 0.08. */
+    readonly edgeFade?: number;
+    /** Maximum accepted temporal history contribution. Defaults to 0.9. */
+    readonly historyWeight?: number;
+    /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
+    readonly depthThreshold?: number;
+    /** Linear HDR multiplier applied to SSR radiance, without scaling fallback removal. Defaults to 1. */
+    readonly intensity?: number;
+}
+
+/** Quality preset used when an individual GTAO sampling control is omitted. */
+type GroundTruthAmbientOcclusionQuality = 'low' | 'medium' | 'high' | 'ultra';
+/** Normal source used for GTAO horizon integration and edge rejection. */
+type GroundTruthAmbientOcclusionNormalSource = 'material' | 'geometry' | 'hybrid';
+/** Production controls for ground-truth ambient occlusion. */
+interface GroundTruthAmbientOcclusionOptions {
+    /** Sampling preset. Individual resolution/direction/step controls override it. Defaults to high. */
+    readonly quality?: GroundTruthAmbientOcclusionQuality;
+    /** Internal AO resolution relative to opaque rendering. Defaults to the quality preset. */
+    readonly resolutionScale?: number;
+    /** View-space horizon-search radius. Defaults to 2. */
+    readonly radius?: number;
+    /** Fraction of the radius at which distance falloff begins. Defaults to 0.6. */
+    readonly falloffStart?: number;
+    /** View-space self-intersection rejection distance. Defaults to 0.05. */
+    readonly thickness?: number;
+    /** Blend between a thin depth field and a solid occluder. Defaults to 0.5. */
+    readonly thicknessBlend?: number;
+    /** Number of rotated horizon slices per pixel. Defaults to the quality preset. */
+    readonly directionCount?: 2 | 3 | 4 | 6 | 8;
+    /** Samples evaluated on each side of a horizon slice. Defaults to the quality preset. */
+    readonly stepCount?: 3 | 4 | 5 | 6 | 8 | 10 | 12;
+    /** Contrast applied to the physically normalized visibility. Defaults to 1.2. */
+    readonly power?: number;
+    /** Occlusion intensity before contrast. Defaults to 1. */
+    readonly intensity?: number;
+    /** Angular self-occlusion bias in radians. Defaults to 0.035. */
+    readonly bias?: number;
+    /** Radius of the additional contact-occlusion lobe, relative to radius. Defaults to 0.2. */
+    readonly contactRadiusScale?: number;
+    /** Strength of the contact-occlusion lobe. Defaults to 0.35. */
+    readonly contactStrength?: number;
+    /** Normal source used by the horizon search. Defaults to hybrid. */
+    readonly normalSource?: GroundTruthAmbientOcclusionNormalSource;
+    /** Geometric-normal contribution in hybrid mode. Defaults to 0.65. */
+    readonly geometricNormalWeight?: number;
+    /** Strength of bent-normal redirection. Defaults to 1. */
+    readonly bentNormalStrength?: number;
+    /** Strength of color-aware multi-bounce diffuse AO. Defaults to 1. */
+    readonly multiBounce?: number;
+    /** View distance where AO starts fading. Defaults to 100. */
+    readonly distanceFadeStart?: number;
+    /** View distance where AO is fully disabled. Defaults to 200. */
+    readonly distanceFadeEnd?: number;
+    /** Screen-edge fade width in AO pixels. Defaults to 2. */
+    readonly edgeFadePixels?: number;
+    /** Maximum accepted temporal contribution. Defaults to 0.9. */
+    readonly historyWeight?: number;
+    /** Maximum relative reprojected view-depth error. Defaults to 0.03. */
+    readonly depthThreshold?: number;
+    /** Minimum normal agreement accepted by temporal reprojection. Defaults to 0.82. */
+    readonly normalThreshold?: number;
+}
+/**
+ * Portable production GTAO for the shared Forward pipeline.
+ *
+ * The feature records opaque depth, material attributes, and motion before shading, evaluates
+ * rotated horizon visibility at configurable resolution, applies submission-aware temporal
+ * rejection and edge-aware filtering, and binds the full-resolution result only to indirect PBR
+ * lighting. Direct lights and emission remain unoccluded.
+ */
+declare class GroundTruthAmbientOcclusion implements ForwardRenderPipelineFeature {
+    #private;
+    readonly name = "ground-truth-ambient-occlusion";
+    readonly injectionPoint: "before-opaque";
+    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
+    constructor(options?: Readonly<GroundTruthAmbientOcclusionOptions>);
+    create(): ForwardRenderPipelineFeatureRuntime;
+}
+
+/** Production controls for portable screen-space diffuse global illumination. */
+interface ScreenSpaceGlobalIlluminationOptions {
+    /** Internal tracing resolution relative to opaque rendering. Defaults to 0.5. */
+    readonly resolutionScale?: number;
+    /** Stochastic hemisphere rays traced per pixel. Defaults to 8. */
+    readonly rayCount?: 4 | 6 | 8 | 12;
+    /** Depth tests performed along each ray. Defaults to 8. */
+    readonly stepCount?: 6 | 8 | 10 | 12;
+    /** Maximum view-space ray distance. Defaults to 4. */
+    readonly maxRayDistance?: number;
+    /** View-space hit thickness used by ray/depth intersection. Defaults to 0.18. */
+    readonly thickness?: number;
+    /** Fraction of the trace distance at which contribution fading begins. Defaults to 0.72. */
+    readonly distanceFadeStart?: number;
+    /** Strength of the diffuse bounce added to linear scene color. Defaults to 1. */
+    readonly intensity?: number;
+    /** Saturation of transported radiance. Defaults to 1.1. */
+    readonly saturation?: number;
+    /** Firefly clamp for transported linear radiance. Defaults to 8. */
+    readonly maxRadiance?: number;
+    /** Maximum accepted temporal contribution. Defaults to 0.92. */
+    readonly historyWeight?: number;
+    /** Maximum relative reprojected view-depth error. Defaults to 0.025. */
+    readonly depthThreshold?: number;
+    /** Minimum normal similarity accepted by reprojection. Defaults to 0.82. */
+    readonly normalThreshold?: number;
+    /** Number of edge-aware a-trous denoise passes. Defaults to 3. */
+    readonly denoisePasses?: 1 | 2 | 3;
+}
+/**
+ * Portable production screen-space diffuse global illumination for the shared Forward pipeline.
+ *
+ * The feature traces stochastic view-space rays against opaque depth, transports linear HDR scene
+ * radiance, rejects invalid history using motion/depth/normal data, applies variance clipping and
+ * edge-aware a-trous filtering, then composites the result before transparent rendering.
+ */
+declare class ScreenSpaceGlobalIllumination implements ForwardRenderPipelineFeature {
+    #private;
+    readonly name = "screen-space-global-illumination";
+    readonly injectionPoint: "after-opaque";
+    readonly requirements: Readonly<ForwardRenderFeatureRequirements>;
+    constructor(options?: Readonly<ScreenSpaceGlobalIlluminationOptions>);
+    create(): ForwardRenderPipelineFeatureRuntime;
 }
 
-/** Process-global symbol used by optional addons to attach renderer behavior across package copies. */
-declare const RENDER_NODE_EXTENSION: unique symbol;
-/** GPU graph contribution owned by an optional scene-node addon. */
-interface RenderNodeGPUExtension {
-    /** Whether this contribution has an opaque or alpha-masked phase. */
-    readonly hasOpaqueRenderers: boolean;
-    /** Whether simulation or raster needs the current sampled scene depth. */
-    readonly requiresSampledDepth: boolean;
-    /** Whether graph work must run even when the contribution is outside the camera. */
-    readonly hasPendingWork: boolean;
-    /** Test view visibility without issuing render commands. */
-    isVisible(camera: Camera): boolean;
-    /** Record one opaque or transparent contribution through the active Render Graph. */
-    record(context: RenderPipelineContext, color: RenderGraphTextureHandle, depth: RenderGraphTextureHandle | null, drawVisible: boolean, phase: 'opaque' | 'transparent'): void;
-    /** Commit staged state only after the enclosing frame submission succeeds. */
-    frameSubmitted(frameIndex: number): void;
-    /** Roll back staged state after recording or submission is discarded. */
-    frameDiscarded(frameIndex: number): void;
+/** Named performance/quality presets for froxel reconstruction and light visibility. */
+type VolumetricLightingQuality = 'low' | 'medium' | 'high' | 'ultra';
+/** Optional integrated-volume diagnostic shown in place of the composited HDR scene. */
+type VolumetricLightingDebugView = 'none' | 'radiance' | 'transmittance';
+/** One world-space spherical local fog-density volume. */
+interface VolumetricSphereFogVolume {
+    /** Discriminant selecting spherical density evaluation. */
+    readonly shape: 'sphere';
+    /** Mutable world-space center sampled at frame-record time. */
+    readonly center: Readonly<Vector3>;
+    /** Outer sphere radius in world units. */
+    readonly radius: number;
+    /** Density added inside the volume. */
+    readonly density: number;
+    /** Single-scattering albedo tint. Defaults to the global fog albedo. */
+    readonly albedo?: Readonly<Color>;
+    /** Fraction of the radius used for a smooth edge. Defaults to 0.2. */
+    readonly edgeFalloff?: number;
 }
-/** Optional render lifecycle implemented by addon-owned scene nodes. */
-interface RenderNodeExtension {
-    /** Allocate or recover renderer-local resources before node updates and graph recording. */
-    prepareRenderer?(renderer: RendererContract): void;
-    /** Refresh camera-dependent streams before scene collection. */
-    prepareView?(camera: Camera): void;
-    /** Active GPU contribution, or `null` when this node uses ordinary scene rendering only. */
-    readonly gpu: RenderNodeGPUExtension | null;
+/** One axis-aligned world-space box local fog-density volume. */
+interface VolumetricBoxFogVolume {
+    /** Discriminant selecting axis-aligned box density evaluation. */
+    readonly shape: 'box';
+    /** Mutable world-space center sampled at frame-record time. */
+    readonly center: Readonly<Vector3>;
+    /** Mutable positive half extent sampled at frame-record time. */
+    readonly halfExtents: Readonly<Vector3>;
+    /** Density added inside the volume. */
+    readonly density: number;
+    /** Single-scattering albedo tint. Defaults to the global fog albedo. */
+    readonly albedo?: Readonly<Color>;
+    /** Fraction of the smallest half extent used for a smooth edge. Defaults to 0.2. */
+    readonly edgeFalloff?: number;
 }
-/** Read and validate an optional render-node extension without importing its addon package. */
-declare function getRenderNodeExtension(node: Node): RenderNodeExtension | null;
-
-/** One graph-buffer range consumed by a storage binding. */
-interface ComputeBufferBinding {
-    /** Frame-scoped graph buffer handle. */
-    readonly buffer: RenderGraphBufferHandle;
-    /** Four-byte-aligned offset into the buffer, defaulting to zero. */
-    readonly byteOffset?: number;
-    /** Four-byte-aligned bound range, defaulting to the remaining buffer. */
-    readonly byteLength?: number;
+/** Local fog shapes injected into the camera-aligned froxel volume. */
+type VolumetricFogVolume = VolumetricSphereFogVolume | VolumetricBoxFogVolume;
+/** Production controls for WebGPU Clustered Forward+ froxel volumetric lighting. */
+interface VolumetricLightingOptions {
+    /** Preset used for unspecified reconstruction and shadow budgets. Defaults to high. */
+    readonly quality?: VolumetricLightingQuality;
+    /** Froxel XY and reconstruction resolution relative to the internal scene. Defaults to the preset. */
+    readonly resolutionScale?: number;
+    /** Depth-aware screen-space light visibility samples in [0, 8]. Defaults to the preset. */
+    readonly shadowSteps?: number;
+    /** Global extinction density in inverse world units. Defaults to 0.025. */
+    readonly density?: number;
+    /** World-space height at and below which global density is constant. Defaults to 0. */
+    readonly baseHeight?: number;
+    /** Exponential density falloff above baseHeight. Defaults to 0.12. */
+    readonly heightFalloff?: number;
+    /** Maximum integrated view distance in world units. Defaults to 120. */
+    readonly maxDistance?: number;
+    /** Global single-scattering albedo. Defaults to a cool neutral white. */
+    readonly albedo?: Readonly<Color>;
+    /** Henyey-Greenstein anisotropy in [-0.9, 0.9]. Positive values emphasize forward scatter. */
+    readonly anisotropy?: number;
+    /** Ambient light injected into the medium. Defaults to 0.12. */
+    readonly ambientStrength?: number;
+    /** Sub-froxel stochastic sample offset strength in [0, 1]. Defaults to 1. */
+    readonly jitterStrength?: number;
+    /** Maximum temporal history contribution in [0, 0.98]. Defaults to 0.9. */
+    readonly historyWeight?: number;
+    /** Maximum relative scene-depth disagreement accepted during reprojection. Defaults to 0.04. */
+    readonly depthThreshold?: number;
+    /** Optional world-space local fog volumes, limited to 32. */
+    readonly localVolumes?: readonly VolumetricFogVolume[];
+    /** Replace normal composition with an integrated radiance or extinction diagnostic. */
+    readonly debugView?: VolumetricLightingDebugView;
 }
-/** One graph texture consumed by a sampled- or storage-texture binding. */
-interface ComputeTextureBinding {
-    /** Complete single-sample two-dimensional graph texture subresource. */
-    readonly texture: RenderGraphTextureAccessHandle;
+
+/** Luminance-metering pattern used by {@link AutoExposure}. */
+type AutoExposureMeteringMode = 'average' | 'center-weighted';
+/** GPU histogram, percentile metering, and eye-adaptation controls. */
+interface AutoExposureOptions {
+    /** Lowest log2 luminance represented by the histogram. Defaults to -12. */
+    readonly minimumLogLuminance?: number;
+    /** Highest log2 luminance represented by the histogram. Defaults to 16. */
+    readonly maximumLogLuminance?: number;
+    /** Dark-tail percentile excluded from metering in [0, 0.49]. Defaults to 0.02. */
+    readonly lowPercentile?: number;
+    /** Bright-tail percentile retained by metering in [0.51, 1]. Defaults to 0.98. */
+    readonly highPercentile?: number;
+    /** Minimum automatically selected EV in [-15, 15]. Defaults to -8. */
+    readonly minimumEV?: number;
+    /** Maximum automatically selected EV in [-15, 15]. Defaults to 8. */
+    readonly maximumEV?: number;
+    /** Exposure compensation in EV stops. Defaults to 0. */
+    readonly compensation?: number;
+    /** Middle-gray target luminance in [0.01, 0.5]. Defaults to 0.18. */
+    readonly keyValue?: number;
+    /** Adaptation speed when exposure increases, in inverse seconds. Defaults to 1.5. */
+    readonly speedUp?: number;
+    /** Adaptation speed when exposure decreases, in inverse seconds. Defaults to 3. */
+    readonly speedDown?: number;
+    /** Histogram sampling stride in pixels. Defaults to 2. */
+    readonly sampleStride?: number;
+    /** Metering pattern. Defaults to center-weighted. */
+    readonly metering?: AutoExposureMeteringMode;
 }
-/** A whole std140 uniform buffer or one explicitly selected range. */
-type ComputeUniformBufferBinding = UniformBuffer | UniformBufferRange;
-/** Direct or GPU-authored indirect dispatch dimensions. */
-type ComputeDispatch = Readonly<{
-    x: number;
-    y?: number;
-    z?: number;
-}> | Readonly<{
-    indirectBuffer: RenderGraphBufferHandle;
-    indirectOffset?: number;
-}>;
-/** Frame-scoped binding resources and dispatch parameters for one compute pass. */
-interface ComputeRenderPassParameters {
-    /** std140 uniform resources in sorted uniform-binding order. */
-    readonly uniformBuffers?: readonly ComputeUniformBufferBinding[];
-    /** Storage resources in sorted storage-buffer-binding order. */
-    readonly buffers: readonly ComputeBufferBinding[];
-    /** Texture resources in sorted sampled/storage-texture-binding order. */
-    readonly textures: readonly ComputeTextureBinding[];
-    /** Immutable samplers in sorted sampler-binding order. */
-    readonly samplers?: readonly ComputeSampler[];
-    /** Direct dimensions or an indirect argument buffer. */
-    readonly dispatch: ComputeDispatch;
+/** On-demand values written by the latest submitted exposure reduction. */
+interface AutoExposureDiagnostics {
+    /** Adapted exposure in EV stops. */
+    readonly actualEV: number;
+    /** Histogram-derived target exposure in EV stops. */
+    readonly targetEV: number;
+    /** Percentile-clipped geometric mean luminance. */
+    readonly averageLuminance: number;
+    /** Weighted histogram sample count. */
+    readonly sampleCount: number;
 }
 /**
- * Stable WebGPU compute pass backed by one immutable {@link ComputeKernel}.
+ * WebGPU histogram auto exposure with percentile clipping and submission-aware eye adaptation.
  *
- * Binding arrays are positional within their resource category and follow the shader ABI after
- * sorting by `(group, binding)`. Setup derives graph access directly from that ABI; callers cannot
- * downgrade a writable storage binding to a read dependency.
+ * The feature records after HDR post-processing and before the display transform, so Bloom and
+ * authored emissive energy share one exposure. It performs no per-frame CPU readback.
  */
-declare class ComputeRenderPass implements ScriptableRenderPass<ComputeRenderPassParameters> {
-    /** Stable diagnostic pass name. */
-    readonly name: string;
-    /** Immutable compute pipeline and shader identity. */
-    readonly kernel: ComputeKernel;
-    constructor(kernel: ComputeKernel, name?: string);
-    /** Declare storage, texture, and indirect dependencies from the immutable shader ABI. */
-    setup(builder: ScriptableRenderPassBuilder, parameters: ComputeRenderPassParameters): void;
-    /** Command emission is supplied by the framework after the pass callback returns. */
-    execute(_context: ScriptableRenderPassContext, _parameters: ComputeRenderPassParameters): void;
+declare class AutoExposure implements ForwardRenderPipelineFeature {
+    #private;
+    readonly name = "auto-exposure";
+    readonly injectionPoint: "after-post-process";
+    readonly requirements: Readonly<{
+        sampledSceneColor: true;
+        sampledDepth: false;
+        requiredCapabilities: readonly ("compute-pass" | "storage-buffer" | "storage-texture")[];
+        requiredTextureFormats: readonly (Readonly<{
+            format: "rgba16float";
+            use: "filterable-sampled";
+        }> | Readonly<{
+            format: "rgba16float";
+            use: "storage";
+        }> | Readonly<{
+            format: "rgba16float";
+            use: "color-attachment";
+        }>)[];
+        requiredLimits: Readonly<{
+            maxBindingsPerBindGroup: 5;
+            maxStorageBuffersPerShaderStage: 3;
+            maxStorageTexturesPerShaderStage: 1;
+            maxSampledTexturesPerShaderStage: 1;
+            maxComputeInvocationsPerWorkgroup: number;
+        }>;
+    }>;
+    constructor(options?: Readonly<AutoExposureOptions>);
+    create(context: RenderPipelineCreateContext): ForwardRenderPipelineFeatureRuntime;
+    /** Read the latest adapted values when attached to exactly one live renderer. */
+    readDiagnostics(): Promise<Readonly<AutoExposureDiagnostics>>;
+}
+
+/** GPU receiver-driven shadow-page allocation and directional clipmap controls. */
+interface VirtualShadowMapOptions {
+    /** Square virtual resolution for every directional clipmap level. Defaults to 4096. */
+    readonly virtualResolution?: number;
+    /** Square physical page edge in pixels. Defaults to 128. */
+    readonly pageSize?: number;
+    /** Shared physical depth-page capacity. Defaults to 32. */
+    readonly physicalPageCount?: number;
+    /** Maximum missing or invalidated pages rendered by one frame. Defaults to 16. */
+    readonly maxPageUpdatesPerFrame?: number;
+    /** Camera-centered directional clipmap levels. Defaults to 4. */
+    readonly directionalClipmapLevels?: number;
+    /** Full world-space width covered by the finest clipmap. Defaults to 64. */
+    readonly firstDirectionalClipmapExtent?: number;
+}
+/** On-demand counters copied only when diagnostics are explicitly requested. */
+interface VirtualShadowMapDiagnostics {
+    /** Unique logical pages requested by the latest submitted receiver pass. */
+    readonly requestedPageCount: number;
+    /** Physical pages whose depth contents were refreshed by the latest submitted frame. */
+    readonly renderedPageCount: number;
+    /** Requested or dirty pages postponed by the configured update/physical-page budgets. */
+    readonly deferredPageCount: number;
+    /** Valid physical residency records retained after the latest submitted allocation. */
+    readonly residentPageCount: number;
+    /** Resident physical pages remapped to another logical identity. */
+    readonly evictionCount: number;
+    /** Unique logical pages touched by changed caster coverage. */
+    readonly invalidatedPageCount: number;
+    /** Configured physical depth-page capacity. */
+    readonly physicalPageCapacity: number;
+    /** Configured camera-centered clipmap levels per directional light. */
+    readonly directionalClipmapLevelCount: number;
 }
 
-/** A keyed cache with optional object-identity lookup. */
-declare class Cache<Value = unknown> {
-    private readonly entries;
-    private objectIds;
-    /** @internal Renderer diagnostics only; not part of the public cache contract. */
-    get size(): number;
-    get(id: string): Value | undefined;
-    getObject(object: object): Value | undefined;
-    add(id: string, value: Value): void;
-    remove(id: string): void;
-    removeObject(object: object): void;
-    removeAll(): void;
-    each(callback: (value: Value, id: string) => void): void;
+/** Rendering budgets for the physical atmosphere and volumetric clouds. */
+type AtmosphereWeatherQuality = 'low' | 'medium' | 'high' | 'ultra';
+/** Optional diagnostic texture shown in place of the weather composition. */
+type AtmosphereWeatherDebugView = 'none' | 'transmittance' | 'multi-scattering' | 'sky-view' | 'weather-map' | 'cloud-radiance' | 'cloud-transmittance' | 'cloud-shadow';
+/**
+ * Mutable state sampled by the weather renderer at frame-record time.
+ *
+ * Updating these values does not recreate pipelines. Call `invalidateHistory()` after a
+ * discontinuous preset or time-of-day jump; continuous animation may update `timeSeconds` and
+ * `sunDirection` every frame without resetting history.
+ */
+declare class AtmosphereWeatherState {
+    #private;
+    /** Normalized world-space direction from the scene toward the sun. */
+    readonly sunDirection: Vector3;
+    /** Procedural weather animation time in seconds. */
+    timeSeconds: number;
+    /** Fractional cloud coverage in [0, 1]. */
+    cloudCoverage: number;
+    /** Cloud optical-density multiplier in [0, 4]. */
+    cloudDensity: number;
+    /** Cumulonimbus/storm shaping in [0, 1]. */
+    storminess: number;
+    /** Horizontal wind direction; Y is ignored. */
+    readonly windDirection: Vector3;
+    /** Wind speed in world units per second. */
+    windSpeed: number;
+    /** Monotonic discontinuity revision consumed by temporal cloud history. */
+    get historyRevision(): number;
+    /** Reset cloud temporal history after a discontinuous authored state change. */
+    invalidateHistory(): this;
 }
-
-interface ShaderParameters {
-    vs?: string;
-    fs?: string;
-    alwaysUse?: boolean;
+/** Rayleigh, Mie, ozone, sun, and aerial-perspective configuration. */
+interface PhysicalAtmosphereOptions {
+    /** Planet radius in world units. Defaults to 6,360,000. */
+    readonly planetRadius?: number;
+    /** Atmosphere height above the planet surface. Defaults to 100,000. */
+    readonly atmosphereHeight?: number;
+    /** World-space planet center. Defaults to `(0, -planetRadius, 0)`. */
+    readonly planetCenter?: Readonly<Vector3>;
+    /** Rayleigh density scale height. Defaults to 8,000. */
+    readonly rayleighScaleHeight?: number;
+    /** Mie density scale height. Defaults to 1,200. */
+    readonly mieScaleHeight?: number;
+    /** Mie phase anisotropy in [0, 0.95]. Defaults to 0.8. */
+    readonly mieAnisotropy?: number;
+    /** Ozone layer center altitude. Defaults to 25,000. */
+    readonly ozoneCenterHeight?: number;
+    /** Ozone triangular half-width. Defaults to 15,000. */
+    readonly ozoneWidth?: number;
+    /** Solar illuminance multiplier. Defaults to 20. */
+    readonly sunIlluminance?: number;
+    /** Linear sun tint. Defaults to warm white. */
+    readonly sunColor?: Readonly<Color>;
+    /** Angular sun-disc radius in degrees. Defaults to 0.27. */
+    readonly sunAngularRadius?: number;
+    /** Maximum aerial-perspective distance. Defaults to 160,000. */
+    readonly aerialPerspectiveDistance?: number;
+    /** Ground albedo used by the multi-scattering approximation. */
+    readonly groundAlbedo?: Readonly<Color>;
 }
-interface ShaderPrecisionProvider {
-    vertexPrecision: ShaderPrecision;
-    fragmentPrecision: ShaderPrecision;
+/** Procedural weather map, cloud shell, ray-march, lighting, and temporal controls. */
+interface VolumetricCloudOptions {
+    /** Cloud-base altitude above the planet surface. Defaults to 1,500. */
+    readonly baseHeight?: number;
+    /** Cloud-layer thickness. Defaults to 8,500. */
+    readonly thickness?: number;
+    /** Horizontal weather-map scale in world units. Defaults to 120,000. */
+    readonly weatherScale?: number;
+    /** Detail-noise scale in world units. Defaults to 7,000. */
+    readonly detailScale?: number;
+    /** Cloud-light forward-scattering anisotropy. Defaults to 0.72. */
+    readonly anisotropy?: number;
+    /** Silver-lining strength in [0, 4]. Defaults to 1.25. */
+    readonly silverLining?: number;
+    /** Ambient sky-light strength in [0, 4]. Defaults to 0.65. */
+    readonly ambientStrength?: number;
+    /** Temporal history contribution in [0, 0.98]. Defaults to 0.92. */
+    readonly historyWeight?: number;
+    /** Screen-space cloud-shadow coverage in world units. Defaults to 80,000. */
+    readonly shadowDistance?: number;
 }
-interface ShaderRenderer extends ShaderPrecisionProvider {
-    resourceManager: RendererResourceManager;
+/** Complete physical atmosphere, cloud, and mutable weather-state configuration. */
+interface AtmosphereWeatherOptions {
+    /** Named sampling and reconstruction budget. Defaults to high. */
+    readonly quality?: AtmosphereWeatherQuality;
+    /** Mutable sun, cloud, wind, and time state. */
+    readonly state?: AtmosphereWeatherState;
+    /** Physical atmosphere constants. */
+    readonly atmosphere?: Readonly<PhysicalAtmosphereOptions>;
+    /** Volumetric clouds, or false to render atmosphere only. */
+    readonly clouds?: Readonly<VolumetricCloudOptions> | false;
+    /** Replace normal composition with one intermediate diagnostic. */
+    readonly debugView?: AtmosphereWeatherDebugView;
 }
-/**
- * Shader类
- */
-declare class Shader {
-    readonly isShader = true;
-    readonly className = "Shader";
-    readonly id: string;
-    private _isDestroyed;
-    private _variantKey;
-    /**
-     * vs 顶点代码
-     */
-    vs: string;
-    /**
-     * vs 片段代码
-     */
-    fs: string;
-    static commonOptions: Record<string, number>;
-    /**
-     * 内部的所有shader块字符串，可以用来拼接glsl代码
-     */
-    static shaders: {
-        [k: string]: string;
-    };
-    /**
-     * 初始化
-     * @param renderer -
-     */
-    static init(renderer: ShaderPrecisionProvider): void;
-    /**
-     * Shader 缓存
-     */
-    static get cache(): Cache<Shader>;
-    /**
-     * Shader header缓存，一般不用管
-     */
-    static get headerCache(): Cache<string>;
-    /**
-     * 重置
-     */
-    static reset(): void;
+
+/** One lower-detail geometry selected when its projected bounding radius is small enough. */
+interface GPUSceneLOD {
+    /** Indexed triangle geometry with float32 position/normal and any material-required UV/tangent streams. */
+    readonly geometry: Geometry;
+    /** Maximum projected radius in physical pixels at which this LOD is selected. */
+    readonly maximumProjectedRadius: number;
+}
+/** One material/geometry family consumed by the GPU Scene fixed-bucket indirect path. */
+interface GPUSceneBucket {
+    /** Highest-detail indexed triangle geometry. */
+    readonly geometry: Geometry;
     /**
-     * 获取header缓存的key
-     * @param mesh - mesh
-     * @param material - 材质
-     * @param lightManager - lightManager
-     * @param fog - fog
-     * @param useLogDepth - 是否使用对数深度
+     * Opaque or alpha-masked built-in metallic/roughness PBR material evaluated by the shared
+     * surface/BRDF contract. Base-color, opacity, metallic, roughness, combined
+     * metallic-roughness, occlusion, emission, and normal maps support UV0/UV1 and material UV
+     * matrices. Layered extensions, custom compilation, parallax/environment inputs, blending,
+     * alpha-to-coverage, and non-default depth modes fail closed.
      */
-    static getHeaderKey(mesh: Mesh, material: MaterialInstance, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, role?: MaterialPassRole): string;
+    readonly material: PBRMaterial;
+    /** Optional coarse levels ordered from smallest to largest projected-radius threshold. */
+    readonly lods?: readonly GPUSceneLOD[];
+}
+/** One concrete scene shader topology requested before the first application frame. */
+interface ClusteredMaterialVariantManifestEntry {
+    /** Exemplar carrying the exact geometry deformation and PBR material topology. */
+    readonly mesh: Mesh;
+    /** Also warm the receive-shadow variant. Defaults to the exemplar's current setting. */
+    readonly shadowed?: boolean;
+}
+/** Bounded startup manifest for clustered scene shader translation and diagnostics. */
+interface ClusteredMaterialVariantManifest {
+    /** Exact mesh/material exemplars whose native clustered variants are required at startup. */
+    readonly entries: readonly Readonly<ClusteredMaterialVariantManifestEntry>[];
+    /** Maximum unique native scene variants, including runtime discoveries. Defaults to 64. */
+    readonly maxVariants?: number;
+    /** Variants translated before yielding back to renderer initialization. Defaults to 4. */
+    readonly warmupBatchSize?: number;
+}
+/** Construction options for the WebGPU high-end GPU Scene and Clustered Forward+ pipeline. */
+interface ClusteredForwardPlusPipelineOptions {
     /**
-     * 获取header
-     * @param mesh -
-     * @param material -
-     * @param lightManager -
-     * @param fog -
+     * GPU Scene bucket families. Compatible opaque and alpha-masked meshes match by identity;
+     * other scene meshes remain renderable through the shared Forward compatibility path.
      */
-    static getHeader(mesh: Mesh, material: MaterialInstance, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, role?: MaterialPassRole): string;
-    private static getHeaderVariant;
-    private static trackHeaderVariantKey;
-    private static trackShaderVariant;
-    private static getCommonHeader;
+    readonly buckets: readonly GPUSceneBucket[];
     /**
-     * 获取 shader
-     * @param mesh -
-     * @param material -
-     * @param isUseInstance -
-     * @param lightManager -
-     * @param fog -
-     * @param useLogDepth -
-     * @param renderer - Renderer precision provider used to build the portable shader preamble.
-     * @param linearOutput - Keep lighting in linear HDR space for floating-point scene targets.
-     * @param groundTruthAmbientOcclusion - Sample the pass-global GTAO visibility in PBR shading.
+     * Stable fixed-bucket GPU Scene object capacity. Compatible excess PBR uses the direct native
+     * clustered lane; unsupported content uses Forward compatibility. Defaults to 16,384.
      */
-    static getShader(mesh: Mesh, material: MaterialInstance, isUseInstance: boolean, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, renderer?: ShaderPrecisionProvider, linearOutput?: boolean, role?: MaterialPassRole, groundTruthAmbientOcclusion?: boolean): Shader | null;
+    readonly maxObjects?: number;
+    /** GPU light-database capacity. Extra traversal-order lights are deterministically dropped. */
+    readonly maxLights?: number;
+    /** Global cluster light-index budget. Defaults to 1,048,576 indices. */
+    readonly maxLightIndices?: number;
+    /** Per-cluster allocation ceiling. Defaults to 96. */
+    readonly maxLightsPerCluster?: number;
+    /** Cluster tile width and height in physical pixels. Defaults to 32. */
+    readonly tileSize?: number;
+    /** Logarithmic view-depth slice count. Defaults to 24. */
+    readonly zSlices?: number;
+    /** Largest supported physical output width. Defaults to 2560. */
+    readonly maxViewportWidth?: number;
+    /** Largest supported physical output height. Defaults to 1440. */
+    readonly maxViewportHeight?: number;
+    /** Enable previous-frame Hi-Z occlusion. Defaults to true. */
+    readonly hiZ?: boolean;
     /**
-     * 获取基础 shader
-     * @param material -
-     * @param isUseInstance -
-     * @param header - 已生成的 shader 宏定义
+     * GPU receiver-driven virtual directional shadows with arbitrary page-table remapping and
+     * camera-centered clipmaps. Requires `hiZ`; disabled by default.
      */
-    static getBasicShader(material: MaterialInstance, isUseInstance: boolean, header: string, renderer?: ShaderPrecisionProvider, role?: MaterialPassRole): Shader;
-    private static getNumericId;
+    readonly virtualShadows?: Readonly<VirtualShadowMapOptions> | false;
+    /** Bloom contribution mixed into the final display transform. Defaults to 0.7. */
+    readonly bloomStrength?: number;
+    /** Exposure multiplier applied before the ACES display transform. Defaults to 1. */
+    readonly exposure?: number;
+    /** HDR display curve. Defaults to ACES; filmic preserves a softer storm-sky shoulder. */
+    readonly toneMapping?: 'aces' | 'filmic';
+    /** GPU luminance histogram and temporal eye adaptation. Disabled by default. */
+    readonly autoExposure?: Readonly<AutoExposureOptions> | false;
     /**
-     * 获取自定义shader
-     * @param vs - 顶点代码
-     * @param fs - 片段代码
-     * @param cacheKey - 如果有，会以此值缓存 shader
-     * @param useHeaderCache - 是否使用 header-aware 缓存命名空间；实际 header 始终参与缓存键
+     * Physical Rayleigh/Mie/ozone atmosphere, aerial perspective, procedural volumetric clouds,
+     * and cloud shadows. Disabled by default.
      */
-    static getCustomShader(vs: string, fs: string, header?: string, cacheKey?: string, useHeaderCache?: boolean, renderer?: ShaderPrecisionProvider): Shader;
-    private static getRendererHeader;
-    private static assembleGLSL300;
+    readonly atmosphere?: Readonly<AtmosphereWeatherOptions> | false;
+    /** Integrated temporal AA/TAAU. Disabled by default; `false` explicitly disables it. */
+    readonly temporalAA?: Readonly<TemporalAAOptions> | false;
     /**
-     * 是否始终使用
+     * Integrated ground-truth ambient occlusion. Disabled by default. The GPU Scene path reuses
+     * temporal motion data and therefore requires `temporalAA` when enabled.
      */
-    alwaysUse: boolean;
+    readonly groundTruthAmbientOcclusion?: Readonly<GroundTruthAmbientOcclusionOptions> | false;
     /**
-     * @param params - 初始化参数，所有params都会复制到实例上
+     * Temporally accumulated screen-space diffuse global illumination. Disabled by default.
+     * The GPU Scene path reuses motion and material attributes and therefore requires `temporalAA`.
      */
-    constructor(params?: ShaderParameters);
+    readonly screenSpaceGlobalIllumination?: Readonly<ScreenSpaceGlobalIlluminationOptions> | false;
+    /** World-space dynamic diffuse GI with visibility-aware probes and software BVH tracing. WebGPU only; disabled by default. */
+    readonly dynamicGlobalIllumination?: Readonly<DynamicGlobalIlluminationOptions> | false;
     /**
-     * 没有被引用时销毁资源
-     * @param renderer -
-     * @returns this
+     * Hierarchical, temporally accumulated screen-space reflections. Disabled by default.
+     * Enabling this production path requires both `hiZ` and `temporalAA`.
      */
-    destroyIfNoRef(renderer: ShaderRenderer): this;
+    readonly screenSpaceReflections?: Readonly<ScreenSpaceReflectionsOptions> | false;
     /**
-     * 销毁资源
-     * @returns this
+     * Camera-aligned froxel fog and volumetric local-light scattering. Disabled by default.
+     * This WebGPU path uses the complete 3D cluster light grid and submission-aware history.
      */
-    destroy(): this;
-}
-
-/** Immutable shader and binding configuration for a fullscreen pass instance. */
-interface FullscreenRenderPassOptions {
-    /** Optional diagnostic pass name. */
-    readonly name?: string;
-    /** GLSL ES 3.00 shader with no vertex attributes. */
-    readonly shader: Shader;
-    /** Fixed raster, depth, blend, and culling state. */
-    readonly pipelineState: Readonly<MaterialPipelineState>;
-    /** std140 buffers in reflected uniform-block order. */
-    readonly uniformBuffers?: readonly UniformBuffer[];
-}
-/** Frame-scoped graph resources and dynamic state for one fullscreen draw. */
-interface FullscreenRenderPassParameters {
-    /** Sampled textures in reflected sampler order; numeric depth uses nearest sampling. */
-    readonly inputTextures: readonly RenderGraphTextureAccessHandle[];
-    /** Color attachments in fragment-output location order. */
-    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
-    /** Optional depth/stencil attachment. */
-    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
-    /** Optional execution viewport in physical attachment pixels. */
-    readonly viewport?: RendererViewport;
-    /** Optional execution scissor in physical attachment pixels. */
-    readonly scissor?: RendererViewport;
-    /** Optional unsigned stencil reference. */
-    readonly stencilReference?: number;
-}
-/**
- * Draws a `gl_VertexID` fullscreen triangle with graph textures resolved during prepare.
- *
- * The vertex shader must declare no vertex attributes. GLSL samplers and registered std140
- * blocks are matched to the fixed arrays captured by this pass instance. Color inputs use the
- * shared linear sampler; ordinary depth inputs are specialized to numeric depth and use the
- * shared non-filtering sampler on both rendering backends.
- */
-declare class FullscreenRenderPass implements ScriptableRenderPass<FullscreenRenderPassParameters> {
-    /** Stable diagnostic pass name. */
-    readonly name: string;
-    /** Shader compiled through the shared GLSL-to-backend pipeline. */
-    readonly shader: Shader;
-    /** Fixed material state for the fullscreen triangle. */
-    readonly pipelineState: Readonly<MaterialPipelineState>;
-    /** Uniform buffers in reflected block order. */
-    readonly uniformBuffers: readonly UniformBuffer[];
-    constructor(options: Readonly<FullscreenRenderPassOptions>);
-    /** Declare sampled inputs and raster attachments. */
-    setup(builder: ScriptableRenderPassBuilder, parameters: FullscreenRenderPassParameters): void;
-    /** Apply optional dynamic state; the framework emits the prepared triangle afterward. */
-    execute(context: ScriptableRenderPassContext, parameters: FullscreenRenderPassParameters): void;
-}
-/** Fullscreen graph-texture present pass with one fixed linear sampler. */
-declare class PresentRenderPass extends FullscreenRenderPass {
-    constructor(name?: string);
-}
-
-/** Public vertex formats accepted by the portable RHI without exposing its namespace. */
-type GPUDrivenVertexFormat = 'uint8x2' | 'uint8x4' | 'sint8x2' | 'sint8x4' | 'unorm8x2' | 'unorm8x4' | 'snorm8x2' | 'snorm8x4' | 'uint16x2' | 'uint16x4' | 'sint16x2' | 'sint16x4' | 'unorm16x2' | 'unorm16x4' | 'snorm16x2' | 'snorm16x4' | 'float16x2' | 'float16x4' | 'float32' | 'float32x2' | 'float32x3' | 'float32x4' | 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4' | 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4';
-/** One attribute sourced from a graph vertex buffer. */
-interface GPUDrivenVertexAttribute {
-    /** Vertex-shader input location. */
-    readonly shaderLocation: number;
-    /** Portable scalar or vector representation in the source buffer. */
-    readonly format: GPUDrivenVertexFormat;
-    /** Byte offset from the start of one vertex or instance element. */
-    readonly byteOffset: number;
-}
-/** Immutable layout for one graph vertex-buffer slot. */
-interface GPUDrivenVertexBufferLayout {
-    /** Bytes between consecutive vertex or instance elements. */
-    readonly arrayStride: number;
-    /** Whether the buffer advances per vertex or per instance. */
-    readonly stepMode?: 'vertex' | 'instance';
-    /** Attributes sourced from this buffer slot. */
-    readonly attributes: readonly GPUDrivenVertexAttribute[];
-}
-/** Direct procedural draw or GPU-authored indirect argument source. */
-type GPUDrivenDraw = Readonly<{
-    kind: 'draw';
-    vertexCount: number;
-    instanceCount?: number;
-    firstVertex?: number;
-    firstInstance?: number;
-}> | Readonly<{
-    kind: 'draw-indirect';
-    buffer: RenderGraphBufferHandle;
-    byteOffset?: number;
-}> | Readonly<{
-    kind: 'draw-indexed-indirect';
-    buffer: RenderGraphBufferHandle;
-    byteOffset?: number;
-}>;
-/** Fixed shader, raster state, and vertex-input ABI for one GPU-driven pass. */
-interface GPUDrivenRenderPassOptions {
-    /** Optional diagnostic pass name. */
-    readonly name?: string;
-    /** WebGPU storage-aware GLSL ES 3.10 graphics shader. */
-    readonly shader: StorageGraphicsShader;
-    /** Raster/depth/blend state only; resource bindings come from pass parameters. */
-    readonly pipelineState: Readonly<MaterialPipelineState>;
-    /** Immutable positional vertex-buffer ABI; omit for vertex pulling. */
-    readonly vertexLayouts?: readonly GPUDrivenVertexBufferLayout[];
-    /** Index format required by indexed indirect draws. */
-    readonly indexFormat?: 'uint16' | 'uint32';
-}
-/** Frame-scoped graph resources consumed by one GPU-driven draw. */
-interface GPUDrivenRenderPassParameters {
-    /** std140 resources in sorted uniform-buffer ABI order. */
-    readonly uniformBuffers?: readonly (UniformBuffer | UniformBufferRange)[];
-    /** Readonly storage resources in sorted storage-buffer ABI order. */
-    readonly buffers: readonly ComputeBufferBinding[];
-    /** Sampled graph textures in sorted sampled-texture ABI order. */
-    readonly textures?: readonly ComputeTextureBinding[];
-    /** Immutable samplers in sorted sampler ABI order. */
-    readonly samplers?: readonly ComputeSampler[];
-    /** Graph vertex buffers in the same order as `vertexLayouts`. */
-    readonly vertexBuffers?: readonly ComputeBufferBinding[];
-    /** Required only by `draw-indexed-indirect`. */
-    readonly indexBuffer?: ComputeBufferBinding;
-    /** Direct or GPU-authored indirect draw command. */
-    readonly draw: GPUDrivenDraw;
-    /** One or more color attachments matching continuous fragment output locations. */
-    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
-    /** Optional depth/stencil attachment and load/store policy. */
-    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
-    /** Optional dynamic viewport in physical attachment pixels. */
-    readonly viewport?: RendererViewport;
-    /** Optional dynamic scissor in physical attachment pixels. */
-    readonly scissor?: RendererViewport;
-    /** Optional unsigned dynamic stencil reference. */
-    readonly stencilReference?: number;
-}
-/**
- * WebGPU-only storage-aware raster pass for vertex pulling and direct/indirect procedural draws.
- *
- * The pass derives graph access from the immutable shader ABI. It never reads indirect arguments
- * on the CPU and never exposes native WebGPU objects.
- */
-declare class GPUDrivenRenderPass implements ScriptableRenderPass<GPUDrivenRenderPassParameters> {
-    /** Stable diagnostic pass name. */
-    readonly name: string;
-    /** Immutable storage-aware graphics shader. */
-    readonly shader: StorageGraphicsShader;
-    /** Material supplying raster, depth, stencil, and blend state. */
-    readonly pipelineState: Readonly<MaterialPipelineState>;
-    /** Snapshotted positional vertex-buffer ABI. */
-    readonly vertexLayouts: readonly Readonly<GPUDrivenVertexBufferLayout>[];
-    /** Index format for indexed indirect draws, when configured. */
-    readonly indexFormat: 'uint16' | 'uint32' | undefined;
-    constructor(options: Readonly<GPUDrivenRenderPassOptions>);
-    /** Declare shader resources, vertex/index/indirect inputs, and raster attachments. */
-    setup(builder: ScriptableRenderPassBuilder, parameters: GPUDrivenRenderPassParameters): void;
-    /** Apply optional dynamic state; the framework emits the prepared draw afterward. */
-    execute(context: ScriptableRenderPassContext, parameters: GPUDrivenRenderPassParameters): void;
+    readonly volumetricLighting?: Readonly<VolumetricLightingOptions> | false;
+    /** Optional bounded material/deformation topology manifest translated during async creation. */
+    readonly variantManifest?: Readonly<ClusteredMaterialVariantManifest>;
 }
-
-/** Fixed pass-global bind group reserved by storage-aware scene variants. */
-declare const SCENE_STORAGE_BIND_GROUP = 3;
-/** One graph-buffer range bound to a readonly scene storage declaration. */
-interface SceneStorageBufferBinding {
-    /** Setup-scoped graph buffer read by the raster shader. */
-    readonly buffer: RenderGraphBufferHandle;
-    /** Byte offset within the graph resource, defaulting to zero. */
-    readonly byteOffset?: number;
-    /** Bound byte length, defaulting to the remaining resource range. */
-    readonly byteLength?: number;
+/** On-demand GPU counters plus current CPU database occupancy. */
+interface ClusteredForwardPlusDiagnostics {
+    /** Submitted probe work, scene coverage, and bounded resource use, or null when disabled. */
+    readonly dynamicGlobalIllumination: Readonly<DynamicGlobalIlluminationDiagnostics> | null;
+    /** Ordinary registered meshes currently occupying stable GPU Scene slots. */
+    readonly objectCount: number;
+    /** Visible-layer meshes routed through the shared Forward compatibility fallback. */
+    readonly fallbackObjectCount: number;
+    /** Alpha-blended PBR meshes shaded from the Clustered Forward+ light database. */
+    readonly clusteredTransparentObjectCount: number;
+    /** Non-bucket opaque PBR meshes using native clustered lighting with shared deformation. */
+    readonly clusteredDeformedObjectCount: number;
+    /** Enabled supported lights uploaded to the current GPU light database. */
+    readonly lightCount: number;
+    /** Enabled supported lights rejected by the configured light capacity. */
+    readonly droppedLightCount: number;
+    /** Objects written to a fixed visible bucket by the most recent submitted cull. */
+    readonly visibleObjectCount: number;
+    /** Objects rejected by conservative previous-frame Hi-Z occlusion. */
+    readonly occludedObjectCount: number;
+    /** Visible objects that selected a lower-detail geometry bucket. */
+    readonly lodObjectCount: number;
+    /** Light indices retained by the bounded cluster allocator. */
+    readonly clusterLightIndexCount: number;
+    /** Light-index entries truncated by per-cluster or global allocation limits. */
+    readonly clusterOverflowCount: number;
+    /** Whether conservative occlusion used a valid previous-frame Hi-Z pyramid. */
+    readonly hiZValid: boolean;
+    /** Current internal scene scale selected by fixed or dynamic temporal rendering. */
+    readonly renderScale: number;
+    /** Smoothed profiled Render Graph render/compute GPU time, or null before samples are ready. */
+    readonly smoothedGPUFrameTimeMs: number | null;
+    /** Number of camera-aligned froxels injected by the latest submitted volumetric frame. */
+    readonly volumetricFroxelCount: number;
+    /** Whether the latest submitted volumetric resolve consumed temporal history. */
+    readonly volumetricHistoryUsed: boolean;
+    /** Eight-by-eight SSR trace tiles containing at least one eligible receiver. */
+    readonly screenSpaceReflectionActiveTileCount: number;
+    /** Eligible SSR receiver pixels classified by the latest submitted frame. */
+    readonly screenSpaceReflectionActivePixelCount: number;
+    /** Eligible SSR receiver pixels that produced a valid screen-space hit. */
+    readonly screenSpaceReflectionHitPixelCount: number;
+    /** Eligible SSR receiver pixels that missed or left the screen. */
+    readonly screenSpaceReflectionMissPixelCount: number;
+    /** SSR misses whose hierarchy crossing could not be validated precisely. */
+    readonly screenSpaceReflectionUncertainPixelCount: number;
+    /** SSR candidates rejected because the hit surface faced away from the ray. */
+    readonly screenSpaceReflectionBackfaceRejectedPixelCount: number;
+    /** SSR temporal pixels that consumed valid surface- or hit-domain history. */
+    readonly screenSpaceReflectionHistoryAcceptedPixelCount: number;
+    /** SSR temporal pixels that rejected every available history candidate. */
+    readonly screenSpaceReflectionHistoryRejectedPixelCount: number;
+    /** Latest adapted exposure in EV stops, or zero when auto exposure is disabled. */
+    readonly autoExposureEV: number;
+    /** Latest histogram-derived target exposure in EV stops, or zero when disabled. */
+    readonly autoExposureTargetEV: number;
+    /** Unique manifest variants translated before renderer creation completed. */
+    readonly warmedMaterialVariantCount: number;
+    /** Unique native variants admitted by the configured runtime budget. */
+    readonly activeMaterialVariantCount: number;
+    /** Runtime candidates rejected after the unique variant budget was exhausted. */
+    readonly materialVariantBudgetExceededCount: number;
+    /** Configured unique clustered scene-variant ceiling. */
+    readonly materialVariantBudget: number;
+    /** CPU translation wall time spent in asynchronous warmup. */
+    readonly materialVariantWarmupTimeMs: number;
+    /** Latest on-demand virtual-shadow counters, or null when virtual shadows are disabled. */
+    readonly virtualShadows: Readonly<VirtualShadowMapDiagnostics> | null;
 }
 /**
- * WebGPU-only shader override for an ordinary renderer list.
+ * WebGPU-only high-end factory combining G0 GPU Scene/Hi-Z and L0 Clustered Forward+.
  *
- * The shader remains GLSL ES 3.10 compiled through the engine/Naga path and must place every
- * readonly storage binding in {@link SCENE_STORAGE_BIND_GROUP}. Groups zero through two remain
- * available to the existing pass/material/mesh uniform and sampled-resource ABI. This contract is
- * explicit: it does not automatically rewrite built-in Basic/PBR shader source.
+ * Compatible registered bucket meshes bypass CPU frustum sorting and ordinary PreparedDraw
+ * creation. Fixed indirect buckets accept opaque, unskinned, indexed triangle PBR geometry;
+ * eligible deformed, layered, and globally sorted transparent PBR meshes use the native direct
+ * storage-lighting lane. Material surface evaluation and the BRDF are shared with ordinary Forward
+ * PBR; clustered variants replace only light-list selection and iteration. Unregistered meshes,
+ * runtime-incompatible state, mixed compatibility-transparent queues, and object-capacity overflow
+ * use the shared Forward path in the same frame.
+ * Invalid initial bucket declarations and unsupported devices still fail closed.
  */
-interface SceneStorageShaderVariant {
-    /** Default storage-aware shader and the canonical pass-global storage ABI. */
-    readonly shader: StorageGraphicsShader;
-    /**
-     * Optional exact per-mesh variants applied without splitting the renderer list. This preserves
-     * global transparent sorting while allowing geometry/material topology to select its compiled
-     * shader. Every mapped shader must expose the same group-three readonly-storage ABI as
-     * the default shader.
-     */
-    readonly shaderByMesh?: ReadonlyMap<Mesh, StorageGraphicsShader>;
-    /** Positional ranges matching the shader's sorted readonly-storage binding order. */
-    readonly buffers: readonly Readonly<SceneStorageBufferBinding>[];
+declare class ClusteredForwardPlusPipelineFactory implements RenderPipelineFactory {
+    #private;
+    /** Stable diagnostic label for renderer initialization and graph tooling. */
+    readonly name = "GPU Scene + Clustered Forward+";
+    /** Shared temporal and GPU Scene state permits one perspective-camera call per frame. */
+    readonly invocationPolicy: Readonly<RenderPipelineInvocationPolicy>;
+    /** Fail-closed WebGPU capabilities, limits, and texture formats required by this profile. */
+    readonly requirements: Readonly<RenderPipelineRequirements>;
+    constructor(options: Readonly<ClusteredForwardPlusPipelineOptions>);
+    /** Create one independent renderer-local GPU Scene and clustered-lighting runtime. */
+    create(context: RenderPipelineCreateContext): Promise<RenderPipeline>;
+    /** Set the diffuse GI contribution for all live runtimes without resetting probe convergence. */
+    setDynamicGlobalIlluminationIntensity(intensity: number): void;
+    /** Set linear sky radiance for probe misses and restart bounded convergence after a lighting change. */
+    setDynamicGlobalIlluminationEnvironment(color: Readonly<Color>): void;
+    /** Read on-demand GPU counters when this factory is attached to exactly one live Renderer. */
+    readDiagnostics(): Promise<Readonly<ClusteredForwardPlusDiagnostics>>;
 }
-/** Retained parameters consumed by {@link SceneRenderPass}. */
-interface SceneRenderPassParameters {
-    /** One setup-declared renderer list prepared through the shared mesh draw processor. */
-    readonly rendererList: RendererListHandle;
-    /** Continuous color attachments in fragment-output location order. */
-    readonly colorAttachments: readonly Readonly<RenderPipelineColorAttachment>[];
-    /** Optional depth/stencil attachment shared by every draw in the list. */
-    readonly depthStencilAttachment?: Readonly<RenderPipelineDepthStencilAttachment>;
-    /** Optional execution viewport in physical attachment pixels. */
-    readonly viewport?: RendererViewport;
-    /** Optional execution scissor in physical attachment pixels. */
-    readonly scissor?: RendererViewport;
-    /** Optional unsigned stencil reference set before drawing the list. */
-    readonly stencilReference?: number;
+
+/** Process-global symbol used by optional addons to attach renderer behavior across package copies. */
+declare const RENDER_NODE_EXTENSION: unique symbol;
+/** Portable graph work automatically recorded before transparent rendering by Forward. */
+interface RenderNodeRasterExtension {
     /**
-     * Opaque scene color sampled by transmission/volume materials in this pass. The graph keeps
-     * this input distinct from the active color attachment, preventing raster feedback.
+     * Whether this view needs the contribution. Forward also checks node/ancestor visibility
+     * and the node's camera layer. Return false when no prepass is needed to retain one scene pass.
      */
-    readonly opaqueTexture?: RenderGraphTextureAccessHandle;
+    isVisible(camera: Camera): boolean;
     /**
-     * Screen-space ambient visibility sampled by built-in opaque PBR materials in this pass.
-     * This pass-global input is mutually exclusive with `opaqueTexture`; opaque shading
-     * consumes GTAO while later transmission shading consumes the captured opaque color.
+     * Record portable graph passes using this invocation's shared camera and culling results.
+     * Promise-like return values are rejected before RHI execution. The context cannot be retained.
      */
-    readonly ambientOcclusionTexture?: RenderGraphTextureAccessHandle;
-    /** Optional WebGPU-only storage-aware shader variant for the ordinary renderer-list path. */
-    readonly storageShaderVariant?: Readonly<SceneStorageShaderVariant>;
-}
-/**
- * Stable scene pass backed by `SharedDrawPassParameters` and `MeshDrawProcessor`.
- *
- * The instance is reusable. Parameters remain caller-owned and must come from a
- * {@link RenderPassParameterPool} when the pass is recorded every frame.
- */
-declare class SceneRenderPass implements ScriptableRenderPass<SceneRenderPassParameters> {
-    /** Stable diagnostic pass name. */
-    readonly name: string;
-    constructor(name?: string);
-    /** Declare attachments and the renderer list without issuing commands. */
-    setup(builder: ScriptableRenderPassBuilder, parameters: SceneRenderPassParameters): void;
-    /** Apply optional dynamic state and draw the setup-declared renderer list. */
-    execute(context: ScriptableRenderPassContext, parameters: SceneRenderPassParameters): void;
-}
-
-/** Parameters consumed by {@link ShadowRenderPass}. */
-interface ShadowRenderPassParameters {
-    /** Shared culling results whose lights and visible shadow casters populate the atlas. */
-    readonly cullingResults: CullingResultsHandle;
-}
-/**
- * Records the renderer's shared shadow-atlas pass set.
- *
- * A shadow atlas can expand to several graph passes, so this primitive records directly through
- * {@link RenderPipelineContext} instead of masquerading as one `ScriptableRenderPass` node.
- */
-declare class ShadowRenderPass {
-    /** Stable diagnostic name for shadow recording failures. */
-    readonly name: string;
-    constructor(name?: string);
-    /** Record all required atlas slices synchronously. */
-    record(context: RenderPipelineContext, parameters: Readonly<ShadowRenderPassParameters>): void;
+    record(context: ForwardRenderFeatureContext): unknown;
+    /** Commit once per application frame after all recorded views have submitted successfully. */
+    frameSubmitted?(frameIndex: number): void;
+    /** Roll back once per discarded application frame, including a failed record callback. */
+    frameDiscarded?(frameIndex: number): void;
 }
-
-/** Full selected-subresource copy parameters. Views may have different parent descriptors. */
-interface TextureCopyPassParameters {
-    /** Initialized single-sample copy source. */
-    readonly source: RenderGraphTextureAccessHandle;
-    /** Same-format, same-extent single-sample copy destination. */
-    readonly destination: RenderGraphTextureAccessHandle;
+/** GPU graph contribution owned by an optional scene-node addon. */
+interface RenderNodeGPUExtension {
+    /** Whether this contribution has an opaque or alpha-masked phase. */
+    readonly hasOpaqueRenderers: boolean;
+    /** Whether simulation or raster needs the current sampled scene depth. */
+    readonly requiresSampledDepth: boolean;
+    /** Whether graph work must run even when the contribution is outside the camera. */
+    readonly hasPendingWork: boolean;
+    /** Test view visibility without issuing render commands. */
+    isVisible(camera: Camera): boolean;
+    /** Record one opaque or transparent contribution through the active Render Graph. */
+    record(context: RenderPipelineContext, color: RenderGraphTextureHandle, depth: RenderGraphTextureHandle | null, drawVisible: boolean, phase: 'opaque' | 'transparent'): void;
+    /** Commit staged state only after the enclosing frame submission succeeds. */
+    frameSubmitted(frameIndex: number): void;
+    /** Roll back staged state after recording or submission is discarded. */
+    frameDiscarded(frameIndex: number): void;
 }
-/** Portable full selected-subresource copy pass emitted through the selected RHI backend. */
-declare class TextureCopyPass implements ScriptableRenderPass<TextureCopyPassParameters> {
-    /** Stable diagnostic pass name. */
-    readonly name: string;
-    constructor(name?: string);
-    /** Declare the copy source and destination. */
-    setup(builder: ScriptableRenderPassBuilder, parameters: TextureCopyPassParameters): void;
-    /** Emit one portable full-texture copy. */
-    execute(context: ScriptableRenderPassContext, parameters: TextureCopyPassParameters): void;
+/** Optional render lifecycle implemented by addon-owned scene nodes. */
+interface RenderNodeExtension {
+    /** Allocate or recover renderer-local resources before node updates and graph recording. */
+    prepareRenderer?(renderer: RendererContract): void;
+    /** Refresh camera-dependent streams before scene collection. */
+    prepareView?(camera: Camera): void;
+    /** Active GPU contribution, or `null` when this node uses ordinary scene rendering only. */
+    readonly gpu: RenderNodeGPUExtension | null;
+    /** Portable Forward prepass contribution; omitted/null nodes require no raster bridge work. */
+    readonly raster?: RenderNodeRasterExtension | null;
 }
+/** Read and validate an optional render-node extension without importing its addon package. */
+declare function getRenderNodeExtension(node: Node): RenderNodeExtension | null;
 
 /** Quality and shape controls for the HDR bloom pyramid. */
 interface BloomOptions {
@@ -11458,104 +11763,55 @@ declare class PostProcessRenderPipelineFactory implements RenderPipelineFactory
     #private;
     readonly name = "post-process-forward";
     readonly requirements: Readonly<RenderPipelineRequirements>;
+    /** Camera and invocation contract inherited from the composed Forward factory. */
+    readonly invocationPolicy: Readonly<RenderPipelineInvocationPolicy>;
     constructor(options?: Readonly<PostProcessRenderPipelineOptions>);
     create(context: RenderPipelineCreateContext): RenderPipeline;
 }
 
-type CubeTextureImage = (TextureImageSource | null)[];
-interface CubeTextureParameters extends Omit<TextureParameters<CubeTextureImage>, 'target'> {
-    image?: CubeTextureImage | null;
+/** Bounded dynamic reflection capture around an existing shared rendering pipeline. */
+interface ReflectionProbePipelineOptions {
+    /** Distinct dynamic probes. At most eight are resident; materials bind a spatially relevant pair. */
+    readonly probes: readonly ReflectionProbe[];
+    /** Main view pipeline. Defaults to portable Forward. */
+    readonly pipeline?: RenderPipelineFactory;
+    /** Cube face size, a power of two in [16, 256]. Defaults to 128. */
+    readonly resolution?: number;
+    /** Roughness bands in [2, 8], bounded by log2(resolution) + 1. Defaults to five. */
+    readonly roughnessLevels?: number;
+    /** GGX importance samples per filtered pixel: 32, 64 or 128. Defaults to 64. */
+    readonly filterSamples?: 32 | 64 | 128;
+    /** Maximum scene faces recorded in one application frame, in [1, 6]. Defaults to one. */
+    readonly facesPerFrame?: number;
+    /** Maximum roughness bands recorded in one application frame, in [1, 8]. Defaults to one. */
+    readonly filterLevelsPerFrame?: number;
+    /** Hard byte budget for capture color/depth and double-buffered filtered radiance. Defaults to 64 MiB. */
+    readonly maxResidentBytes?: number;
+    /** Capture near plane. Defaults to 0.05 world units. */
+    readonly near?: number;
+    /** Capture far plane. Defaults to 100 world units. */
+    readonly far?: number;
+    /** Camera layer mask. Defaults to all layers. Local-probe receivers are excluded to avoid recursion. */
+    readonly visibility?: number;
 }
 /**
- * 立方体纹理
- * @example
- * ```ts
- * const loadQueue = new Hilo3d.LoadQueue([{
- *     src: './textures/cube/right.jpg'
- * }, {
- *     src: './textures/cube/left.jpg'
- * }, {
- *     src: './textures/cube/top.jpg'
- * }, {
- *     src: './textures/cube/bottom.jpg'
- * }, {
- *     src: './textures/cube/front.jpg'
- * }, {
- *     src: './textures/cube/back.jpg'
- * }]).on('complete', function () {
- *     const result = loadQueue.getAllContent();
- *     const skyboxMap = new Hilo3d.CubeTexture({
- *         image: result
- *     });
- *     const skybox = new Hilo3d.Mesh({
- *         geometry: new Hilo3d.BoxGeometry(),
- *         material: new Hilo3d.BasicMaterial({
- *             lightType: 'NONE',
- *             diffuse: skyboxMap
- *         })
- *     });
- *     stage.addChild(skybox);
- * });
- * ```
+ * Adds budgeted, atomic HDR reflection captures to Forward or Clustered rendering. Captures use
+ * shared scene lists, shadows, graph passes and portable raster shaders. Call probe.requestUpdate()
+ * after relevant scene/light changes. A capture spans frames and is not a simultaneous snapshot.
  */
-declare class CubeTexture extends Texture<CubeTextureImage> {
-    isCubeTexture: boolean;
-    readonly className: string;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.image`: 图片列表，共6张
-     */
-    constructor(params?: CubeTextureParameters);
-    private getImage;
-    private setImage;
-    /**
-     * 右侧的图片
-     */
-    get right(): HTMLImageElement | undefined;
-    /**
-     * 右侧的图片
-     */
-    set right(img: HTMLImageElement | undefined);
-    /**
-     * 左侧的图片
-     */
-    get left(): HTMLImageElement | undefined;
-    /**
-     * 左侧的图片
-     */
-    set left(img: HTMLImageElement | undefined);
-    /**
-     * 顶部的图片
-     */
-    get top(): HTMLImageElement | undefined;
-    /**
-     * 顶部的图片
-     */
-    set top(img: HTMLImageElement | undefined);
-    /**
-     * 底部的图片
-     */
-    get bottom(): HTMLImageElement | undefined;
-    /**
-     * 底部的图片
-     */
-    set bottom(img: HTMLImageElement | undefined);
-    /**
-     * 朝前的图片
-     */
-    get front(): HTMLImageElement | undefined;
-    /**
-     * 朝前的图片
-     */
-    set front(img: HTMLImageElement | undefined);
-    /**
-     * 朝后的图片
-     */
-    get back(): HTMLImageElement | undefined;
-    /**
-     * 朝后的图片
-     */
-    set back(img: HTMLImageElement | undefined);
+declare class ReflectionProbePipelineFactory implements RenderPipelineFactory {
+    #private;
+    /** Diagnostic name of the composed pipeline. */
+    readonly name = "Local reflection probes";
+    /** Wrapped requirements plus HDR capture formats and atlas dimensions. */
+    readonly requirements: Readonly<RenderPipelineRequirements>;
+    /** Main-view invocation limits inherited from the wrapped pipeline. */
+    readonly invocationPolicy: Readonly<RenderPipelineInvocationPolicy>;
+    /** Exact declared texture/depth bytes, excluding driver padding and the wrapped pipeline. */
+    readonly residentBytes: number;
+    constructor(options: Readonly<ReflectionProbePipelineOptions>);
+    /** Create isolated capture resources; sharing one dynamic probe across live renderers fails. */
+    create(context: RenderPipelineCreateContext): Promise<RenderPipeline>;
 }
 
 type CubeTextureLoadRequest = LoaderRequest & Partial<Omit<CubeTextureParameters, 'image' | 'type'>> & {
@@ -15020,6 +15276,6 @@ declare const math: {
     nextPowerOfTwo(value: number): number;
 };
 
-export { AmbientLight, Animation, AnimationStates, AreaLight, AtmosphereWeatherState, AutoExposure, AxisHelper, AxisNetHelper, BUILTIN_UNIFORM_BLOCK_BINDING_COUNT, BasicLoader, BasicMaterial, Bloom, BoxGeometry, Cache, Camera, Camera2D, CameraHelper, ClusteredForwardPlusPipelineFactory, Color, ColorUber, ComputeKernel, ComputeRenderPass, ComputeSampler, ComputeShader, CubeTexture, CubeTextureLoader, DEFAULT_2D_LAYER, DEFAULT_MATERIAL_PIPELINE_STATE, DEFAULT_MATERIAL_TEXTURE_CHANNELS, DataTexture, DirectionalLight, Euler, EulerNotifier, EventDispatcher, Fog, ForwardRenderPipelineFactory, Frustum, FullscreenRenderPass, GLTFExtensions_d as GLTFExtensions, GLTFLoader, GLTFParser, GPUDrivenRenderPass, Geometry, GeometryData, GeometryMaterial, GroundTruthAmbientOcclusion, HDRLoader, HiloEvent, KTXLoader, LazyTexture, Light, LightManager, LoadCache, LoadQueue, LoadState, Loader, LogLevel, Logger, MATERIAL_TEXTURE_SLOT_COUNT, MaterialAttributeSemantic, MaterialBlendPreset, MaterialCompiler, MaterialDefinition, MaterialInstance, MaterialTextureSemantic, MaterialTextureSlot, MaterialUniformSemantic, Matrix3, Matrix4, Matrix4Notifier, Mesh, MeshPicker, MorphGeometry, Node, OrbitControls, OrthographicCamera, PBRMaterial, PBRMaterialBuilder, PerspectiveCamera, Plane, PlaneGeometry, PointLight, PostProcessRenderPipelineFactory, PresentRenderPass, Quaternion, QuaternionNotifier, RENDER_NODE_EXTENSION, Ray, RenderInfo, RenderPassParameterPool, Renderer, SCENE_STORAGE_BIND_GROUP, STAGE_SYSTEM_API_VERSION, STATE_TYPES, SceneRenderPass, ScreenSpaceGlobalIllumination, Shader, ShaderMaterial, ShaderMaterialLoader, ShadowRenderPass, Skeleton, SkinnedMesh, SlicedSprite, Sphere, SphereGeometry, SphericalHarmonics3, SpotLight, Sprite, SpriteFrame, SpriteMaterial, Stage, StageSystemRegistry, StageSystemService, Std140Layout, StorageGraphicsShader, StorageLayout, TRIANGLES, TemporalAA, Text2D, Texture, TextureCopyPass, TextureLoader, Ticker, Tween, UNIFORM_BLOCK_BINDINGS, UiButton, UniformBuffer, Vector2, Vector3, Vector3Notifier, Vector4, WebGLSupport, browser, collectionEntries, constants, createEmptyGLTFRoot, createStageSystemService, createStd140Layout, createStorageGraphicsShaderFromPortable, createStorageLayout, detectBrowserFeatures, detectWebGLSupport, Hilo as engineConstants, getCollectionItem, getRenderNodeExtension, getUniformBlockBinding, isArrayCollection, isGLTFRoot, log, math, parseRadianceHDR, registerUniformBlockBinding, resolveMaterialPassDefinition, resolveMaterialPassState, semantic, util_d as util, version, webgl2 as webgl2Constants, webgl as webglConstants, webglExtensions as webglExtensionConstants };
-export type { AccessorArray, AmbientLightParameters, AnimationClip, AnimationInterpolationType, AnimationParameters, AnimationStateHandler, AnimationStateType, AnimationStatesParameters, AnimationTimeRange, AreaLightInfo, AreaLightParameters, AtmosphereWeatherDebugView, AtmosphereWeatherOptions, AtmosphereWeatherQuality, AutoExposureDiagnostics, AutoExposureMeteringMode, AutoExposureOptions, AxisAlignedBox, AxisHelperParameters, AxisNetHelperParameters, BackEaseObject, BasicLightType, BasicLoadRequest, BasicLoaderResource, BasicMaterialParameters, BasicResource, BasicResourceType, BloomOptions, Bounds, BoxGeometryParameters, BrowserFeatures, BuiltInAnimationStateType, BuiltInMaterialTextureSlotName, Camera2DParameters, CameraDepthMode, CameraHelperParameters, CameraParameters, ClusteredForwardPlusDiagnostics, ClusteredForwardPlusPipelineOptions, ClusteredMaterialVariantManifest, ClusteredMaterialVariantManifestEntry, ColorUberOptions, ComputeBufferBinding, ComputeDispatch, ComputeKernelDescriptor, ComputePipelineConstant, ComputeRenderPassParameters, ComputeSamplerAddressMode, ComputeSamplerDescriptor, ComputeSamplerFilterMode, ComputeShaderBinding, ComputeShaderDescriptor, ComputeStorageBufferAccess, ComputeStorageTextureFormat, ComputeStorageTextureViewDimension, ComputeTextureBinding, ComputeTextureSampleType, ComputeTextureViewDimension, ComputeUniformBufferBinding, CubeTextureImage, CubeTextureLoadRequest, CubeTextureParameters, CullingOptions, CullingResultsHandle, DataTextureParameters, DirectionalLightInfo, DirectionalLightParameters, DirectionalLightShadowOptions, DispatchEvent, DynamicResolutionDiagnostics, DynamicResolutionOptions, ElasticEaseObject, EulerOrder, EventListener, FogMode, FogParameters, ForwardRenderFeatureContext, ForwardRenderFeatureRequirements, ForwardRenderInjectionPoint, ForwardRenderPipelineFactoryOptions, ForwardRenderPipelineFeature, ForwardRenderPipelineFeatureRuntime, ForwardRenderPipelineResources, FullscreenRenderPassOptions, FullscreenRenderPassParameters, GLTFAccessor, GLTFAccessorResult, GLTFAccessorType, GLTFAnimation, GLTFAnimationChannel, GLTFAnimationClipsExtension, GLTFAnimationSampler, GLTFAnimationTarget, GLTFAnisotropyExtension, GLTFAsset, GLTFBoundingBoxExtension, GLTFBounds, GLTFBuffer, GLTFBufferView, GLTFBufferViewRuntime, GLTFCamera, GLTFClearcoatExtension, GLTFCollection, GLTFComponentType, GLTFExtensionHandler, GLTFExtensionHandlerRegistry, GLTFExtensionMap, GLTFExtensionMethodName, GLTFExtensionOptions, GLTFImage, GLTFIndex, GLTFIorExtension, GLTFIridescenceExtension, GLTFLoadRequest, GLTFMaterial, GLTFMaterialValue, GLTFMaterialsCommonExtension, GLTFMesh, GLTFModel, GLTFMorphTarget, GLTFNode, GLTFOrthographicCamera, GLTFPBRMetallicRoughness, GLTFPBRSpecularGlossinessExtension, GLTFParserParameters, GLTFPerspectiveCamera, GLTFPrimitive, GLTFProgram, GLTFProgressivePrimitiveState, GLTFProperty, GLTFPunctualLight, GLTFPunctualLightNodeExtension, GLTFPunctualLightsExtension, GLTFPunctualSpotLight, GLTFQuantizedAttributesExtension, GLTFResourceLoader, GLTFRoot, GLTFSampler, GLTFScene, GLTFShader, GLTFSkin, GLTFSparseAccessor, GLTFSparseIndices, GLTFSparseValues, GLTFTechnique, GLTFTechniqueBinding, GLTFTechniqueStates, GLTFTexture, GLTFTextureInfo, GLTFTextureTransformExtension, GLTFTransmissionExtension, GLTFVolumeExtension, GPUDrivenDraw, GPUDrivenRenderPassOptions, GPUDrivenRenderPassParameters, GPUDrivenVertexAttribute, GPUDrivenVertexBufferLayout, GPUDrivenVertexFormat, GPUSceneBucket, GPUSceneLOD, GeometryAttributeValue, GeometryComponentSize, GeometryDataComponentCallback, GeometryDataLike, GeometryDataParameters, GeometryDataTraverseCallback, GeometryMaterialParameters, GeometryParameters, GeometryVertexType, GroundTruthAmbientOcclusionNormalSource, GroundTruthAmbientOcclusionOptions, GroundTruthAmbientOcclusionQuality, HDRLoadRequest, ImageCrossOrigin, InstancedUniform, InterpolatedValue, InterpolationFunction, JsonPrimitive, JsonValue, KTXLoadRequest, KTXTextureOptions, LazyTextureParameters, LightGroupName, LightInfo, LightManagerParameters, LightParameters, LightShadowOptions, ListenerEntry, ListenerMap, LoadCacheFile, LoadQueueItem, LoadQueueSource, LoadStateValue, LoaderRequest, LoaderTextureOptions, LogLevelValue, MaterialAttributeSemanticName, MaterialBinding, MaterialBindingInfo, MaterialBindingMap, MaterialBlendComponent, MaterialBlendFactor, MaterialBlendOperation, MaterialBlendState, MaterialColorOrTextureInput, MaterialCompareFunction, MaterialCompileRequest, MaterialCompositing, MaterialCoverage, MaterialCullMode, MaterialDefinitionParameters, MaterialFamily, MaterialFragmentOutput, MaterialFrontFace, MaterialInstanceParameters, MaterialPassDefinition, MaterialPassFallback, MaterialPassRole, MaterialPipelineState, MaterialRenderingProfile, MaterialSemanticName, MaterialShaderModule, MaterialStencilFaceState, MaterialStencilOperation, MaterialStencilState, MaterialSurfaceDomain, MaterialTargetSignature, MaterialTexture, MaterialTextureChannel, MaterialTextureEncoding, MaterialTextureSemanticName, MaterialTextureSlotBinding, MaterialTextureSlotDefinition, MaterialTextureSlotInput, MaterialTextureValue, MaterialUniformSemanticName, MeshParameters, MeshPickerParameters, MorphGeometryParameters, MorphTargets, MutableArrayLike, MutableNumberArray, MutablePBRMaterialParameters, NetworkResourceType, NodeGetChildByCallback, NodeParameters, NodePointerEvent, NodeRaycastInfo, NodeTraverseCallback, NodeTraverseResult, NormalizedComputeWorkgroupSize, OrbitControlsOptions, OrthographicCameraParameters, PBRMaterialParameters, PBRMaterialTextureInput, PerspectiveCameraParameters, PhysicalAtmosphereOptions, PlaneGeometryParameters, Point2, Point3, PointLightInfo, PointLightParameters, PointLightShadowOptions, PointShadowCameraParameters, PostProcessRenderPipelineOptions, PreparedMaterialVariant, ProgramBindingInfo, RGPassTimestampKind, RadianceHDRImage, RayCamera, RayParameters, RenderColorEncoding, RenderGraphBufferHandle, RenderGraphBufferReadUse, RenderGraphBufferWriteUse, RenderGraphFramePlan, RenderGraphGPUTimelineStatus, RenderGraphPassHandle, RenderGraphPassTimelineSnapshot, RenderGraphResourceLifetimeSnapshot, RenderGraphTextureAccessHandle, RenderGraphTextureHandle, RenderGraphTextureViewHandle, RenderGraphTimelineSnapshot, RenderNodeExtension, RenderNodeGPUExtension, RenderPassParameterFactory, RenderPassParameterReset, RenderPipeline, RenderPipelineBufferDescriptor, RenderPipelineCapabilities, RenderPipelineCapabilityName, RenderPipelineColorAttachment, RenderPipelineColorFormat, RenderPipelineContext, RenderPipelineCreateContext, RenderPipelineDepthStencilAttachment, RenderPipelineExtent, RenderPipelineFactory, RenderPipelineHistoryTextureDescriptor, RenderPipelineHistoryTextureResources, RenderPipelineLimits, RenderPipelineOutput, RenderPipelineOutputColorAttachment, RenderPipelineOutputDepthStencilAttachment, RenderPipelineOutputResources, RenderPipelinePersistentTargetDescriptor, RenderPipelinePersistentTextureUsage, RenderPipelineRequirements, RenderPipelineShadowOptions, RenderPipelineShadowPageRegion, RenderPipelineShadowResources, RenderPipelineShadowSlice, RenderPipelineTargetResources, RenderPipelineTextureAspect, RenderPipelineTextureDescriptor, RenderPipelineTextureDimension, RenderPipelineTextureFormat, RenderPipelineTextureRequirement, RenderPipelineTextureUse, RenderPipelineTextureViewDescriptor, RenderPipelineTextureViewDimension, RenderTarget, RenderTargetColor, RenderTargetColorAttachmentOptions, RenderTargetColorAttachmentReadback, RenderTargetColorFormat, RenderTargetCompareFunction, RenderTargetDepthStencilAttachmentOptions, RenderTargetDepthStencilFormat, RenderTargetLoadOp, RenderTargetParameters, RenderTargetPresentationOptions, RenderTargetReadColorAttachmentOptions, RenderTargetSampleCount, RenderTargetSelectionOptions, RenderTargetStoreOp, RendererAdapterPowerPreference, RendererAutoOptions, RendererBackend, RendererCommonOptions, RendererContextPowerPreference, RendererContract, RendererCreateOptions, RendererExplicitOptions, RendererFeatureName, RendererFrame, RendererFrameCallback, RendererListDescriptor, RendererListHandle, RendererListQueue, RendererListSorting, RendererOptions, RendererOptionsMap, RendererRenderingProfile, RendererResourceDiagnostics, RendererResourceManager, RendererScene, RendererShadowUpdateMode, RendererSupportOptions, RendererViewport, RendererWebGL2Options, RendererWebGPUOptions, ResizableTextureImage, Resource, ResourceLoader, ResourceLoaderConstructor, ResourceRequestOptions, SceneRenderPassParameters, SceneStorageBufferBinding, SceneStorageShaderVariant, ScreenSpaceGlobalIlluminationOptions, ScreenSpaceReflectionsOptions, ScriptableRenderCommands, ScriptableRenderGraph, ScriptableRenderPass, ScriptableRenderPassBuilder, ScriptableRenderPassContext, ScriptableRenderPrepareContext, SemanticMaterial, SemanticMesh, SemanticRenderer, ShaderDefineValue, ShaderMaterialLoadRequest, ShaderMaterialParameters, ShaderMaterialRoleSource, ShaderMaterialTextureSlot, ShaderOptions, ShaderParameters, ShaderPrecision, ShaderPrecisionProvider, ShaderReadBinding, ShaderRenderer, ShaderTextureSampleType, ShaderTextureViewDimension, ShadowCameraParameters, ShadowCastingLightParameters, ShadowRenderPassParameters, Size, SkeletonParameters, SkinnedMeshParameters, SlicedSpriteInsets, SlicedSpriteParameters, SphereGeometryParameters, SpotLightCookie, SpotLightIESProfile, SpotLightInfo, SpotLightParameters, SpriteFrameParameters, SpriteFrameUpdateOptions, SpriteFramesUpdateOptions, SpriteMaterialParameters, SpriteParameters, StageBackend, StageBackendParameters, StageCommonParameters, StageParameters, StagePointerEvent, StageSystem, StageSystemDescriptor, StageSystemRuntime, StageSystemSetupContext, Std140ArrayValue, Std140FieldDefinition, Std140FieldLayout, Std140FieldValue, Std140MatrixType, Std140ScalarType, Std140Schema, Std140Type, Std140Value, Std140Values, Std140VectorType, StorageArrayDefinition, StorageBuffer, StorageBufferDescriptor, StorageBufferRange, StorageBufferReadback, StorageBufferRecoveryPolicy, StorageBufferUsage, StorageFieldLayout, StorageGraphicsShaderDescriptor, StorageMatrixType, StoragePrimitiveType, StoragePrimitiveValue, StorageScalarType, StorageSchema, StorageStructDefinition, StorageType, StorageValue, StorageValues, StorageVectorType, StorageWriteResult, SubDataUpdate, TemporalAAOptions, Text2DParameters, Text2DStyle, TextureBinding, TextureCompressionFormat, TextureCopyPassParameters, TextureCubeFace, TextureImageSource, TextureLoadRequest, TextureMipmap, TextureParameters, TexturePixelData, TextureSource, TextureSubImage, TextureUVChannel, TextureUpdateSnapshot, Tickable, ToneMappingMode, Triangle, TweenCompleteCallback, TweenEaseCollection, TweenEaseFunction, TweenEaseNoneObject, TweenEaseObject, TweenParameters, TweenProperties, TweenStartCallback, TweenUpdateCallback, TypedArray$1 as TypedArray, TypedArrayConstructor$1 as TypedArrayConstructor, UV, UiButtonFrames, UiButtonParameters, UiButtonState, UniformBufferDirtyRange, UniformBufferRange, VirtualShadowMapDiagnostics, VirtualShadowMapOptions, VolumetricBoxFogVolume, VolumetricCloudOptions, VolumetricFogVolume, VolumetricLightingDebugView, VolumetricLightingOptions, VolumetricLightingQuality, VolumetricSphereFogVolume, XYZObject };
+export { AmbientLight, Animation, AnimationBlendTree1D, AnimationClip, AnimationTrack, AreaLight, AtmosphereWeatherState, AutoExposure, AxisHelper, AxisNetHelper, BUILTIN_UNIFORM_BLOCK_BINDING_COUNT, BasicLoader, BasicMaterial, Bloom, BoxGeometry, Cache, Camera, Camera2D, CameraHelper, ClusteredForwardPlusPipelineFactory, Color, ColorUber, ComputeKernel, ComputeRenderPass, ComputeSampler, ComputeShader, CubeTexture, CubeTextureLoader, DEFAULT_2D_LAYER, DEFAULT_MATERIAL_PIPELINE_STATE, DEFAULT_MATERIAL_TEXTURE_CHANNELS, DataTexture, DirectionalLight, Euler, EulerNotifier, EventDispatcher, Fog, ForwardRenderPipelineFactory, Frustum, FullscreenRenderPass, GLTFExtensions_d as GLTFExtensions, GLTFLoader, GLTFParser, GPUDrivenRenderPass, Geometry, GeometryData, GeometryMaterial, GroundTruthAmbientOcclusion, HDRLoader, HiloEvent, KTXLoader, LazyTexture, Light, LightManager, LoadCache, LoadQueue, LoadState, Loader, LogLevel, Logger, MATERIAL_TEXTURE_SLOT_COUNT, MaterialAttributeSemantic, MaterialBlendPreset, MaterialCompiler, MaterialDefinition, MaterialInstance, MaterialTextureSemantic, MaterialTextureSlot, MaterialUniformSemantic, Matrix3, Matrix4, Matrix4Notifier, Mesh, MeshPicker, MorphGeometry, Node, OrbitControls, OrthographicCamera, PBRMaterial, PBRMaterialBuilder, PerspectiveCamera, Plane, PlaneGeometry, PointLight, PostProcessRenderPipelineFactory, PresentRenderPass, Quaternion, QuaternionNotifier, RENDER_NODE_EXTENSION, Ray, ReflectionProbe, ReflectionProbePipelineFactory, RenderInfo, RenderPassParameterPool, Renderer, SCENE_STORAGE_BIND_GROUP, STAGE_SYSTEM_API_VERSION, SceneRenderPass, ScreenSpaceGlobalIllumination, Shader, ShaderMaterial, ShaderMaterialLoader, ShadowRenderPass, Skeleton, SkinnedMesh, SlicedSprite, Sphere, SphereGeometry, SphericalHarmonics3, SpotLight, Sprite, SpriteFrame, SpriteMaterial, Stage, StageSystemRegistry, StageSystemService, Std140Layout, StorageGraphicsShader, StorageLayout, TRIANGLES, TemporalAA, Text2D, Texture, TextureCopyPass, TextureLoader, Ticker, Tween, UNIFORM_BLOCK_BINDINGS, UiButton, UniformBuffer, Vector2, Vector3, Vector3Notifier, Vector4, WebGLSupport, browser, collectionEntries, constants, createEmptyGLTFRoot, createStageSystemService, createStd140Layout, createStorageGraphicsShaderFromPortable, createStorageLayout, detectBrowserFeatures, detectWebGLSupport, Hilo as engineConstants, getCollectionItem, getRenderNodeExtension, getUniformBlockBinding, isArrayCollection, isGLTFRoot, log, math, parseRadianceHDR, registerUniformBlockBinding, resolveMaterialPassDefinition, resolveMaterialPassState, semantic, util_d as util, version, webgl2 as webgl2Constants, webgl as webglConstants, webglExtensions as webglExtensionConstants };
+export type { AccessorArray, AmbientLightParameters, AnimationBindingResolver, AnimationBlendSample, AnimationClipParameters, AnimationEvent, AnimationInterpolation, AnimationLayer, AnimationLayerParameters, AnimationMarker, AnimationMotion, AnimationParameters, AnimationPlayOptions, AnimationProperty, AnimationPropertyBinding, AnimationTrackParameters, AreaLightInfo, AreaLightParameters, AtmosphereWeatherDebugView, AtmosphereWeatherOptions, AtmosphereWeatherQuality, AutoExposureDiagnostics, AutoExposureMeteringMode, AutoExposureOptions, AxisAlignedBox, AxisHelperParameters, AxisNetHelperParameters, BackEaseObject, BasicLightType, BasicLoadRequest, BasicLoaderResource, BasicMaterialParameters, BasicResource, BasicResourceType, BloomOptions, Bounds, BoxGeometryParameters, BrowserFeatures, BuiltInMaterialTextureSlotName, Camera2DParameters, CameraDepthMode, CameraHelperParameters, CameraParameters, ClusteredForwardPlusDiagnostics, ClusteredForwardPlusPipelineOptions, ClusteredMaterialVariantManifest, ClusteredMaterialVariantManifestEntry, ColorUberOptions, ComputeBufferBinding, ComputeDispatch, ComputeKernelDescriptor, ComputePipelineConstant, ComputeRenderPassParameters, ComputeSamplerAddressMode, ComputeSamplerDescriptor, ComputeSamplerFilterMode, ComputeShaderBinding, ComputeShaderDescriptor, ComputeStorageBufferAccess, ComputeStorageTextureFormat, ComputeStorageTextureViewDimension, ComputeTextureBinding, ComputeTextureSampleType, ComputeTextureViewDimension, ComputeUniformBufferBinding, CubeTextureImage, CubeTextureLoadRequest, CubeTextureParameters, CullingOptions, CullingResultsHandle, DataTextureParameters, DirectionalLightInfo, DirectionalLightParameters, DirectionalLightShadowOptions, DispatchEvent, DynamicGlobalIlluminationDiagnostics, DynamicGlobalIlluminationOptions, DynamicResolutionDiagnostics, DynamicResolutionOptions, ElasticEaseObject, EulerOrder, EventListener, FogMode, FogParameters, ForwardRenderFeatureContext, ForwardRenderFeatureRequirements, ForwardRenderInjectionPoint, ForwardRenderPipelineFactoryOptions, ForwardRenderPipelineFeature, ForwardRenderPipelineFeatureRuntime, ForwardRenderPipelineResources, FullscreenRenderPassOptions, FullscreenRenderPassParameters, GLTFAccessor, GLTFAccessorResult, GLTFAccessorType, GLTFAnimation, GLTFAnimationChannel, GLTFAnimationClipsExtension, GLTFAnimationSampler, GLTFAnimationTarget, GLTFAnisotropyExtension, GLTFAsset, GLTFBoundingBoxExtension, GLTFBounds, GLTFBuffer, GLTFBufferView, GLTFBufferViewRuntime, GLTFCamera, GLTFClearcoatExtension, GLTFCollection, GLTFComponentType, GLTFExtensionHandler, GLTFExtensionHandlerRegistry, GLTFExtensionMap, GLTFExtensionMethodName, GLTFExtensionOptions, GLTFImage, GLTFIndex, GLTFIorExtension, GLTFIridescenceExtension, GLTFLoadRequest, GLTFMaterial, GLTFMaterialValue, GLTFMaterialsCommonExtension, GLTFMesh, GLTFModel, GLTFMorphTarget, GLTFNode, GLTFOrthographicCamera, GLTFPBRMetallicRoughness, GLTFPBRSpecularGlossinessExtension, GLTFParserParameters, GLTFPerspectiveCamera, GLTFPrimitive, GLTFProgram, GLTFProgressivePrimitiveState, GLTFProperty, GLTFPunctualLight, GLTFPunctualLightNodeExtension, GLTFPunctualLightsExtension, GLTFPunctualSpotLight, GLTFQuantizedAttributesExtension, GLTFResourceLoader, GLTFRoot, GLTFSampler, GLTFScene, GLTFShader, GLTFSkin, GLTFSparseAccessor, GLTFSparseIndices, GLTFSparseValues, GLTFTechnique, GLTFTechniqueBinding, GLTFTechniqueStates, GLTFTexture, GLTFTextureInfo, GLTFTextureTransformExtension, GLTFTransmissionExtension, GLTFVolumeExtension, GPUDrivenDraw, GPUDrivenRenderPassOptions, GPUDrivenRenderPassParameters, GPUDrivenVertexAttribute, GPUDrivenVertexBufferLayout, GPUDrivenVertexFormat, GPUSceneBucket, GPUSceneLOD, GeometryAttributeValue, GeometryComponentSize, GeometryDataComponentCallback, GeometryDataLike, GeometryDataParameters, GeometryDataTraverseCallback, GeometryMaterialParameters, GeometryParameters, GeometryVertexType, GroundTruthAmbientOcclusionNormalSource, GroundTruthAmbientOcclusionOptions, GroundTruthAmbientOcclusionQuality, HDRLoadRequest, ImageCrossOrigin, InstancedUniform, JsonPrimitive, JsonValue, KTXLoadRequest, KTXTextureOptions, LazyTextureParameters, LightGroupName, LightInfo, LightManagerParameters, LightParameters, LightShadowOptions, ListenerEntry, ListenerMap, LoadCacheFile, LoadQueueItem, LoadQueueSource, LoadStateValue, LoaderRequest, LoaderTextureOptions, LogLevelValue, MaterialAttributeSemanticName, MaterialBinding, MaterialBindingInfo, MaterialBindingMap, MaterialBlendComponent, MaterialBlendFactor, MaterialBlendOperation, MaterialBlendState, MaterialColorOrTextureInput, MaterialCompareFunction, MaterialCompileRequest, MaterialCompositing, MaterialCoverage, MaterialCullMode, MaterialDefinitionParameters, MaterialFamily, MaterialFragmentOutput, MaterialFrontFace, MaterialInstanceParameters, MaterialPassDefinition, MaterialPassFallback, MaterialPassRole, MaterialPipelineState, MaterialRenderingProfile, MaterialSemanticName, MaterialShaderModule, MaterialStencilFaceState, MaterialStencilOperation, MaterialStencilState, MaterialSurfaceDomain, MaterialTargetSignature, MaterialTexture, MaterialTextureChannel, MaterialTextureEncoding, MaterialTextureSemanticName, MaterialTextureSlotBinding, MaterialTextureSlotDefinition, MaterialTextureSlotInput, MaterialTextureValue, MaterialUniformSemanticName, MeshParameters, MeshPickerParameters, MorphGeometryParameters, MorphTargets, MutableArrayLike, MutableNumberArray, MutablePBRMaterialParameters, NetworkResourceType, NodeGetChildByCallback, NodeParameters, NodePointerEvent, NodeRaycastInfo, NodeTraverseCallback, NodeTraverseResult, NormalizedComputeWorkgroupSize, OrbitControlsOptions, OrderedRendererListDescriptor, OrthographicCameraParameters, PBRMaterialParameters, PBRMaterialTextureInput, PerspectiveCameraParameters, PhysicalAtmosphereOptions, PlaneGeometryParameters, Point2, Point3, PointLightInfo, PointLightParameters, PointLightShadowOptions, PointShadowCameraParameters, PostProcessRenderPipelineOptions, PreparedMaterialVariant, ProgramBindingInfo, RGPassTimestampKind, RadianceHDRImage, RayCamera, RayParameters, ReflectionProbeDiagnostics, ReflectionProbeOptions, ReflectionProbePipelineOptions, RenderColorEncoding, RenderGraphBufferHandle, RenderGraphBufferReadUse, RenderGraphBufferWriteUse, RenderGraphFramePlan, RenderGraphGPUTimelineStatus, RenderGraphPassHandle, RenderGraphPassTimelineSnapshot, RenderGraphResourceLifetimeSnapshot, RenderGraphTextureAccessHandle, RenderGraphTextureHandle, RenderGraphTextureViewHandle, RenderGraphTimelineSnapshot, RenderNodeExtension, RenderNodeGPUExtension, RenderNodeRasterExtension, RenderPassParameterFactory, RenderPassParameterReset, RenderPipeline, RenderPipelineBufferDescriptor, RenderPipelineCapabilities, RenderPipelineCapabilityName, RenderPipelineColorAttachment, RenderPipelineColorFormat, RenderPipelineContext, RenderPipelineCreateContext, RenderPipelineDepthStencilAttachment, RenderPipelineExtent, RenderPipelineFactory, RenderPipelineHistoryTextureDescriptor, RenderPipelineHistoryTextureResources, RenderPipelineInvocationPolicy, RenderPipelineLimits, RenderPipelineOutput, RenderPipelineOutputColorAttachment, RenderPipelineOutputDepthStencilAttachment, RenderPipelineOutputResources, RenderPipelinePersistentTargetDescriptor, RenderPipelinePersistentTextureUsage, RenderPipelineRequirements, RenderPipelineShadowOptions, RenderPipelineShadowPageRegion, RenderPipelineShadowResources, RenderPipelineShadowSlice, RenderPipelineTargetResources, RenderPipelineTextureAspect, RenderPipelineTextureDescriptor, RenderPipelineTextureDimension, RenderPipelineTextureFormat, RenderPipelineTextureRequirement, RenderPipelineTextureUse, RenderPipelineTextureViewDescriptor, RenderPipelineTextureViewDimension, RenderTarget, RenderTargetColor, RenderTargetColorAttachmentOptions, RenderTargetColorAttachmentReadback, RenderTargetColorFormat, RenderTargetCompareFunction, RenderTargetDepthStencilAttachmentOptions, RenderTargetDepthStencilFormat, RenderTargetLoadOp, RenderTargetParameters, RenderTargetPresentationOptions, RenderTargetReadColorAttachmentOptions, RenderTargetSampleCount, RenderTargetSelectionOptions, RenderTargetStoreOp, RendererAdapterPowerPreference, RendererAutoOptions, RendererBackend, RendererCommonOptions, RendererContextPowerPreference, RendererContract, RendererCreateOptions, RendererExplicitOptions, RendererFeatureName, RendererFrame, RendererFrameCallback, RendererListDescriptor, RendererListHandle, RendererListQueue, RendererListSorting, RendererOptions, RendererOptionsMap, RendererRenderingProfile, RendererResourceDiagnostics, RendererResourceManager, RendererScene, RendererShadowUpdateMode, RendererSupportOptions, RendererViewport, RendererWebGL2Options, RendererWebGPUOptions, ResizableTextureImage, Resource, ResourceLoader, ResourceLoaderConstructor, ResourceRequestOptions, SceneRenderPassParameters, SceneStorageBufferBinding, SceneStorageShaderVariant, ScreenSpaceGlobalIlluminationOptions, ScreenSpaceReflectionsOptions, ScriptableRenderCommands, ScriptableRenderGraph, ScriptableRenderPass, ScriptableRenderPassBuilder, ScriptableRenderPassContext, ScriptableRenderPrepareContext, SemanticMaterial, SemanticMesh, SemanticRenderer, ShaderDefineValue, ShaderMaterialLoadRequest, ShaderMaterialParameters, ShaderMaterialRoleSource, ShaderMaterialTextureSlot, ShaderOptions, ShaderParameters, ShaderPrecision, ShaderPrecisionProvider, ShaderReadBinding, ShaderRenderer, ShaderTextureSampleType, ShaderTextureViewDimension, ShadowCameraParameters, ShadowCastingLightParameters, ShadowRenderPassParameters, Size, SkeletonParameters, SkinnedMeshParameters, SlicedSpriteInsets, SlicedSpriteParameters, SphereGeometryParameters, SpotLightCookie, SpotLightIESProfile, SpotLightInfo, SpotLightParameters, SpriteFrameParameters, SpriteFrameUpdateOptions, SpriteFramesUpdateOptions, SpriteMaterialParameters, SpriteParameters, StageBackend, StageBackendParameters, StageCommonParameters, StageParameters, StagePointerEvent, StageSystem, StageSystemDescriptor, StageSystemRuntime, StageSystemSetupContext, Std140ArrayValue, Std140FieldDefinition, Std140FieldLayout, Std140FieldValue, Std140MatrixType, Std140ScalarType, Std140Schema, Std140Type, Std140Value, Std140Values, Std140VectorType, StorageArrayDefinition, StorageBuffer, StorageBufferDescriptor, StorageBufferRange, StorageBufferReadback, StorageBufferRecoveryPolicy, StorageBufferUsage, StorageFieldLayout, StorageGraphicsShaderDescriptor, StorageMatrixType, StoragePrimitiveType, StoragePrimitiveValue, StorageScalarType, StorageSchema, StorageStructDefinition, StorageType, StorageValue, StorageValues, StorageVectorType, StorageWriteResult, SubDataUpdate, TemporalAAOptions, Text2DParameters, Text2DStyle, TextureBinding, TextureCompressionFormat, TextureCopyPassParameters, TextureCubeFace, TextureImageSource, TextureLoadRequest, TextureMipmap, TextureParameters, TexturePixelData, TextureSource, TextureSubImage, TextureUVChannel, TextureUpdateSnapshot, Tickable, ToneMappingMode, Triangle, TweenCompleteCallback, TweenEaseCollection, TweenEaseFunction, TweenEaseNoneObject, TweenEaseObject, TweenParameters, TweenProperties, TweenStartCallback, TweenUpdateCallback, TypedArray$1 as TypedArray, TypedArrayConstructor$1 as TypedArrayConstructor, UV, UiButtonFrames, UiButtonParameters, UiButtonState, UniformBufferDirtyRange, UniformBufferRange, VirtualShadowMapDiagnostics, VirtualShadowMapOptions, VolumetricBoxFogVolume, VolumetricCloudOptions, VolumetricFogVolume, VolumetricLightingDebugView, VolumetricLightingOptions, VolumetricLightingQuality, VolumetricSphereFogVolume, XYZObject };
 //# sourceMappingURL=Hilo3d.d.ts.map