hilo3d 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/Hilo3d.d.ts

@@ -3156,6 +3156,8 @@ interface GeometryDataParameters {
     bufferViewId?: string;
     stride?: number;
     offset?: number;
+    /** Advance this stream once per vertex or once per direct-draw instance. */
+    stepMode?: 'vertex' | 'instance';
 }
 interface SubDataUpdate {
     readonly revision: number;
@@ -3199,6 +3201,10 @@ declare class GeometryData {
     get isDirty(): boolean;
     set isDirty(value: boolean);
     bufferViewId: string;
+    private _stepMode;
+    /** Portable RHI vertex-buffer stepping policy. */
+    get stepMode(): 'vertex' | 'instance';
+    set stepMode(value: 'vertex' | 'instance');
     readonly id: string;
     private _data;
     private readonly subDataList;
@@ -3761,6 +3767,65 @@ declare class Frustum {
     intersectsSphere(sphere: Sphere): boolean;
 }
 
+/**
+ * 颜色类
+ */
+declare class Color extends Vector4 {
+    /**
+     * 类名
+     */
+    className: string;
+    isColor: boolean;
+    /**
+     * r
+     */
+    get r(): number;
+    set r(value: number);
+    /**
+     * g
+     */
+    get g(): number;
+    set g(value: number);
+    /**
+     * b
+     */
+    get b(): number;
+    set b(value: number);
+    /**
+     * a
+     */
+    get a(): number;
+    set a(value: number);
+    /**
+     * @param r -
+     * @param g -
+     * @param b -
+     * @param a -
+     */
+    constructor(r?: number, g?: number, b?: number, a?: number);
+    /**
+     * 转换到数组
+     * @param array - 转换到的数组
+     * @param offset - 数组偏移值
+     */
+    toRGBArray(array?: number[], offset?: number): number[];
+    /**
+     * 从数组赋值
+     * @param array - 数组
+     * @param offset - 数组偏移值
+     */
+    fromUintArray(array: ArrayLike<number>, offset?: number): this;
+    /**
+     * 从十六进制值赋值
+     * @param hex - 颜色的十六进制值，可以以下形式："#ff9966", "ff9966", "#f96", "f96", 0xff9966
+     */
+    fromHEX(hex: string | number): this;
+    /**
+     * 转16进制
+     */
+    toHEX(): string;
+}
+
 type TextureImageSource = HTMLImageElement | HTMLCanvasElement | ImageBitmap | ImageData | OffscreenCanvas | HTMLVideoElement | TexturePixelData;
 type TextureUVChannel = 0 | 1;
 /**
@@ -4033,65 +4098,6 @@ declare class Texture<Image = TextureImageSource> extends EventDispatcher {
     clone(): Texture<Image>;
 }
 
-/**
- * 颜色类
- */
-declare class Color extends Vector4 {
-    /**
-     * 类名
-     */
-    className: string;
-    isColor: boolean;
-    /**
-     * r
-     */
-    get r(): number;
-    set r(value: number);
-    /**
-     * g
-     */
-    get g(): number;
-    set g(value: number);
-    /**
-     * b
-     */
-    get b(): number;
-    set b(value: number);
-    /**
-     * a
-     */
-    get a(): number;
-    set a(value: number);
-    /**
-     * @param r -
-     * @param g -
-     * @param b -
-     * @param a -
-     */
-    constructor(r?: number, g?: number, b?: number, a?: number);
-    /**
-     * 转换到数组
-     * @param array - 转换到的数组
-     * @param offset - 数组偏移值
-     */
-    toRGBArray(array?: number[], offset?: number): number[];
-    /**
-     * 从数组赋值
-     * @param array - 数组
-     * @param offset - 数组偏移值
-     */
-    fromUintArray(array: ArrayLike<number>, offset?: number): this;
-    /**
-     * 从十六进制值赋值
-     * @param hex - 颜色的十六进制值，可以以下形式："#ff9966", "ff9966", "#f96", "f96", 0xff9966
-     */
-    fromHEX(hex: string | number): this;
-    /**
-     * 转16进制
-     */
-    toHEX(): string;
-}
-
 type Std140ScalarType = 'float' | 'int' | 'uint' | 'bool';
 type Std140VectorType = 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4' | 'uvec2' | 'uvec3' | 'uvec4' | 'bvec2' | 'bvec3' | 'bvec4';
 type Std140MatrixType = 'mat2' | 'mat3' | 'mat4' | 'mat2x3' | 'mat2x4' | 'mat3x2' | 'mat3x4' | 'mat4x2' | 'mat4x3';
@@ -4298,6 +4304,8 @@ interface LightParameters extends NodeParameters {
     quadraticAttenuation?: number;
     range?: number;
     isDirty?: boolean;
+    /** Receiver-layer mask used by clustered lighting; defaults to every layer. */
+    lightLayerMask?: number;
 }
 /** Parameters shared only by light kinds that implement shadows on every rendering backend. */
 interface ShadowCastingLightParameters extends LightParameters {
@@ -4320,6 +4328,10 @@ declare class Light extends Node {
      * 光强度
      */
     amount: number;
+    private lightLayerMaskValue;
+    /** Receiver-layer mask evaluated independently from camera/node visibility. */
+    get lightLayerMask(): number;
+    set lightLayerMask(value: number);
     /**
      * 是否开启灯光
      */
@@ -4478,8 +4490,36 @@ declare class AreaLight extends Light {
     set ltcTexture2(texture: DataTexture | null);
 }
 
-interface DirectionalLightParameters extends ShadowCastingLightParameters {
+/**
+ * Directional-light shadow controls.
+ *
+ * Values greater than one for `cascadeCount` enable camera-relative cascaded shadow maps. Manual
+ * `cameraInfo` bounds remain available for the single-cascade compatibility path.
+ */
+interface DirectionalLightShadowOptions extends LightShadowOptions {
+    /** Number of camera-frustum cascades. Defaults to `1`; the supported range is 1–4. */
+    cascadeCount?: number;
+    /**
+     * Blend between uniform (`0`) and logarithmic (`1`) cascade split placement. Defaults to
+     * `0.5`.
+     */
+    cascadeSplitLambda?: number;
+    /** Maximum view-space shadow distance. Defaults to the active camera far plane. */
+    cascadeMaxDistance?: number;
+    /** Fraction of each cascade interval blended into the following cascade. Defaults to `0.1`. */
+    cascadeBlend?: number;
+    /** Snap automatic cascade projections to shadow texels. Defaults to `true`. */
+    stabilizeCascades?: boolean;
+    /**
+     * Art-directed contrast applied to filtered directional-shadow occlusion. `1` preserves the
+     * physically sampled visibility, values above `1` deepen partial PCF coverage, and `0`
+     * disables the visible shadow contribution. Defaults to `1`; the supported range is 0–4.
+     */
+    shadowStrength?: number;
+}
+interface DirectionalLightParameters extends Omit<ShadowCastingLightParameters, 'shadow'> {
     direction?: Vector3;
+    shadow?: DirectionalLightShadowOptions | null;
 }
 /**
  * 平行光
@@ -4489,6 +4529,9 @@ declare class DirectionalLight extends Light {
     isDirectionalLight: boolean;
     className: string;
     direction: Vector3;
+    /** Directional shadow options, including the optional cascaded-shadow controls. */
+    get shadow(): DirectionalLightShadowOptions | null;
+    set shadow(value: DirectionalLightShadowOptions | null);
     /**
      * @param params - 创建对象的属性参数。可包含此类的所有属性。
      * - `params.color`: 光颜色
@@ -4530,6 +4573,28 @@ interface SpotLightParameters extends ShadowCastingLightParameters {
     direction?: Vector3;
     cutoff?: number;
     outerCutoff?: number;
+    /** Optional analytic projected cookie for native clustered lighting. */
+    cookie?: Readonly<SpotLightCookie> | null;
+    /** Optional normalized axial IES fit for native clustered lighting. */
+    iesProfile?: Readonly<SpotLightIESProfile> | null;
+}
+/** Analytic projected cookie carried by the high-end clustered-light ABI. */
+interface SpotLightCookie {
+    /** Projected half-extent on the light plane. */
+    readonly scale?: readonly [number, number];
+    /** Projected cookie-center offset. */
+    readonly offset?: readonly [number, number];
+    /** Cookie multiplier. Defaults to one. */
+    readonly intensity?: number;
+    /** Edge transition as a fraction of the cookie extent. Defaults to 0.1. */
+    readonly softness?: number;
+}
+/** Compact axial fit for an imported IES photometric profile. */
+interface SpotLightIESProfile {
+    /** Candela multiplier after normalization. Defaults to one. */
+    readonly intensity?: number;
+    /** Axial concentration exponent. Defaults to one. */
+    readonly exponent?: number;
 }
 /**
  * 聚光灯
@@ -4539,6 +4604,16 @@ declare class SpotLight extends Light {
     isSpotLight: boolean;
     className: string;
     direction: Vector3;
+    private cookieValue;
+    private iesProfileValue;
+    /** Analytic projected cookie used by native clustered Spot lighting. */
+    get cookie(): Readonly<Required<SpotLightCookie>> | null;
+    /** Analytic projected cookie used by native clustered Spot lighting. */
+    set cookie(value: Readonly<SpotLightCookie> | null);
+    /** Normalized axial IES fit used by native clustered Spot lighting. */
+    get iesProfile(): Readonly<Required<SpotLightIESProfile>> | null;
+    /** Normalized axial IES fit used by native clustered Spot lighting. */
+    set iesProfile(value: Readonly<SpotLightIESProfile> | null);
     private cutoffCosine;
     private cutoffDegrees;
     /**
@@ -4707,6 +4782,342 @@ declare class LightManager {
     getShadowMapCount(type: LightGroupName): number;
 }
 
+/** Semantic material pass requested by a render pipeline. */
+type MaterialPassRole = 'forward' | 'depth-only' | 'shadow-caster' | 'motion-vector' | 'material-attributes' | 'picking' | `user:${string}`;
+/** High-level surface family. It selects a surface evaluator, not a render pass. */
+type MaterialFamily = 'basic' | 'pbr' | 'geometry' | 'sprite' | 'custom';
+/** Domain in which a material definition can be evaluated. */
+type MaterialSurfaceDomain = 'surface' | 'unlit' | 'post-process';
+/** Portable profile supported by a material definition. */
+type MaterialRenderingProfile = 'portable' | 'webgpu-high-end';
+/** How a missing semantic role is handled before an RHI frame begins. */
+type MaterialPassFallback = 'required' | 'safe-fallback' | 'skip';
+/** Stable fragment-output contract selected by a semantic pass. */
+type MaterialFragmentOutput = 'color' | 'depth-only' | 'motion-vector' | 'material-attributes' | 'picking';
+/** Backend-neutral fixed-function state names. */
+type MaterialFrontFace = 'ccw' | 'cw';
+type MaterialCullMode = 'none' | 'front' | 'back';
+type MaterialCompareFunction = 'never' | 'less' | 'equal' | 'less-equal' | 'greater' | 'not-equal' | 'greater-equal' | 'always';
+type MaterialStencilOperation = 'keep' | 'zero' | 'replace' | 'invert' | 'increment-clamp' | 'decrement-clamp' | 'increment-wrap' | 'decrement-wrap';
+type MaterialBlendOperation = 'add' | 'subtract' | 'reverse-subtract' | 'min' | 'max';
+type MaterialBlendFactor = 'zero' | 'one' | 'src' | 'one-minus-src' | 'src-alpha' | 'one-minus-src-alpha' | 'dst' | 'one-minus-dst' | 'dst-alpha' | 'one-minus-dst-alpha' | 'src-alpha-saturated' | 'constant' | 'one-minus-constant';
+interface MaterialBlendComponent {
+    readonly operation: MaterialBlendOperation;
+    readonly srcFactor: MaterialBlendFactor;
+    readonly dstFactor: MaterialBlendFactor;
+}
+interface MaterialBlendState {
+    readonly color: Readonly<MaterialBlendComponent>;
+    readonly alpha: Readonly<MaterialBlendComponent>;
+}
+interface MaterialStencilFaceState {
+    readonly compare: MaterialCompareFunction;
+    readonly failOp: MaterialStencilOperation;
+    readonly depthFailOp: MaterialStencilOperation;
+    readonly passOp: MaterialStencilOperation;
+}
+interface MaterialStencilState {
+    readonly front: Readonly<MaterialStencilFaceState>;
+    readonly back: Readonly<MaterialStencilFaceState>;
+    readonly readMask: number;
+    readonly writeMask: number;
+    readonly reference: number;
+}
+/** Immutable pipeline state owned by one semantic material pass. */
+interface MaterialPipelineState {
+    /** Line-list rasterization request. Geometry normalization remains a renderer concern. */
+    readonly wireframe: boolean;
+    readonly frontFace: MaterialFrontFace;
+    readonly cullMode: MaterialCullMode;
+    readonly depthTest: boolean;
+    readonly depthWrite: boolean;
+    readonly depthCompare: MaterialCompareFunction;
+    readonly depthRange: readonly [number, number];
+    readonly blend?: Readonly<MaterialBlendState>;
+    readonly stencil?: Readonly<MaterialStencilState>;
+    readonly alphaToCoverage: boolean;
+}
+/** Coverage controls whether a surface exists; it is independent of transmission and blending. */
+type MaterialCoverage = Readonly<{
+    mode: 'opaque';
+}> | Readonly<{
+    mode: 'mask';
+    cutoff: number;
+}> | Readonly<{
+    mode: 'alpha-to-coverage';
+    cutoff: number;
+}>;
+/** Compositing controls how a shaded result combines with the existing color target. */
+type MaterialCompositing = Readonly<{
+    mode: 'opaque';
+}> | Readonly<{
+    mode: 'alpha-blend';
+    premultiplied: boolean;
+}> | Readonly<{
+    mode: 'additive';
+    premultiplied: boolean;
+}> | Readonly<{
+    mode: 'custom';
+    blend: Readonly<MaterialBlendState>;
+    depthWrite: boolean;
+}>;
+/** Encoding applied to a sampled texture before it enters the surface evaluator. */
+type MaterialTextureEncoding = 'linear' | 'srgb' | 'data';
+/** Stable four-channel source mapping. */
+type MaterialTextureChannel = 'r' | 'g' | 'b' | 'a' | 'zero' | 'one';
+interface MaterialTextureSlotDefinition {
+    readonly name: string;
+    readonly index: number;
+    readonly encoding: MaterialTextureEncoding;
+    readonly channels: readonly [
+        MaterialTextureChannel,
+        MaterialTextureChannel,
+        MaterialTextureChannel,
+        MaterialTextureChannel
+    ];
+    readonly sampleType: 'float' | 'depth' | 'sint' | 'uint';
+    readonly viewDimension: '2d' | 'cube' | '3d' | '2d-array';
+    readonly presence: 'static' | 'fallback';
+    /** UV sets for which this definition compiled vertex inputs. */
+    readonly uvSets: readonly (0 | 1)[];
+}
+/** Per-instance texture binding. Transform and UV selection belong to the slot, not the material. */
+interface MaterialTextureSlotBinding {
+    readonly texture: Texture<unknown>;
+    readonly uvSet: 0 | 1;
+    readonly transform: Matrix3 | null;
+    readonly encoding: MaterialTextureEncoding;
+    readonly channels: MaterialTextureSlotDefinition['channels'];
+}
+interface MaterialTextureSlotInput {
+    readonly texture: Texture<unknown>;
+    readonly uvSet?: 0 | 1;
+    readonly transform?: Matrix3 | null;
+    readonly encoding?: MaterialTextureEncoding;
+    readonly channels?: MaterialTextureSlotDefinition['channels'];
+}
+/** Shader source recipe retained across device loss; it never contains a native pipeline. */
+type MaterialShaderModule = Readonly<{
+    kind: 'builtin';
+    family: Exclude<MaterialFamily, 'custom'>;
+}> | Readonly<{
+    kind: 'glsl';
+    vertexSource: string;
+    fragmentSource: string;
+    sourceRevision: string;
+}>;
+interface MaterialPassDefinition {
+    readonly role: MaterialPassRole;
+    readonly shader: MaterialShaderModule;
+    readonly fragmentOutput: MaterialFragmentOutput;
+    readonly state: Readonly<MaterialPipelineState>;
+    readonly fallback: MaterialPassFallback;
+}
+interface MaterialDefinitionParameters {
+    readonly id: string;
+    readonly family: MaterialFamily;
+    readonly domain?: MaterialSurfaceDomain;
+    readonly shaderRevision?: string;
+    readonly staticFeatures?: Readonly<Record<string, number>>;
+    readonly coverage?: MaterialCoverage;
+    readonly compositing?: MaterialCompositing;
+    readonly instanceOverrides?: Readonly<{
+        coverage?: boolean;
+        compositing?: boolean;
+    }>;
+    readonly textureSlots?: readonly Readonly<MaterialTextureSlotDefinition>[];
+    readonly passes: readonly Readonly<MaterialPassDefinition>[];
+    readonly profiles?: readonly MaterialRenderingProfile[];
+}
+/**
+ * Immutable material structure shared by any number of instances.
+ *
+ * Definitions own shader topology, texture layout, supported pass roles and pass state. Runtime
+ * parameters and texture identities deliberately live in {@link MaterialInstance}.
+ */
+declare class MaterialDefinition {
+    #private;
+    readonly id: string;
+    readonly family: MaterialFamily;
+    readonly domain: MaterialSurfaceDomain;
+    readonly shaderRevision: string;
+    readonly staticFeatures: Readonly<Record<string, number>>;
+    readonly coverage: MaterialCoverage;
+    readonly compositing: MaterialCompositing;
+    readonly instanceOverrides: Readonly<{
+        coverage: boolean;
+        compositing: boolean;
+    }>;
+    readonly textureSlots: readonly Readonly<MaterialTextureSlotDefinition>[];
+    readonly profiles: readonly MaterialRenderingProfile[];
+    readonly passes: readonly Readonly<MaterialPassDefinition>[];
+    constructor(parameters: Readonly<MaterialDefinitionParameters>);
+    getPass(role: MaterialPassRole): Readonly<MaterialPassDefinition> | null;
+    getTextureSlot(name: string): Readonly<MaterialTextureSlotDefinition> | null;
+}
+declare const DEFAULT_MATERIAL_PIPELINE_STATE: Readonly<MaterialPipelineState>;
+declare const DEFAULT_MATERIAL_TEXTURE_CHANNELS: readonly ["r", "g", "b", "a"];
+
+/** Stable vertex-attribute semantics understood by the shared renderer. */
+declare const MaterialAttributeSemantic: Readonly<{
+    readonly POSITION: "POSITION";
+    readonly NORMAL: "NORMAL";
+    readonly TANGENT: "TANGENT";
+    readonly TEXCOORD_0: "TEXCOORD_0";
+    readonly TEXCOORD_1: "TEXCOORD_1";
+    readonly COLOR_0: "COLOR_0";
+    readonly SKIN_INDICES: "SKININDICES";
+    readonly SKIN_WEIGHTS: "SKINWEIGHTS";
+}>;
+/** Stable non-texture uniform semantics understood by the shared renderer. */
+declare const MaterialUniformSemantic: Readonly<{
+    readonly LOCAL: "LOCAL";
+    readonly MODEL: "MODEL";
+    readonly OBJECT_ID_COLOR: "OBJECTIDCOLOR";
+    readonly VIEW: "VIEW";
+    readonly PROJECTION: "PROJECTION";
+    readonly VIEW_PROJECTION: "VIEWPROJECTION";
+    readonly MODEL_VIEW: "MODELVIEW";
+    readonly MODEL_VIEW_PROJECTION: "MODELVIEWPROJECTION";
+    readonly MODEL_INVERSE: "MODELINVERSE";
+    readonly VIEW_INVERSE: "VIEWINVERSE";
+    readonly VIEW_INVERSE_NORMAL: "VIEWINVERSEINVERSETRANSPOSE";
+    readonly PROJECTION_INVERSE: "PROJECTIONINVERSE";
+    readonly MODEL_VIEW_INVERSE: "MODELVIEWINVERSE";
+    readonly MODEL_VIEW_PROJECTION_INVERSE: "MODELVIEWPROJECTIONINVERSE";
+    readonly MODEL_NORMAL: "MODELINVERSETRANSPOSE";
+    readonly MODEL_VIEW_NORMAL: "MODELVIEWINVERSETRANSPOSE";
+    readonly VIEWPORT: "VIEWPORT";
+    readonly CAMERA_FAR: "CAMERAFAR";
+    readonly CAMERA_NEAR: "CAMERANEAR";
+    readonly CAMERA_TYPE: "CAMERATYPE";
+    readonly CAMERA_POSITION: "CAMERAPOSITION";
+    readonly RENDERER_SIZE: "RENDERERSIZE";
+    readonly JOINT_MATRIX: "JOINTMATRIX";
+    readonly NORMAL_MAP_SCALE: "NORMALMAPSCALE";
+    readonly DIFFUSE_COLOR: "DIFFUSE";
+    readonly SPECULAR_COLOR: "SPECULAR";
+    readonly AMBIENT_COLOR: "AMBIENT";
+    readonly EMISSION_COLOR: "EMISSION";
+    readonly OPACITY: "TRANSPARENCY";
+    readonly OCCLUSION_STRENGTH: "OCCLUSIONSTRENGTH";
+    readonly SHININESS: "SHININESS";
+    readonly SPECULAR_ENV_MATRIX: "SPECULARENVMATRIX";
+    readonly REFLECTIVITY: "REFLECTIVITY";
+    readonly REFRACT_RATIO: "REFRACTRATIO";
+    readonly REFRACTIVITY: "REFRACTIVITY";
+    readonly LOG_DEPTH: "LOGDEPTH";
+    readonly AMBIENT_LIGHTS_COLOR: "AMBIENTLIGHTSCOLOR";
+    readonly DIRECTIONAL_LIGHTS_COLOR: "DIRECTIONALLIGHTSCOLOR";
+    readonly DIRECTIONAL_LIGHTS_INFO: "DIRECTIONALLIGHTSINFO";
+    readonly DIRECTIONAL_LIGHTS_SHADOW_MAP_SIZE: "DIRECTIONALLIGHTSSHADOWMAPSIZE";
+    readonly DIRECTIONAL_LIGHTS_SHADOW_BIAS: "DIRECTIONALLIGHTSSHADOWBIAS";
+    readonly DIRECTIONAL_LIGHT_SPACE_MATRIX: "DIRECTIONALLIGHTSPACEMATRIX";
+    readonly DIRECTIONAL_CASCADE_SPLITS: "DIRECTIONALCASCADESPLITS";
+    readonly DIRECTIONAL_CASCADE_PARAMS: "DIRECTIONALCASCADEPARAMS";
+    readonly DIRECTIONAL_CASCADE_MATRICES: "DIRECTIONALCASCADEMATRICES";
+    readonly POINT_LIGHTS_POSITION: "POINTLIGHTSPOS";
+    readonly POINT_LIGHTS_COLOR: "POINTLIGHTSCOLOR";
+    readonly POINT_LIGHTS_INFO: "POINTLIGHTSINFO";
+    readonly POINT_LIGHTS_RANGE: "POINTLIGHTSRANGE";
+    readonly POINT_LIGHTS_SHADOW_BIAS: "POINTLIGHTSSHADOWBIAS";
+    readonly POINT_LIGHT_SPACE_MATRIX: "POINTLIGHTSPACEMATRIX";
+    readonly POINT_LIGHT_CAMERA: "POINTLIGHTCAMERA";
+    readonly SPOT_LIGHTS_POSITION: "SPOTLIGHTSPOS";
+    readonly SPOT_LIGHTS_DIRECTION: "SPOTLIGHTSDIR";
+    readonly SPOT_LIGHTS_COLOR: "SPOTLIGHTSCOLOR";
+    readonly SPOT_LIGHTS_CUTOFFS: "SPOTLIGHTSCUTOFFS";
+    readonly SPOT_LIGHTS_INFO: "SPOTLIGHTSINFO";
+    readonly SPOT_LIGHTS_RANGE: "SPOTLIGHTSRANGE";
+    readonly SPOT_LIGHTS_SHADOW_MAP_SIZE: "SPOTLIGHTSSHADOWMAPSIZE";
+    readonly SPOT_LIGHTS_SHADOW_BIAS: "SPOTLIGHTSSHADOWBIAS";
+    readonly SPOT_LIGHT_SPACE_MATRIX: "SPOTLIGHTSPACEMATRIX";
+    readonly AREA_LIGHTS_POSITION: "AREALIGHTSPOS";
+    readonly AREA_LIGHTS_COLOR: "AREALIGHTSCOLOR";
+    readonly AREA_LIGHTS_WIDTH: "AREALIGHTSWIDTH";
+    readonly AREA_LIGHTS_HEIGHT: "AREALIGHTSHEIGHT";
+    readonly FOG_COLOR: "FOGCOLOR";
+    readonly FOG_INFO: "FOGINFO";
+    readonly SHADOW_ATLAS_SIZE: "SHADOWATLASSIZE";
+    readonly SHADOW_ATLAS_RECTS: "SHADOWATLASRECTS";
+    readonly POINT_SHADOW_MATRICES: "POINTSHADOWMATRICES";
+    readonly POSITION_DECODE_MATRIX: "POSITIONDECODEMAT";
+    readonly NORMAL_DECODE_MATRIX: "NORMALDECODEMAT";
+    readonly UV_DECODE_MATRIX: "UVDECODEMAT";
+    readonly UV1_DECODE_MATRIX: "UV1DECODEMAT";
+    readonly BASE_COLOR: "BASECOLOR";
+    readonly EMISSION_FACTOR: "EMISSIONFACTOR";
+    readonly METALLIC: "METALLIC";
+    readonly ROUGHNESS: "ROUGHNESS";
+    readonly DIFFUSE_ENV_INTENSITY: "DIFFUSEENVINTENSITY";
+    readonly SPECULAR_ENV_INTENSITY: "SPECULARENVINTENSITY";
+    readonly SPECULAR_ENV_MIP_COUNT: "SPECULARENVMAPMIPCOUNT";
+    readonly DIFFUSE_ENV_SPHERICAL_HARMONICS: "DIFFUSEENVSPHEREHARMONICS3";
+    readonly GLOSSINESS: "GLOSSINESS";
+    readonly ALPHA_CUTOFF: "ALPHACUTOFF";
+    readonly TEMPORAL_REACTIVE_FACTOR: "TEMPORALREACTIVEFACTOR";
+    readonly MORPH_WEIGHTS: "MORPHWEIGHTS";
+    readonly CLEARCOAT_FACTOR: "CLEARCOATFACTOR";
+    readonly CLEARCOAT_ROUGHNESS_FACTOR: "CLEARCOATROUGHNESSFACTOR";
+    readonly CLEARCOAT_NORMAL_SCALE: "CLEARCOATNORMALSCALE";
+    readonly ANISOTROPY_STRENGTH: "ANISOTROPYSTRENGTH";
+    readonly ANISOTROPY_ROTATION: "ANISOTROPYROTATION";
+    readonly TRANSMISSION_FACTOR: "TRANSMISSIONFACTOR";
+    readonly THICKNESS_FACTOR: "THICKNESSFACTOR";
+    readonly ATTENUATION_DISTANCE: "ATTENUATIONDISTANCE";
+    readonly ATTENUATION_COLOR: "ATTENUATIONCOLOR";
+    readonly IOR: "IOR";
+    readonly IRIDESCENCE_FACTOR: "IRIDESCENCEFACTOR";
+    readonly IRIDESCENCE_IOR: "IRIDESCENCEIOR";
+    readonly IRIDESCENCE_THICKNESS_MINIMUM: "IRIDESCENCETHICKNESSMINIMUM";
+    readonly IRIDESCENCE_THICKNESS_MAXIMUM: "IRIDESCENCETHICKNESSMAXIMUM";
+    readonly MATERIAL_TEXTURE_TRANSFORMS: "MATERIALTEXTURETRANSFORMS";
+    readonly MATERIAL_TEXTURE_INFO: "MATERIALTEXTUREINFO";
+    readonly MATERIAL_TEXTURE_CHANNELS: "MATERIALTEXTURECHANNELS";
+}>;
+/** Stable sampled-resource semantics understood by the shared renderer. */
+declare const MaterialTextureSemantic: Readonly<{
+    readonly SHADOW_ATLAS: "SHADOWATLAS";
+    readonly DIRECTIONAL_LIGHTS_SHADOW_MAP: "DIRECTIONALLIGHTSSHADOWMAP";
+    readonly POINT_LIGHTS_SHADOW_MAP: "POINTLIGHTSSHADOWMAP";
+    readonly SPOT_LIGHTS_SHADOW_MAP: "SPOTLIGHTSSHADOWMAP";
+    readonly AREA_LIGHTS_LTC_TEXTURE_1: "AREALIGHTSLTCTEXTURE1";
+    readonly AREA_LIGHTS_LTC_TEXTURE_2: "AREALIGHTSLTCTEXTURE2";
+    readonly DIFFUSE: "DIFFUSE";
+    readonly SPECULAR: "SPECULAR";
+    readonly EMISSION: "EMISSION";
+    readonly AMBIENT: "AMBIENT";
+    readonly NORMAL_MAP: "NORMALMAP";
+    readonly PARALLAX_MAP: "PARALLAXMAP";
+    readonly OPACITY: "TRANSPARENCY";
+    readonly BASE_COLOR_MAP: "BASECOLORMAP";
+    readonly METALLIC_MAP: "METALLICMAP";
+    readonly ROUGHNESS_MAP: "ROUGHNESSMAP";
+    readonly METALLIC_ROUGHNESS_MAP: "METALLICROUGHNESSMAP";
+    readonly OCCLUSION_MAP: "OCCLUSIONMAP";
+    readonly SPECULAR_GLOSSINESS_MAP: "SPECULARGLOSSINESSMAP";
+    readonly LIGHT_MAP: "LIGHTMAP";
+    readonly CLEARCOAT_MAP: "CLEARCOATMAP";
+    readonly CLEARCOAT_ROUGHNESS_MAP: "CLEARCOATROUGHNESSMAP";
+    readonly CLEARCOAT_NORMAL_MAP: "CLEARCOATNORMALMAP";
+    readonly ANISOTROPY_MAP: "ANISOTROPYMAP";
+    readonly TRANSMISSION_MAP: "TRANSMISSIONMAP";
+    readonly THICKNESS_MAP: "THICKNESSMAP";
+    readonly IRIDESCENCE_MAP: "IRIDESCENCEMAP";
+    readonly IRIDESCENCE_THICKNESS_MAP: "IRIDESCENCETHICKNESSMAP";
+    readonly DIFFUSE_ENV_MAP: "DIFFUSEENVMAP";
+    readonly BRDF_LUT: "BRDFLUT";
+    readonly SPECULAR_ENV_MAP: "SPECULARENVMAP";
+    readonly OPAQUE_SCENE_TEXTURE: "OPAQUETEXTURE";
+    /** Pass-global ground-truth ambient visibility texture. */
+    readonly GROUND_TRUTH_AMBIENT_OCCLUSION: "GTAOTEXTURE";
+}>;
+type MaterialAttributeSemanticName = (typeof MaterialAttributeSemantic)[keyof typeof MaterialAttributeSemantic] | `MORPH${'POSITION' | 'NORMAL' | 'TANGENT'}${0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}`;
+type MaterialUniformSemanticName = (typeof MaterialUniformSemantic)[keyof typeof MaterialUniformSemantic];
+type MaterialTextureSemanticName = (typeof MaterialTextureSemantic)[keyof typeof MaterialTextureSemantic] | `${'DIFFUSE' | 'SPECULAR' | 'EMISSION' | 'AMBIENT'}UV` | `${'NORMALMAP' | 'PARALLAXMAP' | 'BASECOLORMAP' | 'METALLICMAP' | 'ROUGHNESSMAP' | 'METALLICROUGHNESSMAP' | 'OCCLUSIONMAP' | 'SPECULARGLOSSINESSMAP' | 'LIGHTMAP' | 'CLEARCOATMAP' | 'CLEARCOATROUGHNESSMAP' | 'CLEARCOATNORMALMAP' | 'ANISOTROPYMAP' | 'TRANSMISSIONMAP' | 'THICKNESSMAP' | 'IRIDESCENCEMAP' | 'IRIDESCENCETHICKNESSMAP'}UV` | 'TRANSPARENCYUV';
+/** Any built-in semantic identifier accepted by a string material binding. */
+type MaterialSemanticName = MaterialAttributeSemanticName | MaterialUniformSemanticName | MaterialTextureSemanticName;
+
 interface ProgramBindingInfo {
     textureIndex?: number;
     name?: string;
@@ -4715,502 +5126,214 @@ interface MaterialBindingInfo {
     readonly isBlankInfo?: boolean;
     readonly isDependMesh?: boolean;
     readonly notSupportInstanced?: boolean;
-    get(mesh: Mesh, material: Material, programInfo: ProgramBindingInfo): unknown;
+    get(mesh: Mesh, material: MaterialInstance, programInfo: ProgramBindingInfo): unknown;
 }
-type MaterialBinding = string | MaterialBindingInfo;
+type MaterialBinding = MaterialSemanticName | MaterialBindingInfo;
 type MaterialBindingMap = Record<string, MaterialBinding>;
-interface MaterialShaderSource {
-    vs: string;
-    fs: string;
-}
-type MaterialBeforeCompile = (vs: string, fs: string) => MaterialShaderSource;
 type MaterialTexture = Texture<unknown>;
 type MaterialTextureValue = MaterialTexture | Color | null;
-interface MaterialParameters {
-    name?: string | null;
-    shaderCacheId?: string | null;
-    shaderName?: string | null;
-    lightType?: string;
-    wireframe?: boolean;
-    frontFace?: GLenum;
-    depthTest?: boolean;
-    sampleAlphaToCoverage?: boolean;
-    depthMask?: boolean;
-    depthRange?: [number, number];
-    depthFunc?: GLenum;
-    cullFace?: boolean;
-    cullFaceType?: GLenum;
-    side?: GLenum;
-    normalMap?: Texture | null;
-    parallaxMap?: Texture | null;
-    emission?: MaterialTextureValue;
-    normalMapScale?: number;
-    ignoreTransparent?: boolean;
-    gammaCorrection?: boolean;
-    usePhysicsLight?: boolean;
-    isDiffuseEnvAndAmbientLightWorkTogether?: boolean;
-    userData?: unknown;
-    renderOrder?: number;
-    premultiplyAlpha?: boolean;
-    gammaFactor?: number;
-    castShadows?: boolean;
-    receiveShadows?: boolean;
-    uvMatrix?: Matrix3 | null;
-    uvMatrix1?: Matrix3 | null;
-    blend?: boolean;
-    blendEquation?: GLenum;
-    blendEquationAlpha?: GLenum;
-    blendSrc?: GLenum;
-    blendDst?: GLenum;
-    blendSrcAlpha?: GLenum;
-    blendDstAlpha?: GLenum;
-    stencilTest?: boolean;
-    stencilMask?: number;
-    stencilFunc?: GLenum;
-    stencilFuncRef?: number;
-    stencilFuncMask?: number;
-    stencilOpFail?: GLenum;
-    stencilOpZFail?: GLenum;
-    stencilOpZPass?: GLenum;
-    isDirty?: boolean;
-    transparency?: number | Texture;
-    transparent?: boolean;
-    alphaCutoff?: number;
-    useHDR?: boolean;
-    exposure?: number;
-    enableTextureLod?: boolean;
-    enableDrawBuffers?: boolean;
-    needBasicUniforms?: boolean;
-    needBasicAttributes?: boolean;
-    /**
-     * Semantic resolvers used by canonical UBO packing and standalone sampler bindings.
-     * Application-defined classic uniforms must be sampler types; put every numeric value in
-     * `uniformBlocks`.
-     */
-    uniforms?: MaterialBindingMap;
-    attributes?: MaterialBindingMap;
+interface MaterialInstanceParameters {
+    readonly name?: string | null;
+    readonly userData?: unknown;
+    readonly coverage?: MaterialCoverage;
+    readonly compositing?: MaterialCompositing;
+    readonly opacity?: number;
+    /** Authored TAA history suppression for unstable shading, from zero to one. */
+    readonly temporalReactiveFactor?: number;
+    readonly opacityMap?: Texture<unknown> | MaterialTextureSlotInput | null;
+    readonly normalMap?: Texture<unknown> | MaterialTextureSlotInput | null;
+    readonly normalScale?: number;
+    readonly parallaxMap?: Texture<unknown> | MaterialTextureSlotInput | null;
     /** Registered std140 blocks keyed by their globally stable GLSL block name. */
-    uniformBlocks?: Record<string, UniformBuffer>;
-    onBeforeCompile?: MaterialBeforeCompile | null;
+    readonly uniformBlocks?: Readonly<Record<string, UniformBuffer>>;
 }
 interface InstancedUniform {
-    name: string;
-    info: MaterialBindingInfo;
-}
-declare class TextureOptionBuilder {
-    private readonly uvTypes;
-    private option;
-    reset(option: ShaderOptions): this;
-    add(texture: unknown, optionName: string, callback?: () => void): this;
-    update(): this;
+    readonly name: string;
+    readonly info: MaterialBindingInfo;
 }
 /**
- * 材质基类，一般不直接使用
+ * Mutable material data bound to one immutable {@link MaterialDefinition}.
+ *
+ * Ordinary parameter and texture changes advance `revision` but never alter the definition,
+ * resource layout, supported pass roles or shader topology. A topology change requires a new
+ * instance created with another definition.
  */
-declare class Material {
-    readonly isMaterial = true;
+declare class MaterialInstance {
+    #private;
+    readonly isMaterialInstance = true;
     readonly className: string;
-    onBeforeCompile: MaterialBeforeCompile | null;
-    /**
-     * name
-     */
+    readonly id: string;
+    readonly materialId: number;
+    readonly definition: MaterialDefinition;
+    readonly coverage: MaterialCoverage;
+    readonly compositing: MaterialCompositing;
     name: string | null;
+    userData: unknown;
+    readonly uniforms: MaterialBindingMap;
+    readonly attributes: MaterialBindingMap;
+    readonly uniformBlocks: Record<string, UniformBuffer>;
+    constructor(definition: MaterialDefinition, parameters?: Readonly<MaterialInstanceParameters>, initializeBindings?: boolean);
+    /** Monotonic instance-data revision observed independently by each renderer. */
+    get revision(): number;
+    get opacity(): number;
+    set opacity(value: number);
+    /** Authored TAA history suppression written by the material's motion-vector pass. */
+    get temporalReactiveFactor(): number;
+    set temporalReactiveFactor(value: number);
+    get normalScale(): number;
+    set normalScale(value: number);
+    /** Whether the forward pass composites this surface with an existing color attachment. */
+    get isTransparent(): boolean;
+    /** Whether the forward shader samples the opaque scene-color copy. */
+    get requiresOpaqueSceneTexture(): boolean;
+    /**
+     * Forward renderer queue selected from compositing and pass resource dependencies.
+     *
+     * An unblended transmission surface remains compositionally opaque, but it must execute after
+     * the opaque scene copy exists and therefore belongs to the transparent/after-opaque queue.
+     */
+    get forwardQueue(): 'opaque' | 'transparent';
+    get lightType(): string;
+    /** Bind data to a slot already declared by the immutable definition. */
+    setTextureSlot(name: string, value: Texture<unknown> | MaterialTextureSlotInput | null): void;
+    getTextureSlot(name: string): MaterialTextureSlotBinding | null;
+    /** @internal Fixed-index lookup used by UBO packing without map iteration. */
+    getTextureSlotByIndex(index: number): MaterialTextureSlotBinding | null;
+    /** @internal Snapshot dirty slot indices for a submission-aware material database. */
+    getDirtyTextureSlots(): readonly number[];
+    /** @internal Clear dirty slots only after a valid submission commits their revision. */
+    commitTextureSlotRevision(revision: number): void;
+    /**
+     * Advance the data revision after mutating a referenced vector, color, matrix, or custom
+     * binding value. Texture-slot and built-in scalar accessors call this automatically.
+     */
+    invalidateData(): void;
+    protected markDataChanged(): void;
+    protected initializeBindings(): void;
+    protected addBasicAttributes(): void;
+    protected addBasicUniforms(): void;
+    protected addTextureUniforms(textureUniforms: Readonly<Record<string, MaterialTextureSemanticName>>): void;
+    getRenderOption(option?: ShaderOptions): ShaderOptions;
+    getInstancedUniforms(): readonly InstancedUniform[];
+    getUniformData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
+    getAttributeData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
+    getUniformInfo(name: string): MaterialBindingInfo;
+    getAttributeInfo(name: string): MaterialBindingInfo;
+    getTextures(): readonly MaterialTexture[];
+    destroyTextures(): void;
+    protected copyBindings(origin: MaterialBindingMap, data: Readonly<MaterialBindingMap>): void;
+    private getInfo;
+}
+
+interface MeshParameters extends NodeParameters {
+    geometry?: Geometry | null;
+    material?: MaterialInstance | null;
+    useInstanced?: boolean;
+    frustumTest?: boolean;
+    renderOrder?: number;
+    castShadows?: boolean;
+    receiveShadows?: boolean;
+    /** Active direct-draw instances when geometry supplies per-instance vertex streams. */
+    instanceCount?: number;
+}
+/**
+ * Mesh
+ * @example
+ * ```ts
+ * const mesh = new Hilo3d.Mesh({
+ *     geometry: new Hilo3d.BoxGeometry(),
+ *     material: new Hilo3d.BasicMaterial({
+ *         diffuse: new Hilo3d.Color(0.8, 0, 0)
+ *     }),
+ *     x:100,
+ *     rotationX:30
+ * });
+ * stage.addChild(mesh);
+ * ```
+ */
+declare class Mesh extends Node {
+    static readonly typeName: string;
+    protected _isDestroyed: boolean;
+    isMesh: boolean;
+    className: string;
+    geometry: Geometry | null;
+    material: MaterialInstance | null;
     /**
-     * shader cache id
+     * 是否使用 Instanced
      */
-    shaderCacheId: string | null;
+    useInstanced: boolean;
     /**
-     * shader name，会在 shader 中加个 SHADER_NAME 宏，不填用 className 代替。
+     * 是否开启视锥体裁剪
      */
-    shaderName: string | null;
+    frustumTest: boolean;
+    /** Object ordering policy; it is intentionally independent of material identity. */
+    renderOrder: number;
+    /** Object participation in shadow-caster renderer lists. */
+    castShadows: boolean;
+    /** Whether forward shading consumes scene shadow data for this object. */
+    receiveShadows: boolean;
+    private _instanceCount;
     /**
-     * 光照类型
+     * Active direct-draw instance count.
+     *
+     * Values above one require at least one `GeometryData` input with `stepMode: 'instance'`.
+     * Planner-owned `useInstanced` batching keeps its existing independent contract.
      */
-    lightType: string;
+    get instanceCount(): number;
+    set instanceCount(value: number);
     /**
-     * 是否开启网格模式
+     * @param params - 初始化参数，所有params都会复制到实例上
+     * - `params.geometry`: 几何体
+     * - `params.material`: 材质
      */
-    wireframe: boolean;
+    constructor(params?: MeshParameters);
     /**
-     * front face winding orientation
+     * clone 当前mesh
+     * @param isChild - 是否子元素
+     * @returns 返回clone的实例
      */
-    frontFace: number;
+    clone(isChild?: boolean): Mesh;
     /**
-     * 是否开启深度测试
+     * raycast
+     * @param ray -
+     * @param sort - 是否按距离排序
      */
-    depthTest: boolean;
+    raycast(ray: Ray, sort?: boolean): Vector3[] | null;
     /**
-     * SAMPLE_ALPHA_TO_COVERAGE
+     * 获取渲染选项值
+     * @param opt - 渲染选项值
+     * @returns 渲染选项值
      */
-    sampleAlphaToCoverage: boolean;
+    getRenderOption(opt?: ShaderOptions): ShaderOptions;
     /**
-     * 是否开启depthMask
+     * 是否被销毁
      */
-    depthMask: boolean;
+    get isDestroyed(): boolean;
     /**
-     * 深度测试Range
+     * 销毁 Mesh 资源
+     * @param renderer -
+     * @param needDestroyTextures - 是否销毁材质的贴图，默认不销毁
+     * @returns this
      */
-    depthRange: [number, number];
+    destroy(renderer?: Renderer, needDestroyTextures?: boolean): this;
+}
+
+/** Depth convention used by projection, depth testing, shadows, and picking. */
+type CameraDepthMode = 'standard' | 'reversed';
+interface CameraParameters extends NodeParameters {
     /**
-     * 深度测试方法
+     * Depth convention. `reversed` maps the near plane to 1 and far/infinity to 0, improving
+     * floating-point depth precision. Defaults to `standard` for compatibility.
      */
-    depthFunc: number;
-    private _cullFace;
+    depthMode?: CameraDepthMode;
     /**
-     * 法线贴图
+     * Camera visibility bit mask. A renderable node is collected when
+     * `(camera.visibility & node.layer) !== 0`.
      */
-    normalMap: Texture | null;
+    visibility?: number;
     /**
-     * 视差贴图
-     */
-    parallaxMap: Texture | null;
-    emission: MaterialTextureValue;
-    /**
-     * 法线贴图scale
-     */
-    normalMapScale: number;
-    /**
-     * 是否忽略透明度
-     */
-    ignoreTransparent: boolean;
-    /**
-     * 是否开启 gamma 矫正
-     */
-    gammaCorrection: boolean;
-    /**
-     * 是否使用物理灯光
-     */
-    usePhysicsLight: boolean;
-    /**
-     * 是否环境贴图和环境光同时生效
-     */
-    isDiffuseEnvAndAmbientLightWorkTogether: boolean;
-    /**
-     * 用户数据
-     */
-    userData: unknown;
-    /**
-     * 渲染顺序数字小的先渲染（透明物体和不透明在不同的队列）
-     */
-    renderOrder: number;
-    private _premultiplyAlpha;
-    /**
-     * 是否预乘 alpha
-     */
-    get premultiplyAlpha(): boolean;
-    /**
-     * 是否预乘 alpha
-     */
-    set premultiplyAlpha(value: boolean);
-    /**
-     * gamma值
-     */
-    gammaFactor: number;
-    /**
-     * 是否投射阴影
-     */
-    castShadows: boolean;
-    /**
-     * 是否接受阴影
-     */
-    receiveShadows: boolean;
-    /**
-     * uv transform eg:new Matrix3().fromRotationTranslationScale(Math.PI/2, 0, 0, 2, 2)
-     */
-    uvMatrix: Matrix3 | null;
-    /**
-     * uv1 transform eg:new Matrix3().fromRotationTranslationScale(Math.PI/2, 0, 0, 2, 2)
-     */
-    uvMatrix1: Matrix3 | null;
-    /**
-     * 是否开启 CullFace
-     */
-    get cullFace(): boolean;
-    /**
-     * 是否开启 CullFace
-     */
-    set cullFace(value: boolean);
-    private _cullFaceType;
-    /**
-     * CullFace 类型
-     */
-    get cullFaceType(): GLenum;
-    /**
-     * CullFace 类型
-     */
-    set cullFaceType(value: GLenum);
-    private _side;
-    /**
-     * 显示面，可选值 FRONT, BACK, FRONT_AND_BACK
-     */
-    get side(): GLenum;
-    /**
-     * 显示面，可选值 FRONT, BACK, FRONT_AND_BACK
-     */
-    set side(value: GLenum);
-    /**
-     * 是否开启颜色混合
-     */
-    blend: boolean;
-    /**
-     * 颜色混合方式
-     */
-    blendEquation: number;
-    /**
-     * 透明度混合方式
-     */
-    blendEquationAlpha: number;
-    /**
-     * 颜色混合来源比例
-     */
-    blendSrc: number;
-    /**
-     * 颜色混合目标比例
-     */
-    blendDst: number;
-    /**
-     * 透明度混合来源比例
-     */
-    blendSrcAlpha: number;
-    /**
-     * 透明度混合目标比例
-     */
-    blendDstAlpha: number;
-    /**
-     * stencilTest
-     */
-    stencilTest: boolean;
-    /**
-     * stencilMask
-     */
-    stencilMask: number;
-    /**
-     * stencilFunc func
-     */
-    stencilFunc: number;
-    /**
-     * stencilFunc ref
-     */
-    stencilFuncRef: number;
-    /**
-     * stencilFunc mask
-     */
-    stencilFuncMask: number;
-    /**
-     * stencilOp fail
-     */
-    stencilOpFail: number;
-    /**
-     * stencilOp zfail
-     */
-    stencilOpZFail: number;
-    /**
-     * stencilOp zpass
-     */
-    stencilOpZPass: number;
-    private _isDirty;
-    private _revision;
-    /** Monotonic material-data revision observed independently by every backend. */
-    get revision(): number;
-    /** 当前是否需要强制更新 */
-    get isDirty(): boolean;
-    set isDirty(value: boolean);
-    /**
-     * 透明度 0~1
-     */
-    transparency: number | Texture;
-    private _transparent;
-    /**
-     * 是否需要透明
-     */
-    get transparent(): boolean;
-    /**
-     * 是否需要透明
-     */
-    set transparent(value: boolean);
-    setDefaultTransparentBlend(): void;
-    /**
-     * 透明度剪裁，如果渲染的颜色透明度大于等于这个值的话渲染为完全不透明，否则渲染为完全透明
-     */
-    alphaCutoff: number;
-    /**
-     * 是否使用HDR
-     */
-    useHDR: boolean;
-    /**
-     * 曝光度，仅在 useHDR 为 true 时生效
-     */
-    exposure: number;
-    /**
-     * 是否开启 texture lod
-     */
-    enableTextureLod: boolean;
-    /**
-     * 是否开启 drawBuffers
-     */
-    enableDrawBuffers: boolean;
-    /**
-     * 是否需要加基础 uniforms
-     */
-    needBasicUniforms: boolean;
-    /**
-     * 是否需要加基础 attributes
-     */
-    needBasicAttributes: boolean;
-    readonly id: string;
-    /**
-     * Semantic resolvers for canonical block fields and sampler bindings. Program linking rejects
-     * every active classic uniform that is not an opaque sampler.
-     */
-    uniforms: MaterialBindingMap;
-    attributes: MaterialBindingMap;
-    /** Registered std140 blocks keyed by GLSL block name. */
-    uniformBlocks: Record<string, UniformBuffer>;
-    protected readonly textureOption: TextureOptionBuilder;
-    private _instancedUniforms;
-    private bindingsInitialized;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     */
-    constructor(params?: MaterialParameters, initializeBindings?: boolean);
-    protected initializeBindings(): void;
-    /**
-     * 增加基础 attributes
-     */
-    addBasicAttributes(): void;
-    /**
-     * 增加基础 uniforms
-     */
-    addBasicUniforms(): void;
-    /**
-     * 增加贴图 uniforms
-     * @param textureUniforms - textureName:semanticName 键值对
-     */
-    addTextureUniforms(textureUniforms: Readonly<Record<string, string>>): void;
-    /**
-     * 获取渲染选项值
-     * @param option - 渲染选项值
-     * @returns 渲染选项值
-     */
-    getRenderOption(option?: ShaderOptions): ShaderOptions;
-    /**
-     * 获取 instanced uniforms
-     */
-    getInstancedUniforms(): InstancedUniform[];
-    getUniformData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
-    getAttributeData(name: string, mesh: Mesh, programInfo: ProgramBindingInfo): unknown;
-    getUniformInfo(name: string): MaterialBindingInfo;
-    getAttributeInfo(name: string): MaterialBindingInfo;
-    private getInfo;
-    /**
-     * clone 当前Material
-     * @returns 返回clone的Material
-     */
-    clone(): Material;
-    /**
-     * 销毁贴图
-     * @returns this
-     */
-    destroyTextures(): void;
-    /**
-     * 获取材质全部贴图
-     */
-    getTextures(): MaterialTexture[];
-    /**
-     * 复制属性，只有没属性时才会覆盖
-     * @param origin -
-     * @param data -
-     */
-    protected copyBindings(origin: MaterialBindingMap, data: Readonly<MaterialBindingMap>): void;
-    /**
-     * 获取阴影材质，子类可重写
-     * @param shadowMaterial - 通用阴影材质
-     */
-    getShadowMaterial(shadowMaterial: Material): Material;
-}
-
-interface MeshParameters extends NodeParameters {
-    geometry?: Geometry | null;
-    material?: Material | null;
-    useInstanced?: boolean;
-    frustumTest?: boolean;
-}
-/**
- * Mesh
- * @example
- * ```ts
- * const mesh = new Hilo3d.Mesh({
- *     geometry: new Hilo3d.BoxGeometry(),
- *     material: new Hilo3d.BasicMaterial({
- *         diffuse: new Hilo3d.Color(0.8, 0, 0)
- *     }),
- *     x:100,
- *     rotationX:30
- * });
- * stage.addChild(mesh);
- * ```
- */
-declare class Mesh extends Node {
-    static readonly typeName: string;
-    protected _isDestroyed: boolean;
-    isMesh: boolean;
-    className: string;
-    geometry: Geometry | null;
-    material: Material | null;
-    /**
-     * 是否使用 Instanced
-     */
-    useInstanced: boolean;
-    /**
-     * 是否开启视锥体裁剪
-     */
-    frustumTest: boolean;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.geometry`: 几何体
-     * - `params.material`: 材质
-     */
-    constructor(params?: MeshParameters);
-    /**
-     * clone 当前mesh
-     * @param isChild - 是否子元素
-     * @returns 返回clone的实例
-     */
-    clone(isChild?: boolean): Mesh;
-    /**
-     * raycast
-     * @param ray -
-     * @param sort - 是否按距离排序
-     */
-    raycast(ray: Ray, sort?: boolean): Vector3[] | null;
-    /**
-     * 获取渲染选项值
-     * @param opt - 渲染选项值
-     * @returns 渲染选项值
-     */
-    getRenderOption(opt?: ShaderOptions): ShaderOptions;
-    /**
-     * 是否被销毁
-     */
-    get isDestroyed(): boolean;
-    /**
-     * 销毁 Mesh 资源
-     * @param renderer -
-     * @param needDestroyTextures - 是否销毁材质的贴图，默认不销毁
-     * @returns this
-     */
-    destroy(renderer?: Renderer, needDestroyTextures?: boolean): this;
-}
-
-interface CameraParameters extends NodeParameters {
-    /**
-     * Camera visibility bit mask. A renderable node is collected when
-     * `(camera.visibility & node.layer) !== 0`.
-     */
-    visibility?: number;
-    /**
-     * Clear the current color attachment when this camera follows another camera in the same
-     * application frame. The first camera always clears.
+     * Clear the current color attachment when this camera follows another camera in the same
+     * application frame. The first camera always clears.
      */
     clearColor?: boolean;
     /** Clear depth before this camera when composing multiple cameras. */
@@ -5226,8 +5349,14 @@ interface CameraParameters extends NodeParameters {
 declare class Camera extends Node {
     static readonly typeName: string;
     readonly viewMatrix: Matrix4;
+    /** Stable non-jittered projection used by CPU culling, picking, and project/unproject. */
     readonly projectionMatrix: Matrix4;
+    /** Raster projection with the current sub-pixel clip-space jitter applied. */
+    readonly jitteredProjectionMatrix: Matrix4;
+    /** Stable non-jittered view-projection used by CPU visibility and interaction queries. */
     readonly viewProjectionMatrix: Matrix4;
+    /** Raster view-projection with the current sub-pixel clip-space jitter applied. */
+    readonly jitteredViewProjectionMatrix: Matrix4;
     protected readonly _frustum: Frustum;
     protected _geometry: Geometry | null;
     isCamera: boolean;
@@ -5249,6 +5378,10 @@ declare class Camera extends Node {
     clearDepth: boolean;
     /** Whether this camera clears stencil before drawing. */
     clearStencil: boolean;
+    private depthModeValue;
+    /** Active projection/depth-buffer convention. */
+    get depthMode(): CameraDepthMode;
+    set depthMode(value: CameraDepthMode);
     private priorityValue;
     /** Camera composition priority. Lower values render first and receive pointer input last. */
     get priority(): number;
@@ -5258,6 +5391,8 @@ declare class Camera extends Node {
      */
     protected _needUpdateProjectionMatrix: boolean;
     protected _isGeometryDirty: boolean;
+    private projectionJitterXValue;
+    private projectionJitterYValue;
     /**
      * @param params - 创建对象的属性参数。可包含此类的所有属性。
      */
@@ -5276,6 +5411,23 @@ declare class Camera extends Node {
      * 更新投影矩阵，子类必须重载这个方法
      */
     updateProjectionMatrix(): void;
+    /** Horizontal raster jitter in normalized-device coordinates. */
+    get projectionJitterX(): number;
+    /** Vertical raster jitter in normalized-device coordinates. */
+    get projectionJitterY(): number;
+    /**
+     * Apply a sub-pixel raster offset without changing the stable CPU projection.
+     *
+     * Temporal render features use normalized-device coordinates, where one physical pixel is
+     * `2 / attachmentSize`. Culling, picking, project/unproject, and camera helpers continue to
+     * consume `projectionMatrix` and `viewProjectionMatrix`.
+     * @param x - Horizontal normalized-device offset.
+     * @param y - Vertical normalized-device offset.
+     * @returns this
+     */
+    setProjectionJitter(x: number, y: number): this;
+    /** Clear the raster jitter while preserving transform history. */
+    clearProjectionJitter(): this;
     /**
      * 获取几何体，子类必须重写
      * @param forceUpdate - 是否强制更新
@@ -5286,6 +5438,8 @@ declare class Camera extends Node {
      * @returns this
      */
     updateViewProjectionMatrix(): this;
+    /** Rebuild the raster projection by translating clip coordinates before perspective divide. */
+    protected updateJitteredProjectionMatrix(): void;
     /**
      * 获取元素相对于当前Camera的矩阵
      * @param node - 目标元素
@@ -5321,6 +5475,8 @@ declare class Camera extends Node {
      * @param point -
      */
     isPointVisible(point: Vector3): boolean;
+    /** Return whether a world-space bounding sphere intersects the stable camera frustum. */
+    isSphereVisible(sphere: Sphere): boolean;
     /**
      * mesh 是否摄像机可见
      * @param mesh -
@@ -5334,6 +5490,54 @@ declare class Camera extends Node {
     updateFrustum(matrix: Matrix4): this;
 }
 
+/** Native command-pass categories that can receive GPU timestamps. */
+type RGPassTimestampKind = 'render' | 'compute';
+/** Availability state for one frame's asynchronous GPU timestamp result. */
+type RenderGraphGPUTimelineStatus = 'unavailable' | 'pending' | 'ready' | 'failed' | 'saturated';
+/** Immutable CPU/GPU timing values for one compiled Render Graph pass. */
+interface RenderGraphPassTimelineSnapshot {
+    /** Stable graph pass label. */
+    readonly name: string;
+    /** Native timestamp category, or null when this pass cannot be profiled. */
+    readonly kind: RGPassTimestampKind | null;
+    /** Synchronous CPU execution duration in milliseconds. */
+    readonly cpuDurationMs: number;
+    /** Asynchronously resolved GPU duration in milliseconds, or null when unavailable. */
+    readonly gpuDurationMs: number | null;
+}
+/** Immutable lifetime metadata for one compiled Render Graph resource. */
+interface RenderGraphResourceLifetimeSnapshot {
+    /** Stable graph resource label. */
+    readonly name: string;
+    /** Logical graph resource category. */
+    readonly kind: 'texture' | 'texture-view' | 'buffer';
+    /** Whether the resource was imported, transiently allocated, or derived as a view. */
+    readonly origin: 'imported' | 'transient' | 'view';
+    /** First compiled pass index using this resource, or null when unused. */
+    readonly firstUse: number | null;
+    /** Last compiled pass index using this resource, or null when unused. */
+    readonly lastUse: number | null;
+}
+/** One immutable CPU/GPU view of a compiled and submitted Render Graph frame. */
+interface RenderGraphTimelineSnapshot {
+    /** Application frame index. */
+    readonly frameIndex: number;
+    /** Pipeline graph-recording CPU duration in milliseconds. */
+    readonly recordDurationMs: number;
+    /** Graph compilation CPU duration in milliseconds. */
+    readonly compileDurationMs: number;
+    /** Resource and pipeline preparation CPU duration in milliseconds. */
+    readonly prepareDurationMs: number;
+    /** Command-emission CPU duration in milliseconds. */
+    readonly executeDurationMs: number;
+    /** Lifecycle state of the asynchronous GPU timestamp result. */
+    readonly gpuStatus: RenderGraphGPUTimelineStatus;
+    /** Compiled pass timing snapshots in execution order. */
+    readonly passes: readonly RenderGraphPassTimelineSnapshot[];
+    /** Compiled logical-resource lifetime snapshots. */
+    readonly resources: readonly RenderGraphResourceLifetimeSnapshot[];
+}
+
 /**
  * 渲染信息
  */
@@ -5374,6 +5578,9 @@ interface RenderGraphFramePlan {
     readonly shadowLights: ReadonlySet<Light>;
 }
 
+/** Encoding carried by render-pipeline color values at a presentation boundary. */
+type RenderColorEncoding = 'linear' | 'srgb';
+
 type RenderTargetSampleCount = 1 | 4;
 type RenderTargetColorFormat = 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba16float' | 'rgba32float';
 type RenderTargetDepthStencilFormat = 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8';
@@ -5398,6 +5605,8 @@ interface RenderTargetDepthStencilAttachmentOptions {
     readonly format?: RenderTargetDepthStencilFormat;
     /** Expose the depth aspect as an engine Texture. Multisampled depth cannot be sampled. */
     readonly sampled?: boolean;
+    /** Projection/depth-buffer convention. Defaults to `standard`. */
+    readonly depthMode?: CameraDepthMode;
     readonly compare?: RenderTargetCompareFunction;
     readonly depthClearValue?: number;
     readonly depthLoadOp?: RenderTargetLoadOp;
@@ -5419,7 +5628,15 @@ interface RenderTargetParameters {
     readonly sampleCount?: RenderTargetSampleCount;
     readonly label?: string;
 }
-interface RenderTargetSelectionOptions {
+/** Color contract used when attachment zero is copied to the browser presentation surface. */
+interface RenderTargetPresentationOptions {
+    /**
+     * Encoding stored in attachment zero. Linear input receives the final sRGB transfer. Defaults
+     * to `linear`; a selection's value is reused by `present()` when that target is implicit.
+     */
+    readonly colorEncoding?: RenderColorEncoding;
+}
+interface RenderTargetSelectionOptions extends RenderTargetPresentationOptions {
     /** Present attachment zero after each render. */
     readonly present?: boolean;
     /** Destroy the target when it is replaced or when the renderer is destroyed. */
@@ -5561,7 +5778,7 @@ interface RendererFrame {
     readonly backend: RendererBackend;
     render(stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
     renderToTarget(target: RenderTarget, stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
-    present(target?: RenderTarget): void;
+    present(target?: RenderTarget, options?: RenderTargetPresentationOptions): void;
 }
 /** Synchronous frame recorder. Returning a Promise is rejected at runtime. */
 type RendererFrameCallback = (frame: RendererFrame) => unknown;
@@ -5580,7 +5797,9 @@ interface RendererContract {
     pixelRatio: number;
     domElement: HTMLCanvasElement | null;
     useInstanced: boolean;
-    forceMaterial: Material | null;
+    readonly cameraRelative: boolean;
+    readonly renderingProfile: 'portable' | 'high-end';
+    forceMaterial: MaterialInstance | null;
     clearColor: Color;
     resize(width: number, height: number, force?: boolean): void;
     setOffset(x: number, y: number): void;
@@ -5595,7 +5814,7 @@ interface RendererContract {
     createRenderTarget(parameters: RenderTargetParameters): RenderTarget;
     setRenderTarget(target: RenderTarget | null, options?: RenderTargetSelectionOptions): this;
     /** Present the first color attachment of a renderer-owned target to the canvas. */
-    present(target?: RenderTarget): void;
+    present(target?: RenderTarget, options?: RenderTargetPresentationOptions): void;
     renderToTarget(target: RenderTarget, stage: RendererScene, camera: Camera, fireEvent?: boolean): void;
     onInit(callback: (renderer: this) => void): void;
     /** Resolve after all work submitted before this call has completed. */
@@ -5665,18 +5884,41 @@ interface RendererListDescriptor {
     /** Sorting policy applied before draw preparation. */
     readonly sorting: RendererListSorting;
     /** Optional material used for every selected mesh. */
-    readonly overrideMaterial?: Material;
+    readonly overrideMaterial?: MaterialInstance;
+    /** Semantic material pass compiled for every selected draw. Defaults to `forward`. */
+    readonly materialPass?: MaterialPassRole;
     /** Include only meshes whose effective material casts shadows. */
     readonly castShadowsOnly?: boolean;
+    /**
+     * Mesh identities omitted from this list after culling. This supports hybrid pipelines that
+     * draw a GPU-managed subset separately while retaining the shared Forward path as a fallback.
+     */
+    readonly excludeMeshes?: readonly Mesh[];
 }
 
+/** Physical dimension of a scriptable render-pipeline texture. */
+type RenderPipelineTextureDimension = '1d' | '2d' | '3d';
+/** Dimension exposed by one scriptable render-pipeline texture view. */
+type RenderPipelineTextureViewDimension = '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+/** Aspect selected by one scriptable render-pipeline texture view. */
+type RenderPipelineTextureAspect = 'all' | 'stencil-only' | 'depth-only';
+/** Portable texture formats accepted by graph, compute, copy, and raster validation. */
+type RenderPipelineTextureFormat = 'r8unorm' | 'r8snorm' | 'r8uint' | 'r8sint' | 'r16uint' | 'r16sint' | 'r16float' | 'rg8unorm' | 'rg8snorm' | 'rg8uint' | 'rg8sint' | 'r32uint' | 'r32sint' | 'r32float' | 'rg16uint' | 'rg16sint' | 'rg16float' | 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba8snorm' | 'rgba8uint' | 'rgba8sint' | 'bgra8unorm' | 'bgra8unorm-srgb' | 'rgb10a2unorm' | 'rgb10a2uint' | 'rg11b10ufloat' | 'rgb9e5ufloat' | 'rg32uint' | 'rg32sint' | 'rg32float' | 'rgba16uint' | 'rgba16sint' | 'rgba16float' | 'rgba32uint' | 'rgba32sint' | 'rgba32float' | 'stencil8' | 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8' | 'bc1-rgba-unorm' | 'bc1-rgba-unorm-srgb' | 'bc2-rgba-unorm' | 'bc2-rgba-unorm-srgb' | 'bc3-rgba-unorm' | 'bc3-rgba-unorm-srgb' | 'etc2-rgb8unorm' | 'etc2-rgb8unorm-srgb' | 'etc2-rgb8a1unorm' | 'etc2-rgb8a1unorm-srgb' | 'etc2-rgba8unorm' | 'etc2-rgba8unorm-srgb' | 'eac-r11unorm' | 'eac-r11snorm' | 'eac-rg11unorm' | 'eac-rg11snorm' | 'astc-4x4-unorm' | 'astc-4x4-unorm-srgb';
+
 declare const renderGraphTextureHandleBrand: unique symbol;
+declare const renderGraphTextureViewHandleBrand: unique symbol;
 declare const renderGraphBufferHandleBrand: unique symbol;
 declare const renderGraphPassHandleBrand: unique symbol;
 /** Opaque texture identity scoped to one scriptable frame. */
 type RenderGraphTextureHandle = number & {
     readonly [renderGraphTextureHandleBrand]: true;
 };
+/** Opaque view identity selecting subresources from one graph texture. */
+type RenderGraphTextureViewHandle = number & {
+    readonly [renderGraphTextureViewHandleBrand]: true;
+};
+/** A complete graph texture or one explicit mip/layer/aspect view. */
+type RenderGraphTextureAccessHandle = RenderGraphTextureHandle | RenderGraphTextureViewHandle;
 /** Opaque buffer identity scoped to one scriptable frame. */
 type RenderGraphBufferHandle = number & {
     readonly [renderGraphBufferHandleBrand]: true;
@@ -5698,13 +5940,40 @@ type RenderPipelineExtent = Readonly<{
 /** Backend-neutral transient texture descriptor. Usage is inferred from pass declarations. */
 interface RenderPipelineTextureDescriptor {
     /** Color or depth/stencil format. */
-    readonly format: RenderTargetColorFormat | RenderTargetDepthStencilFormat;
+    readonly format: RenderPipelineTextureFormat;
     /** Absolute or output-relative dimensions. */
     readonly extent: RenderPipelineExtent;
     /** Raster sample count, defaulting to one. */
     readonly sampleCount?: RenderTargetSampleCount;
     /** Mip count, defaulting to one; multisampled textures require one mip. */
     readonly mipLevelCount?: number;
+    /** Texture depth or array-layer count, defaulting to one. */
+    readonly depthOrArrayLayers?: number;
+    /** Physical texture dimension, defaulting to `2d`. */
+    readonly dimension?: RenderPipelineTextureDimension;
+    /** Default whole-resource view dimension. */
+    readonly viewDimension?: RenderPipelineTextureViewDimension;
+    /** Compatible formats that explicit views may select. */
+    readonly viewFormats?: readonly RenderPipelineTextureFormat[];
+}
+/** Explicit subresource selection into one graph texture. */
+interface RenderPipelineTextureViewDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** Optional compatible format reinterpretation declared by the parent texture. */
+    readonly format?: RenderPipelineTextureFormat;
+    /** View dimensionality. */
+    readonly dimension?: RenderPipelineTextureViewDimension;
+    /** Color, depth, stencil, or all compatible aspects. */
+    readonly aspect?: RenderPipelineTextureAspect;
+    /** First selected mip. */
+    readonly baseMipLevel?: number;
+    /** Number of selected mips. */
+    readonly mipLevelCount?: number;
+    /** First selected array layer. */
+    readonly baseArrayLayer?: number;
+    /** Number of selected array layers. */
+    readonly arrayLayerCount?: number;
 }
 /** Backend-neutral transient buffer descriptor. Usage is inferred from pass declarations. */
 interface RenderPipelineBufferDescriptor {
@@ -5744,15 +6013,46 @@ interface RenderPipelinePersistentTargetDescriptor {
     readonly colorFormats: readonly RenderTargetColorFormat[];
     /** Optional depth/stencil attachment format. */
     readonly depthStencilFormat?: RenderTargetDepthStencilFormat;
+    /** Create a persistent depth-only sampled view for a single-sample depth attachment. */
+    readonly depthStencilSampled?: boolean;
     /** Raster sample count, defaulting to one. */
     readonly sampleCount?: RenderTargetSampleCount;
 }
+/** Explicit creation roles for a recovery-aware history texture. */
+type RenderPipelinePersistentTextureUsage = 'sampled' | 'storage' | 'attachment' | 'copy-source' | 'copy-destination';
+/**
+ * Recovery recipe for a renderer-owned double- or triple-buffered history texture.
+ *
+ * The first release accepts one single-sample 2D color mip and array layer. This fail-closed
+ * boundary ensures any submitted current-slot writer fully initializes the next readable slot.
+ */
+interface RenderPipelineHistoryTextureDescriptor extends RenderPipelineTextureDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** Complete immutable usage set required by every history slot. */
+    readonly usage: readonly RenderPipelinePersistentTextureUsage[];
+    /** Number of rotating slots, defaulting to two. */
+    readonly bufferCount?: 2 | 3;
+}
+/** Frame-scoped handles for one persistent history ring. */
+interface RenderPipelineHistoryTextureResources {
+    /** Slot that this frame may completely replace. */
+    readonly current: RenderGraphTextureHandle;
+    /** Whether the immediately previous slot contains valid submitted contents. */
+    readonly valid: boolean;
+    /** Invalidation generation for cached temporal state. */
+    readonly generation: number;
+    /** Number of readable history slots. */
+    readonly historyCount: number;
+    /** Return history slot zero (previous frame) through `historyCount - 1`. */
+    history(index?: number): RenderGraphTextureHandle;
+}
 /** One setup-declared color attachment. */
 interface RenderPipelineColorAttachment {
     /** Attachment source texture. */
-    readonly texture: RenderGraphTextureHandle;
+    readonly texture: RenderGraphTextureAccessHandle;
     /** Optional single-sample resolve destination. */
-    readonly resolveTarget?: RenderGraphTextureHandle;
+    readonly resolveTarget?: RenderGraphTextureAccessHandle;
     /** Whether existing contents are loaded or cleared. */
     readonly loadOp: RenderTargetLoadOp;
     /** Whether resulting contents remain available after the pass. */
@@ -5763,7 +6063,7 @@ interface RenderPipelineColorAttachment {
 /** One setup-declared depth/stencil attachment. */
 interface RenderPipelineDepthStencilAttachment {
     /** Depth/stencil texture handle. */
-    readonly texture: RenderGraphTextureHandle;
+    readonly texture: RenderGraphTextureAccessHandle;
     /** Depth aspect load operation. */
     readonly depthLoadOp?: RenderTargetLoadOp;
     /** Depth aspect store operation. */
@@ -5784,14 +6084,14 @@ interface RenderPipelineDepthStencilAttachment {
 /** Setup-only dependency declaration surface for one pass. */
 interface ScriptableRenderPassBuilder {
     /** Declare a sampled texture read. */
-    readTexture(texture: RenderGraphTextureHandle): void;
+    readTexture(texture: RenderGraphTextureAccessHandle): void;
     /**
      * Declare a write-only storage-texture binding that completely replaces its subresource.
      * Partial in-place texture updates are intentionally outside the first public compute ABI.
      */
-    writeStorageTexture(texture: RenderGraphTextureHandle): void;
-    /** Declare one complete texture copy and its exact source/destination dependency pair. */
-    copyTexture(source: RenderGraphTextureHandle, destination: RenderGraphTextureHandle): void;
+    writeStorageTexture(texture: RenderGraphTextureAccessHandle): void;
+    /** Declare one complete selected-subresource copy and its exact dependency pair. */
+    copyTexture(source: RenderGraphTextureAccessHandle, destination: RenderGraphTextureAccessHandle): void;
     /** Declare one initialized buffer read for the given portable role. */
     readBuffer(buffer: RenderGraphBufferHandle, use: RenderGraphBufferReadUse): void;
     /** Declare a complete buffer replacement for the given portable role. */
@@ -5823,8 +6123,8 @@ interface ScriptableRenderCommands {
     setStencilReference(reference: number): void;
     /** Draw a renderer list declared during setup. */
     drawRendererList(list: RendererListHandle): void;
-    /** Copy the complete single-sample source texture into the destination. */
-    copyTexture(source: RenderGraphTextureHandle, destination: RenderGraphTextureHandle): void;
+    /** Copy the complete selected single-sample subresource into the destination. */
+    copyTexture(source: RenderGraphTextureAccessHandle, destination: RenderGraphTextureAccessHandle): void;
     /** Copy one complete buffer using a source/destination pair declared during setup. */
     copyBuffer(source: RenderGraphBufferHandle, destination: RenderGraphBufferHandle): void;
     /** Clear the exact destination byte range declared during setup. */
@@ -5867,16 +6167,32 @@ interface ScriptableRenderPass<P extends object> {
 interface ScriptableRenderGraph {
     /** Create a logical transient texture whose usage is inferred from live passes. */
     createTexture(name: string, descriptor: Readonly<RenderPipelineTextureDescriptor>): RenderGraphTextureHandle;
+    /** Create one explicit mip/layer/aspect view into a graph texture. */
+    createTextureView(name: string, texture: RenderGraphTextureHandle, descriptor?: Readonly<RenderPipelineTextureViewDescriptor>): RenderGraphTextureViewHandle;
     /** Create a logical transient buffer whose usage is inferred from live passes. */
     createBuffer(name: string, descriptor: Readonly<RenderPipelineBufferDescriptor>): RenderGraphBufferHandle;
     /** Import one renderer-owned persistent StorageBuffer into the active graph. */
     importStorageBuffer(buffer: StorageBuffer): RenderGraphBufferHandle;
+    /**
+     * Import one engine Texture as a sampled, renderer-owned persistent graph resource.
+     *
+     * The texture upload, sampler-independent image identity, device recovery, and submission
+     * lifetime remain owned by the renderer. Storage and attachment access are intentionally not
+     * exposed through this import.
+     */
+    importTexture(texture: Texture<unknown>): RenderGraphTextureHandle;
     /** Import the current surface or selected RenderTarget output. */
     importOutput(): RenderPipelineOutputResources;
     /** Import a RenderTarget owned by the current Renderer. */
     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. */
+    acquireHistoryTexture(key: object, descriptor: Readonly<RenderPipelineHistoryTextureDescriptor>): RenderPipelineHistoryTextureResources;
+    /** Invalidate submitted history before acquiring it in the active frame. */
+    invalidateHistoryTexture(key: object): boolean;
+    /** Transactionally release one renderer-owned history ring. */
+    releaseHistoryTexture(key: object): boolean;
     /**
      * Release one persistent target by runtime-owned key.
      *
@@ -5891,6 +6207,162 @@ interface ScriptableRenderGraph {
     addPass<P extends object>(pass: ScriptableRenderPass<P>, parameters: P): RenderGraphPassHandle;
 }
 
+/** Sample interpretation supported by whole-subresource compute graph textures. */
+type ComputeTextureSampleType = 'float' | 'unfilterable-float' | 'depth';
+/** Compute graph textures currently expose one complete two-dimensional subresource. */
+type ComputeTextureViewDimension = '2d';
+/** Compute storage textures currently expose one complete two-dimensional subresource. */
+type ComputeStorageTextureViewDimension = '2d';
+/** Sample interpretation supported by storage-aware graphics shaders. */
+type ShaderTextureSampleType = ComputeTextureSampleType | 'sint' | 'uint';
+/** Texture views supported by the Material-backed storage graphics path. */
+type ShaderTextureViewDimension = ComputeTextureViewDimension | '2d-array' | '3d' | 'cube';
+/** Public color formats that can be requested for a storage-texture binding. */
+type ComputeStorageTextureFormat = 'r32float' | 'rg32float' | 'rgba8unorm' | 'rgba16float' | 'rgba32float';
+/** Graph initialization promise for a writable storage-buffer binding. */
+type ComputeStorageBufferAccess = 'read-write' | 'write-discard';
+/** Resource binding that a shader may only read. */
+type ShaderReadBinding = Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'uniform-buffer' | 'read-only-storage-buffer';
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampled-texture';
+    sampleType: ShaderTextureSampleType;
+    viewDimension?: ShaderTextureViewDimension;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampler' | 'comparison-sampler';
+}>;
+/** Explicit binding ABI for one Direct WGSL compute shader. */
+type ComputeShaderBinding = Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'uniform-buffer' | 'read-only-storage-buffer';
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampled-texture';
+    sampleType: ComputeTextureSampleType;
+    viewDimension?: ComputeTextureViewDimension;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'sampler' | 'non-filtering-sampler' | 'comparison-sampler';
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'storage-buffer';
+    /** Graph access promise; both modes use a WGSL `read_write` storage declaration. */
+    access: ComputeStorageBufferAccess;
+    minBindingSize?: number;
+    dynamicOffset?: boolean;
+}> | Readonly<{
+    name: string;
+    group: number;
+    binding: number;
+    kind: 'storage-texture';
+    /**
+     * WGSL access mode. Declaring this binding also promises that the pass completely
+     * replaces the bound texture subresource before a later graph read.
+     */
+    access: 'write-only';
+    format: ComputeStorageTextureFormat;
+    viewDimension?: ComputeStorageTextureViewDimension;
+}>;
+/** Immutable source, entry point, workgroup size, and binding ABI for {@link ComputeShader}. */
+interface ComputeShaderDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** Direct WGSL source containing exactly the declared compute entry point and resources. */
+    readonly source: string;
+    /** Compute entry-point name. Defaults to `main`. */
+    readonly entryPoint?: string;
+    /** One to three positive literal dimensions, which must match `@workgroup_size`. */
+    readonly workgroupSize: readonly [number, number?, number?];
+    /** Complete explicit resource ABI; entries are snapshotted and sorted by group/binding. */
+    readonly bindings: readonly ComputeShaderBinding[];
+}
+/** Normalized three-dimensional compute workgroup size. */
+type NormalizedComputeWorkgroupSize = readonly [number, number, number];
+/** Immutable, backend-neutral Direct WGSL compute shader configuration. */
+declare class ComputeShader {
+    /** Stable diagnostic label, or an empty string. */
+    readonly label: string;
+    /** Validated Direct WGSL source. */
+    readonly source: string;
+    /** Validated compute entry point. */
+    readonly entryPoint: string;
+    /** Normalized workgroup dimensions. */
+    readonly workgroupSize: NormalizedComputeWorkgroupSize;
+    /** Immutable bindings in group/binding order. */
+    readonly bindings: readonly ComputeShaderBinding[];
+    /** Snapshot a Direct WGSL compute shader contract without creating device objects. */
+    constructor(descriptor: Readonly<ComputeShaderDescriptor>);
+}
+
+/** Constrained GLSL ES 3.10 graphics source and readonly resource ABI. */
+interface StorageGraphicsShaderDescriptor {
+    /** Optional diagnostic label. */
+    readonly label?: string;
+    /** GLSL ES 3.10 vertex source; storage blocks must be `readonly` and `std430`. */
+    readonly vertexSource: string;
+    /** GLSL ES 3.10 fragment source; storage blocks must be `readonly` and `std430`. */
+    readonly fragmentSource: string;
+    /** Complete read-only resource ABI shared by the two graphics stages. */
+    readonly bindings: readonly ShaderReadBinding[];
+}
+/** Internal adapter for a preprocessed portable shader promoted into the storage-raster dialect. */
+interface PortableStorageGraphicsShaderDescriptor {
+    readonly label?: string;
+    /** Fully preprocessed GLSL ES 3.00 vertex source. */
+    readonly portableVertexSource: string;
+    /** Fully preprocessed GLSL ES 3.00 fragment source with constrained readonly storage blocks. */
+    readonly portableFragmentSource: string;
+    readonly bindings: readonly ShaderReadBinding[];
+}
+/**
+ * Immutable WebGPU-only graphics shader configuration for readonly storage-buffer rendering.
+ *
+ * Sources use the constrained GLSL ES 3.10 contract. Compilation still runs through the shared
+ * engine GLSL preprocessing and Naga translation path; this object never accepts hand-written
+ * graphics WGSL.
+ */
+declare class StorageGraphicsShader {
+    /** Stable diagnostic label, or an empty string. */
+    readonly label: string;
+    /** Immutable GLSL ES 3.10 vertex source. */
+    readonly vertexSource: string;
+    /** Immutable GLSL ES 3.10 fragment source. */
+    readonly fragmentSource: string;
+    /** Immutable bindings in group/binding order. */
+    readonly bindings: readonly ShaderReadBinding[];
+    /** Snapshot a WebGPU-only storage-aware graphics shader contract. */
+    constructor(descriptor: Readonly<StorageGraphicsShaderDescriptor>);
+}
+/**
+ * Promote fully preprocessed portable raster source at the single storage-graphics boundary.
+ * This keeps dynamic built-in material variants on the same GLSL/Naga path without admitting a
+ * second handwritten WGSL or raster-material tree.
+ *
+ * @internal
+ */
+declare function createStorageGraphicsShaderFromPortable(descriptor: Readonly<PortableStorageGraphicsShaderDescriptor>): StorageGraphicsShader;
+
 /** Optional renderer capabilities exposed only after their complete SRP/RHI path is available. */
 type RenderPipelineCapabilityName = 'storage-buffer' | 'storage-texture' | 'compute-pass' | 'indirect-draw';
 /** Portable texture roles available to creation-time requirement validation. */
@@ -5903,6 +6375,8 @@ interface RenderPipelineLimits {
     readonly maxColorAttachments: number;
     /** Maximum sampled textures visible to one shader stage. */
     readonly maxSampledTexturesPerShaderStage: number;
+    /** Maximum samplers visible to one shader stage. */
+    readonly maxSamplersPerShaderStage: number;
     /** Maximum bind groups in one pipeline layout. */
     readonly maxBindGroups: number;
     /** Maximum bindings declared by one bind group. */
@@ -5931,20 +6405,26 @@ interface RenderPipelineLimits {
     readonly maxComputeWorkgroupSizeZ?: number;
     /** Maximum direct dispatch count in each dimension. */
     readonly maxComputeWorkgroupsPerDimension?: number;
+    /** Minimum native subgroup size when the optional subgroups feature is enabled. */
+    readonly subgroupMinSize?: number;
+    /** Maximum native subgroup size when the optional subgroups feature is enabled. */
+    readonly subgroupMaxSize?: number;
 }
 /** Frozen effective capabilities for one renderer device generation. */
 interface RenderPipelineCapabilities {
     /** Backend-neutral limit snapshot. */
     readonly limits: Readonly<RenderPipelineLimits>;
+    /** Return whether one optional renderer device feature is enabled for this generation. */
+    supportsFeature(feature: RendererFeatureName): boolean;
     /** Return whether an optional pipeline capability is fully implemented end to end. */
     supportsCapability(capability: RenderPipelineCapabilityName): boolean;
     /** Return whether a texture format supports a portable role and sample count. */
-    supportsTextureFormat(format: RenderTargetColorFormat | RenderTargetDepthStencilFormat, use: RenderPipelineTextureUse, sampleCount?: RenderTargetSampleCount): boolean;
+    supportsTextureFormat(format: RenderPipelineTextureFormat, use: RenderPipelineTextureUse, sampleCount?: RenderTargetSampleCount): boolean;
 }
 /** One texture-format constraint validated before the pipeline runtime is created. */
 interface RenderPipelineTextureRequirement {
     /** Required portable format. */
-    readonly format: RenderTargetColorFormat | RenderTargetDepthStencilFormat;
+    readonly format: RenderPipelineTextureFormat;
     /** Required graph or pass role. */
     readonly use: RenderPipelineTextureUse;
     /** Required sample count, defaulting to one. */
@@ -5965,6 +6445,16 @@ interface RenderPipelineRequirements {
 interface RenderPipelineCreateContext {
     /** Capabilities for the selected device generation. */
     readonly capabilities: RenderPipelineCapabilities;
+    /**
+     * Create a renderer-owned persistent storage buffer during pipeline initialization.
+     *
+     * The returned identity participates in normal device-loss recovery and must be destroyed by
+     * the pipeline runtime. Creation-time allocation keeps fixed GPU databases out of frame
+     * recording while avoiding native backend access.
+     */
+    createStorageBuffer(descriptor: Readonly<StorageBufferDescriptor>): StorageBuffer;
+    /** Translate and validate storage-aware raster variants before the first application frame. */
+    warmupStorageGraphicsShaders(shaders: readonly StorageGraphicsShader[], batchSize?: number): Promise<void>;
 }
 /** Attachment operations selected for one physical output color attachment. */
 interface RenderPipelineOutputColorAttachment {
@@ -6016,6 +6506,97 @@ interface RenderPipelineOutput {
     /** Return the selected load, store, and clear policy for one output color attachment. */
     colorAttachment(index: number): Readonly<RenderPipelineOutputColorAttachment>;
 }
+/** Frame-scoped shared shadow-atlas data available to custom and built-in pipelines. */
+interface RenderPipelineShadowResources {
+    /** Exact graph texture written by the recorded shadow passes. */
+    readonly atlas: RenderGraphTextureHandle;
+    /** Atlas dimensions and reciprocal dimensions as `[width, height, 1/width, 1/height]`. */
+    readonly atlasSize: Float32Array;
+    /** Top-left atlas rectangles as packed `[scaleX, scaleY, offsetX, offsetY]` values. */
+    readonly atlasRects: Float32Array;
+    /** Depth convention used by the atlas texture and comparison sampler. */
+    readonly depthMode: CameraDepthMode;
+    /** Shadow-first directional-light order used by the packed directional arrays. */
+    readonly directionalLights: readonly DirectionalLight[];
+    /** Shadow-first spot-light order used by the packed spot arrays. */
+    readonly spotLights: readonly SpotLight[];
+    /** Shadow-first point-light order used by the packed point arrays. */
+    readonly pointLights: readonly PointLight[];
+    /** Number of leading directional lights with valid packed shadow data. */
+    readonly directionalShadowCount: number;
+    /** Number of leading spot lights with valid packed shadow data. */
+    readonly spotShadowCount: number;
+    /** Number of leading point lights with valid packed shadow data. */
+    readonly pointShadowCount: number;
+    /** Directional minimum/slope bias pairs in shadow-first light order. */
+    readonly directionalBiases: Float32Array;
+    /** Four cascade far distances per directional light. */
+    readonly directionalCascadeSplits: Float32Array;
+    /** Cascade count, blend fraction, and shadow strength per directional light. */
+    readonly directionalCascadeParams: Float32Array;
+    /** View-space-to-shadow-clip matrices for every directional cascade. */
+    readonly directionalCascadeMatrices: Float32Array;
+    /** Spot minimum/slope bias pairs in shadow-first light order. */
+    readonly spotBiases: Float32Array;
+    /** View-space-to-shadow-clip matrices for shadowed spot lights. */
+    readonly spotMatrices: Float32Array;
+    /** Point minimum/slope bias pairs in shadow-first light order. */
+    readonly pointBiases: Float32Array;
+    /** Six view-space-to-shadow-clip face matrices per shadowed point light. */
+    readonly pointMatrices: Float32Array;
+    /** Physical atlas slices in dense render order. Values are valid only for this invocation. */
+    readonly slices: readonly Readonly<RenderPipelineShadowSlice>[];
+    /** Page-granular atlas updates recorded this frame, in render order. */
+    readonly pageRegions: readonly Readonly<RenderPipelineShadowPageRegion>[];
+}
+/** One frame-scoped physical page update within a shadow slice. */
+interface RenderPipelineShadowPageRegion {
+    /** Dense physical slice containing this page. */
+    readonly slicePhysicalIndex: number;
+    /** Zero-based horizontal virtual-page coordinate within the slice. */
+    readonly pageX: number;
+    /** Zero-based vertical virtual-page coordinate within the slice. */
+    readonly pageY: number;
+    /** Physical atlas X origin in pixels. */
+    readonly x: number;
+    /** Physical atlas Y origin in pixels. */
+    readonly y: number;
+    /** Physical page width in pixels; edge pages may be smaller than the page size. */
+    readonly width: number;
+    /** Physical page height in pixels; edge pages may be smaller than the page size. */
+    readonly height: number;
+}
+/** One frame-scoped shadow-atlas slice exposed for GPU-driven caster work. */
+interface RenderPipelineShadowSlice {
+    /** Light projection represented by the slice. */
+    readonly kind: 'directional' | 'spot' | 'point';
+    /** Stable LightBlock ABI index. */
+    readonly sliceIndex: number;
+    /** Dense physical placement index within the atlas. */
+    readonly physicalIndex: number;
+    /** Point-light cube face, or null for planar shadows. */
+    readonly face: number | null;
+    /** Directional cascade index, or null for local lights. */
+    readonly cascade: number | null;
+    /** Atlas viewport as `[x, y, width, height]`. */
+    readonly viewport: RendererViewport;
+    /** World-space to shadow clip-space transform. */
+    readonly viewProjectionMatrix: Float32Array;
+    /** Shadow-camera near plane. */
+    readonly near: number;
+    /** Shadow-camera far plane. */
+    readonly far: number;
+    /** Whether the submission-aware cache scheduled this slice for update. */
+    readonly dirty: boolean;
+}
+/** Optional hybrid-shadow selection used by GPU-managed pipelines. */
+interface RenderPipelineShadowOptions {
+    /**
+     * Mesh identities omitted from CPU shadow draws while remaining part of cache invalidation.
+     * The caller must record equivalent atlas writes for every exposed `pageRegions` entry.
+     */
+    readonly excludeMeshes?: readonly Mesh[];
+}
 /** Frame-scoped recording context; retaining it after record() returns is an error. */
 interface RenderPipelineContext {
     /** Monotonic application frame index. */
@@ -6032,27 +6613,51 @@ interface RenderPipelineContext {
     readonly output: RenderPipelineOutput;
     /** Effective capabilities for the current device generation. */
     readonly capabilities: RenderPipelineCapabilities;
+    /** Whether scene depth uses the renderer's logarithmic depth encoding. */
+    readonly useLogDepth: boolean;
     /** Backend-neutral graph facade for this invocation. */
     readonly graph: ScriptableRenderGraph;
+    /** Update scene world matrices and the active camera without building a CPU render list. */
+    prepareScene(): void;
     /** Collect camera-visible scene meshes and lights into a frame-scoped handle. */
     cull(options?: Readonly<CullingOptions>): CullingResultsHandle;
     /** Select and sort a reusable draw list from current-frame culling results. */
     createRendererList(descriptor: Readonly<RendererListDescriptor>): RendererListHandle;
-    /** Record the shared directional, spot, and point-light shadow atlas for these results. */
-    recordShadows(cullingResults: CullingResultsHandle): void;
+    /**
+     * 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
+     * active. The returned arrays are frame-scoped and must not be retained after `record()`.
+     */
+    recordShadows(cullingResults: CullingResultsHandle, options?: Readonly<RenderPipelineShadowOptions>): Readonly<RenderPipelineShadowResources> | null;
     /** Acquire one runtime-owned, high-water reusable parameter slot. */
     acquirePassParameters<P extends object>(pool: RenderPassParameterPool<P>): P;
+    /**
+     * Stage a dirty upload to a pipeline-owned storage buffer before importing it into this graph.
+     * Failed frames retain the dirty CPU shadow for a later valid submission.
+     */
+    writeStorageBuffer(buffer: StorageBuffer, byteOffset: number, data: ArrayBufferView): void;
 }
 /** Renderer-local runtime created exactly once by a RenderPipelineFactory. */
 interface RenderPipeline {
     /** Human-readable runtime name used in diagnostics. */
     readonly name: string;
+    /** Whether this runtime needs Render Graph timing without external diagnostics. */
+    readonly usesRenderGraphTimeline?: boolean;
     /**
      * Record one invocation synchronously into the active application Render Graph.
      *
      * @returns An ignored synchronous value. Promise-like values are rejected before RHI execution.
      */
     record(context: RenderPipelineContext): unknown;
+    /** Commit CPU-side temporal state after the frame has submitted successfully. */
+    frameSubmitted?(frameIndex: number): void;
+    /** Roll back staged CPU-side temporal state after recording or submission failure. */
+    frameDiscarded?(frameIndex: number): void;
+    /**
+     * Consume opt-in Render Graph timing snapshots. GPU-ready snapshots arrive asynchronously
+     * after submission completion and may be used by renderer-local adaptive quality controllers.
+     */
+    recordRenderGraphTimeline?(snapshot: Readonly<RenderGraphTimelineSnapshot>): void;
     /** Release runtime-owned state exactly once during Renderer destruction. */
     destroy(): void;
 }
@@ -6070,8 +6675,10 @@ interface RenderPipelineFactory {
 type RendererAdapterPowerPreference = 'low-power' | 'high-performance';
 /** Backend-neutral context power policy; `default` is accepted by WebGL2 contexts. */
 type RendererContextPowerPreference = 'default' | RendererAdapterPowerPreference;
+/** Shared renderer policy bundle. `high-end` enables reversed-Z cameras and camera-relative GPU transforms. */
+type RendererRenderingProfile = 'portable' | 'high-end';
 /** Optional device capabilities that the renderer can request through the portable RHI. */
-type RendererFeatureName = 'texture-compression-bc' | 'texture-compression-etc2' | 'texture-compression-astc' | 'timestamp-query' | 'shader-f16' | 'depth32float-stencil8' | 'float32-filterable' | 'float32-blendable';
+type RendererFeatureName = 'texture-compression-bc' | 'texture-compression-etc2' | 'texture-compression-astc' | 'timestamp-query' | 'shader-f16' | 'subgroups' | 'depth32float-stencil8' | 'float32-filterable' | 'float32-blendable';
 /** Backend-independent construction options. */
 interface RendererCommonOptions {
     width?: number;
@@ -6086,12 +6693,19 @@ interface RendererCommonOptions {
     premultipliedAlpha?: boolean;
     failIfMajorPerformanceCaveat?: boolean;
     useLogDepth?: boolean;
+    /**
+     * Subtract one frame-wide camera origin from GPU camera/model transforms while preserving CPU
+     * world coordinates. This improves large-world precision and enables stable temporal inputs.
+     */
+    cameraRelative?: boolean;
+    /** Renderer policy bundle. Defaults to `portable`. */
+    renderingProfile?: RendererRenderingProfile;
     vertexPrecision?: ShaderPrecision;
     fragmentPrecision?: ShaderPrecision;
     fog?: Fog | null;
     offsetX?: number;
     offsetY?: number;
-    forceMaterial?: Material | null;
+    forceMaterial?: MaterialInstance | null;
     clearColor?: Color;
     /** Renderer-local scriptable pipeline factory. Defaults to ForwardRenderPipelineFactory. */
     renderPipeline?: RenderPipelineFactory;
@@ -6147,6 +6761,8 @@ declare class Renderer<Backend extends RendererBackend = RendererBackend> implem
     readonly lightManager: RendererContract['lightManager'];
     readonly resourceManager: RendererContract['resourceManager'];
     readonly renderTarget: RendererContract['renderTarget'];
+    readonly cameraRelative: RendererContract['cameraRelative'];
+    readonly renderingProfile: RendererContract['renderingProfile'];
     width: RendererContract['width'];
     height: RendererContract['height'];
     pixelRatio: RendererContract['pixelRatio'];
@@ -6428,6 +7044,14 @@ declare class Node extends EventDispatcher {
      * @returns this
      */
     removeFromParent(): this;
+    /**
+     * Reset this node's previous-frame transform on its next submitted render.
+     *
+     * Call this after a discontinuous teleport, origin shift, camera cut, or animation reset so
+     * temporal effects receive `previous === current` instead of a false motion vector.
+     * @returns this
+     */
+    invalidateTransformHistory(): this;
     /**
      * 更新本地矩阵
      * @returns this
@@ -6807,247 +7431,141 @@ declare class SphericalHarmonics3 {
     copy(other: SphericalHarmonics3): this;
 }
 
-interface PBRMaterialParameters extends MaterialParameters {
-    lightType?: 'PBR' | 'NONE';
-    baseColor?: Color;
-    baseColorMap?: Texture | null;
-    metallic?: number;
-    metallicMap?: Texture | null;
-    roughness?: number;
-    roughnessMap?: Texture | null;
-    metallicRoughnessMap?: Texture | null;
-    occlusionMap?: Texture | null;
-    occlusionStrength?: number;
-    isOcclusionInMetallicRoughnessMap?: boolean;
-    diffuseEnvMap?: MaterialTexture | null;
-    diffuseEnvSphereHarmonics3?: SphericalHarmonics3 | null;
-    diffuseEnvIntensity?: number;
-    brdfLUT?: Texture | null;
-    specularEnvIntensity?: number;
-    specularEnvMap?: MaterialTexture | null;
-    isSpecularEnvMapIncludeMipmaps?: boolean;
-    emission?: MaterialTextureValue;
-    emissionFactor?: Color;
-    isSpecularGlossiness?: boolean;
-    specular?: Color;
-    glossiness?: number;
-    specularGlossinessMap?: Texture | null;
-    lightMap?: Texture | null;
-    clearcoatFactor?: number;
-    clearcoatMap?: Texture | null;
-    clearcoatRoughnessFactor?: number;
-    clearcoatRoughnessMap?: Texture | null;
-    clearcoatNormalMap?: Texture | null;
-    clearcoatNormalScale?: number;
-    anisotropyStrength?: number;
-    anisotropyRotation?: number;
-    anisotropyMap?: Texture | null;
-    transmissionFactor?: number;
-    transmissionMap?: Texture | null;
-    thicknessFactor?: number;
-    thicknessMap?: Texture | null;
-    attenuationDistance?: number;
-    attenuationColor?: Color;
-    ior?: number;
-    iridescenceFactor?: number;
-    iridescenceMap?: Texture | null;
-    iridescenceIor?: number;
-    iridescenceThicknessMinimum?: number;
-    iridescenceThicknessMaximum?: number;
-    iridescenceThicknessMap?: Texture | null;
-}
-/**
- * PBR材质
- * @example
- * ```ts
- * const material = new Hilo3d.PBRMaterial();
- * ```
- */
-declare class PBRMaterial extends Material {
-    isPBRMaterial: boolean;
+type PBRMaterialTextureInput = Texture<unknown> | MaterialTextureSlotInput | null;
+interface PBRMaterialParameters extends MaterialInstanceParameters {
+    /** Compile the standard surface without lighting. */
+    readonly unlit?: boolean;
+    readonly baseColor?: Color;
+    readonly baseColorMap?: PBRMaterialTextureInput;
+    readonly metallic?: number;
+    readonly metallicMap?: PBRMaterialTextureInput;
+    readonly roughness?: number;
+    readonly roughnessMap?: PBRMaterialTextureInput;
+    readonly metallicRoughnessMap?: PBRMaterialTextureInput;
+    readonly occlusionMap?: PBRMaterialTextureInput;
+    readonly occlusionStrength?: number;
+    readonly isOcclusionInMetallicRoughnessMap?: boolean;
+    readonly diffuseEnvMap?: MaterialTexture | MaterialTextureSlotInput | null;
+    readonly diffuseEnvSphereHarmonics3?: SphericalHarmonics3 | null;
+    readonly diffuseEnvIntensity?: number;
+    readonly brdfLUT?: Texture | null;
+    readonly specularEnvIntensity?: number;
+    readonly specularEnvMap?: MaterialTexture | MaterialTextureSlotInput | null;
+    readonly isSpecularEnvMapIncludeMipmaps?: boolean;
+    readonly emission?: MaterialTextureValue | MaterialTextureSlotInput;
+    readonly emissionFactor?: Color;
+    readonly isSpecularGlossiness?: boolean;
+    readonly specular?: Color;
+    readonly glossiness?: number;
+    readonly specularGlossinessMap?: PBRMaterialTextureInput;
+    readonly lightMap?: PBRMaterialTextureInput;
+    readonly clearcoatFactor?: number;
+    readonly clearcoatMap?: PBRMaterialTextureInput;
+    readonly clearcoatRoughnessFactor?: number;
+    readonly clearcoatRoughnessMap?: PBRMaterialTextureInput;
+    readonly clearcoatNormalMap?: PBRMaterialTextureInput;
+    readonly clearcoatNormalScale?: number;
+    readonly anisotropyStrength?: number;
+    readonly anisotropyRotation?: number;
+    readonly anisotropyMap?: PBRMaterialTextureInput;
+    readonly transmissionFactor?: number;
+    readonly transmissionMap?: PBRMaterialTextureInput;
+    readonly thicknessFactor?: number;
+    readonly thicknessMap?: PBRMaterialTextureInput;
+    readonly attenuationDistance?: number;
+    readonly attenuationColor?: Color;
+    readonly ior?: number;
+    readonly iridescenceFactor?: number;
+    readonly iridescenceMap?: PBRMaterialTextureInput;
+    readonly iridescenceIor?: number;
+    readonly iridescenceThicknessMinimum?: number;
+    readonly iridescenceThicknessMaximum?: number;
+    readonly iridescenceThicknessMap?: PBRMaterialTextureInput;
+    readonly frontFace?: MaterialFrontFace;
+    readonly cullMode?: MaterialCullMode;
+    readonly state?: Partial<Readonly<MaterialPipelineState>>;
+}
+type MutablePBRMaterialParameters = {
+    -readonly [Name in keyof PBRMaterialParameters]: PBRMaterialParameters[Name];
+};
+/** Mutable import-time descriptor. It is finalized into one immutable-topology material instance. */
+declare class PBRMaterialBuilder {
+    readonly parameters: MutablePBRMaterialParameters;
+    constructor(initial?: Readonly<PBRMaterialParameters>);
+    build(): PBRMaterial;
+}
+/** Physically based standard-surface material with immutable shader topology. */
+declare class PBRMaterial extends MaterialInstance {
+    #private;
+    readonly isPBRMaterial = true;
     readonly className: string;
-    /**
-     * 光照类型，只能为 PBR 或 NONE
-     */
-    lightType: 'PBR' | 'NONE';
-    /**
-     * gammaCorrection
-     */
-    gammaCorrection: boolean;
-    /**
-     * 是否使用物理灯光
-     */
-    usePhysicsLight: boolean;
-    /**
-     * 基础颜色
-     */
-    baseColor: Color;
-    /**
-     * 基础颜色贴图(sRGB空间)
-     */
-    baseColorMap: Texture | null;
-    /**
-     * 金属度
-     */
-    metallic: number;
-    /**
-     * 金属度贴图
-     */
-    metallicMap: Texture | null;
-    /**
-     * 粗糙度
-     */
-    roughness: number;
-    /**
-     * 粗糙度贴图
-     */
-    roughnessMap: Texture | null;
-    /**
-     * 金属度及粗糙度贴图，金属度为B通道，粗糙度为G通道，可以指定R通道作为环境光遮蔽
-     */
-    metallicRoughnessMap: Texture | null;
-    /**
-     * 环境光遮蔽贴图
-     */
-    occlusionMap: Texture | null;
-    /**
-     * 环境光遮蔽强度
-     */
-    occlusionStrength: number;
-    /**
-     * 环境光遮蔽贴图(occlusionMap)包含在 metallicRoughnessMap 的R通道中
-     */
-    isOcclusionInMetallicRoughnessMap: boolean;
-    /**
-     * 漫反射辐照(Diffuse IBL)贴图
-     */
-    diffuseEnvMap: MaterialTexture | null;
-    /**
-     * 漫反射 SphericalHarmonics3
-     */
-    diffuseEnvSphereHarmonics3: SphericalHarmonics3 | null;
-    /**
-     * 漫反射环境强度
-     */
-    diffuseEnvIntensity: number;
-    /**
-     * BRDF lookup texture used with an environment reflection map.
-     */
-    brdfLUT: Texture | null;
-    /**
-     * 环境反射(Specular IBL)贴图强度
-     */
-    specularEnvIntensity: number;
-    /**
-     * 环境反射(Specular IBL)贴图
-     */
-    specularEnvMap: MaterialTexture | null;
-    /**
-     * 环境反射是否包含 mipmaps
-     */
-    isSpecularEnvMapIncludeMipmaps: boolean;
-    /**
-     * 放射光贴图(sRGB 空间)
-     */
-    emission: MaterialTextureValue;
-    /**
-     * The emissive color of the material.
-     */
-    emissionFactor: Color;
-    /**
-     * 是否基于反射光泽度的 PBR，具体见 [KHR_materials_pbrSpecularGlossiness]{@link https://github.com/KhronosGroup/glTF/tree/master/extensions/Khronos/KHR_materials_pbrSpecularGlossiness}
-     */
-    isSpecularGlossiness: boolean;
-    /**
-     * 镜面反射率，针对 isSpecularGlossiness 渲染
-     */
-    specular: Color;
-    /**
-     * 光泽度，针对 isSpecularGlossiness 渲染，默认PBR无效
-     */
-    glossiness: number;
-    /**
-     * 镜面反射即光泽度贴图，RGB 通道为镜面反射率，A 通道为光泽度
-     */
-    specularGlossinessMap: Texture | null;
-    lightMap: Texture | null;
-    /**
-     * The clearcoat layer intensity.
-     */
-    clearcoatFactor: number;
-    /**
-     * The clearcoat layer intensity texture.
-     */
-    clearcoatMap: Texture | null;
-    /**
-     * The clearcoat layer roughness.
-     */
-    clearcoatRoughnessFactor: number;
-    /**
-     * The clearcoat layer roughness texture.
-     */
-    clearcoatRoughnessMap: Texture | null;
-    /**
-     * The clearcoat normal map texture.
-     */
-    clearcoatNormalMap: Texture | null;
-    /** Scale applied to the clearcoat normal texture XY channels. */
-    clearcoatNormalScale: number;
-    /** Strength of the anisotropic GGX lobe in the range [0, 1]. */
-    anisotropyStrength: number;
-    /** Counter-clockwise anisotropy direction rotation in tangent space, in radians. */
-    anisotropyRotation: number;
-    /** RG tangent-space direction and B strength texture from KHR_materials_anisotropy. */
-    anisotropyMap: Texture | null;
-    private _transmissionFactor;
-    /** Thin-surface transmission fraction in the range [0, 1]. */
+    readonly baseColor: Color;
+    readonly baseColorMap: Texture<unknown> | null;
+    readonly metallicMap: Texture<unknown> | null;
+    readonly roughnessMap: Texture<unknown> | null;
+    readonly metallicRoughnessMap: Texture<unknown> | null;
+    readonly occlusionMap: Texture<unknown> | null;
+    readonly isOcclusionInMetallicRoughnessMap: boolean;
+    readonly diffuseEnvMap: MaterialTexture | null;
+    readonly diffuseEnvSphereHarmonics3: SphericalHarmonics3 | null;
+    readonly brdfLUT: Texture<unknown> | null;
+    readonly specularEnvMap: MaterialTexture | null;
+    readonly isSpecularEnvMapIncludeMipmaps: boolean;
+    readonly emission: MaterialTextureValue;
+    readonly emissionFactor: Color;
+    readonly isSpecularGlossiness: boolean;
+    readonly specular: Color;
+    readonly specularGlossinessMap: Texture<unknown> | null;
+    readonly lightMap: Texture<unknown> | null;
+    readonly clearcoatMap: Texture<unknown> | null;
+    readonly clearcoatRoughnessMap: Texture<unknown> | null;
+    readonly clearcoatNormalMap: Texture<unknown> | null;
+    readonly anisotropyMap: Texture<unknown> | null;
+    readonly transmissionMap: Texture<unknown> | null;
+    readonly thicknessMap: Texture<unknown> | null;
+    readonly attenuationColor: Color;
+    readonly iridescenceMap: Texture<unknown> | null;
+    readonly iridescenceThicknessMap: Texture<unknown> | null;
+    constructor(params?: Readonly<PBRMaterialParameters>);
+    get metallic(): number;
+    set metallic(value: number);
+    get roughness(): number;
+    set roughness(value: number);
+    get occlusionStrength(): number;
+    set occlusionStrength(value: number);
+    get diffuseEnvIntensity(): number;
+    set diffuseEnvIntensity(value: number);
+    get specularEnvIntensity(): number;
+    set specularEnvIntensity(value: number);
+    get glossiness(): number;
+    set glossiness(value: number);
+    get clearcoatFactor(): number;
+    set clearcoatFactor(value: number);
+    get clearcoatRoughnessFactor(): number;
+    set clearcoatRoughnessFactor(value: number);
+    get clearcoatNormalScale(): number;
+    set clearcoatNormalScale(value: number);
+    get anisotropyStrength(): number;
+    set anisotropyStrength(value: number);
+    get anisotropyRotation(): number;
+    set anisotropyRotation(value: number);
     get transmissionFactor(): number;
     set transmissionFactor(value: number);
-    /** Linear R-channel transmission texture. */
-    transmissionMap: Texture | null;
-    /** Maximum volume thickness in scene units. */
-    thicknessFactor: number;
-    /** Linear G-channel thickness texture. */
-    thicknessMap: Texture | null;
-    /** Beer-Lambert attenuation distance; positive infinity disables attenuation. */
-    attenuationDistance: number;
-    /** Linear attenuation color reached after {@link PBRMaterial.attenuationDistance}. */
-    attenuationColor: Color;
-    /** Index of refraction used by screen-space volume refraction. */
-    ior: number;
-    /** Thin-film iridescence intensity in the range [0, 1]. */
-    iridescenceFactor: number;
-    /** Linear R-channel thin-film intensity texture. */
-    iridescenceMap: Texture | null;
-    /** Index of refraction of the thin-film layer. */
-    iridescenceIor: number;
-    /** Thin-film thickness represented by a zero texture sample, in nanometers. */
-    iridescenceThicknessMinimum: number;
-    /** Thin-film thickness represented by a one texture sample, in nanometers. */
-    iridescenceThicknessMaximum: number;
-    /** Linear G-channel thin-film thickness texture. */
-    iridescenceThicknessMap: Texture | null;
-    usedUniformVectors: number;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.lightType`: 光照类型，只能为 PBR 或 NONE
-     * - `params.baseColor`: 基础颜色
-     * - `params.baseColorMap`: 基础颜色贴图(sRGB空间)
-     * - `params.metallic`: 金属度
-     * - `params.metallicMap`: 金属度贴图
-     * - `params.roughness`: 粗糙度
-     * - `params.roughnessMap`: 粗糙度贴图
-     * - `params.occlusionMap`: 环境光遮蔽贴图
-     * - `params.occlusionStrength`: 环境光遮蔽强度
-     * - `params.emission`: 放射光贴图(sRGB 空间)，或颜色
-     * - `params.diffuseEnvMap`: 漫反射辐照(Diffuse IBL)贴图
-     * - `params.diffuseEnvSphereHarmonics3`: 漫反射 SphericalHarmonics3
-     * - `params.diffuseEnvIntensity`: 漫反射强度
-     * - `params.specularEnvMap`: 环境反射(Specular IBL)贴图
-     * - `params.brdfLUT`: BRDF贴图，跟环境反射贴图一起使用
-     * - `params.specularEnvIntensity`: 环境反射(Specular IBL)贴图强度
-     */
-    constructor(params?: PBRMaterialParameters);
+    get thicknessFactor(): number;
+    set thicknessFactor(value: number);
+    get attenuationDistance(): number;
+    set attenuationDistance(value: number);
+    get ior(): number;
+    set ior(value: number);
+    get iridescenceFactor(): number;
+    set iridescenceFactor(value: number);
+    get iridescenceIor(): number;
+    set iridescenceIor(value: number);
+    get iridescenceThicknessMinimum(): number;
+    set iridescenceThicknessMinimum(value: number);
+    get iridescenceThicknessMaximum(): number;
+    set iridescenceThicknessMaximum(value: number);
+    private assertTopologyFeature;
     getRenderOption(option?: ShaderOptions): ShaderOptions;
 }
 
@@ -7550,7 +8068,7 @@ interface GLTFModel {
     cameras: Camera[];
     lights: Light[];
     textures: Texture[];
-    materials: Material[];
+    materials: MaterialInstance[];
     anim?: Animation;
     bounds?: GLTFBounds;
     /** Settles when progressive textures and compressed geometry finish. */
@@ -7619,10 +8137,12 @@ interface GLTFParserParameters {
     ignoreTextureError?: boolean;
     forceCreateNewBuffer?: boolean;
     useInstanced?: boolean;
+    /** Defaults copied into every glTF 2 PBR material before asset data and extensions apply. */
+    pbrMaterialDefaults?: Readonly<PBRMaterialParameters>;
     preHandlerImageURI?: ((uri: string, image: GLTFImage) => string) | null;
     preHandlerBufferURI?: ((uri: string, buffer: GLTFBuffer) => string) | null;
     preHandlerShaderURI?: ((uri: string, index: GLTFIndex, shader: unknown) => string) | null;
-    customMaterialCreator?: ((name: string, material: GLTFMaterial, json: GLTFRoot, parser: GLTFParser) => Material | null | undefined) | null;
+    customMaterialCreator?: ((name: string, material: GLTFMaterial, json: GLTFRoot, parser: GLTFParser) => MaterialInstance | null | undefined) | null;
     extensionHandlers?: Readonly<GLTFExtensionHandlerRegistry> | null;
 }
 type AccessorArray = (number | number[])[];
@@ -7645,6 +8165,7 @@ declare class GLTFParser {
     ignoreTextureError: boolean;
     forceCreateNewBuffer: boolean;
     useInstanced: boolean;
+    pbrMaterialDefaults: Readonly<PBRMaterialParameters>;
     preHandlerImageURI: GLTFParserParameters['preHandlerImageURI'];
     preHandlerBufferURI: GLTFParserParameters['preHandlerBufferURI'];
     preHandlerShaderURI: GLTFParserParameters['preHandlerShaderURI'];
@@ -7658,7 +8179,7 @@ declare class GLTFParser {
     buffers: Record<string, ArrayBuffer>;
     bufferViews: Record<string, GLTFBufferViewRuntime>;
     textures: Record<string, Texture>;
-    materials: Record<string, Material>;
+    materials: Record<string, MaterialInstance>;
     cameras: Record<string, Camera>;
     meshes: Mesh[];
     lights: Light[];
@@ -7705,10 +8226,12 @@ declare class GLTFParser {
     getBufferView(name: GLTFIndex): GLTFBufferViewRuntime;
     getTexture(textureInfo: GLTFTextureInfo): Texture | null;
     getColorOrTexture(value: GLTFMaterialValue | undefined): Color | Texture | null;
-    parseMaterialCommonProps(material: Material, materialData: GLTFMaterial): void;
-    createPBRMaterial(materialData: GLTFMaterial): PBRMaterial;
-    private requirePBRMaterial;
-    private parseTextureTransform;
+    private parseMaterialCommonProps;
+    createPBRMaterial(materialData: GLTFMaterial): PBRMaterialBuilder;
+    private requirePBRMaterialBuilder;
+    getTextureSlot(textureInfo: GLTFTextureInfo): MaterialTextureSlotInput | null;
+    private slotForTexture;
+    private createTextureSlot;
     private createKMCMaterial;
     parseMaterials(): void;
     sparseAccessorHandler(data: GeometryData, sparse: GLTFSparseAccessor): GeometryData;
@@ -7718,7 +8241,6 @@ declare class GLTFParser {
     setAccessorDecodeMatrix(data: GeometryData, matrix: readonly number[]): void;
     getAccessorDecodeMatrix(data: GeometryData): number[] | undefined;
     getArrayByAccessor(name: GLTFIndex, isDecode?: boolean): AccessorArray;
-    parseTechnique(materialData: GLTFMaterial, material: Material): void;
     createMorphGeometry(primitive: GLTFPrimitive, weights?: readonly number[]): MorphGeometry;
     private geometryTargetName;
     handlerGeometry(initial: Geometry | undefined, primitive: GLTFPrimitive): Geometry | Promise<Geometry>;
@@ -7756,30 +8278,30 @@ declare const ALI_bounding_box: {
 };
 declare const KHR_materials_pbrSpecularGlossiness: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_clearcoat: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_anisotropy: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_transmission: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_volume: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_ior: {
-    parse(extensionData: unknown, _parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, _parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_materials_iridescence: {
     getUsedTextureNameMap(extensionData: unknown, map: Record<string, true>): void;
-    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterial;
+    parse(extensionData: unknown, parser: GLTFParser, result: unknown): PBRMaterialBuilder;
 };
 declare const KHR_lights_punctual: {
     parse(extensionData: unknown, parser: GLTFParser, result: unknown): Node;
@@ -7940,56 +8462,6 @@ declare namespace util_d {
   export type { util_d_GeometryDataLike as GeometryDataLike, util_d_MutableArrayLike as MutableArrayLike, util_d_TypedArray as TypedArray, util_d_TypedArrayConstructor as TypedArrayConstructor };
 }
 
-interface SkinnedMeshParameters extends MeshParameters {
-    skeleton?: Skeleton | null;
-}
-/**
- * 蒙皮Mesh
- */
-declare class SkinnedMesh extends Mesh {
-    static readonly typeName: string;
-    private jointMat;
-    private clonedFrom;
-    isSkinnedMesh: boolean;
-    className: string;
-    /**
-     * 是否支持 Instanced
-     */
-    useInstanced: boolean;
-    /**
-     * 是否开启视锥体裁剪
-     */
-    frustumTest: boolean;
-    /**
-     * 骨架
-     */
-    skeleton: Skeleton | null;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.geometry`: 几何体
-     * - `params.material`: 材质
-     * - `params.skeleton`: 骨骼
-     */
-    constructor(params?: SkinnedMeshParameters);
-    /**
-     * 获取每个骨骼对应的矩阵数组
-     * @returns 返回矩阵数组
-     */
-    getJointMat(): Float32Array;
-    /**
-     * 用新骨骼的 node name 重设 jointNames
-     * @param skeleton - 新骨架
-     */
-    resetJointNamesByNodeName(skeleton: Skeleton): void;
-    /**
-     * 用新骨骼重置skinIndices
-     * @param skeleton -
-     */
-    resetSkinIndices(skeleton: Skeleton): void;
-    clone(isChild?: boolean): SkinnedMesh;
-    getRenderOption(opt?: ShaderOptions): ShaderOptions;
-}
-
 type DOMViewport = ReturnType<typeof getElementRect>;
 interface StageCommonParameters extends NodeParameters {
     container?: HTMLElement;
@@ -8007,6 +8479,8 @@ interface StageCommonParameters extends NodeParameters {
     clearColor?: Color;
     useInstanced?: boolean;
     useLogDepth?: boolean;
+    /** Renderer policy bundle. `high-end` enables reversed-Z and camera-relative transforms. */
+    renderingProfile?: RendererRenderingProfile;
     alpha?: boolean;
     depth?: boolean;
     stencil?: boolean;
@@ -8016,6 +8490,8 @@ interface StageCommonParameters extends NodeParameters {
     gameMode?: boolean;
     /** Renderer-local scriptable pipeline factory snapshotted during Stage.create(). */
     renderPipeline?: RenderPipelineFactory;
+    /** Optional Stage Systems initialized transactionally before `Stage.create()` resolves. */
+    systems?: readonly StageSystem[];
 }
 /** Requested backend policy. `auto` probes WebGPU first and otherwise selects WebGL 2. */
 type StageBackend = RendererBackend | 'auto';
@@ -8073,6 +8549,8 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      * 渲染器
      */
     renderer: Renderer<Backend>;
+    /** Per-Stage scheduler and service registry for optional addon Systems. */
+    readonly systems: StageSystemRegistry;
     /** Resolves when the selected graphics backend is ready for rendering. */
     readonly ready: Promise<void>;
     /** Ordered cameras rendered by `tick()`. */
@@ -8175,6 +8653,11 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      * @returns 舞台本身。链式调用支持。
      */
     tick(dt: number): this;
+    /** Install one optional addon after this Stage is ready. */
+    installSystem(system: StageSystem): Promise<this>;
+    /** Remove one leaf addon System. Hard dependants must be removed first. */
+    uninstallSystem(id: string): this;
+    private prepareAddonRendererResources;
     /**
      * Replace the ordered camera composition.
      * @param cameras - Unique Camera instances in back-to-front render order.
@@ -8186,45 +8669,210 @@ declare class Stage<Backend extends RendererBackend = RendererBackend> extends N
      */
     addCamera(camera: Camera): this;
     /**
-     * Remove a camera from the composition.
-     * @param camera - Camera to remove.
+     * Remove a camera from the composition.
+     * @param camera - Camera to remove.
+     */
+    removeCamera(camera: Camera): this;
+    /**
+     * 开启/关闭舞台的DOM事件响应。要让舞台上的可视对象响应用户交互，必须先使用此方法开启舞台的相应事件的响应。
+     * @param types - 要开启/关闭的事件名称或数组。
+     * @param enabled - 指定开启还是关闭。如果不传此参数，则默认为开启。
+     * @returns 舞台本身。链式调用支持。
+     */
+    enableDOMEvent(types: string | readonly string[], enabled?: boolean): this;
+    private updateTouchAction;
+    /**
+     * DOM事件处理函数。此方法会把事件调度到事件的坐标点所对应的可视对象。
+     */
+    private _onDOMEvent;
+    /**
+     * 更新 DOM viewport
+     * @returns DOM viewport，格式为 `{ left, top, right, bottom }`
+     */
+    updateDomViewport(): DOMViewport;
+    /**
+     * 获取指定点的 mesh
+     * @param x -
+     * @param y -
+     * @param eventMode -
+     */
+    getMeshResultAtPoint(x: number, y: number, eventMode?: boolean): NodeRaycastInfo | null;
+    private sortCameras;
+    /**
+     * 释放当前图形后端资源。
+     * @returns this
+     */
+    releaseGPUResources(): this;
+    /**
+     * 销毁
+     * @returns this
+     */
+    destroy(): this;
+}
+
+/** Stage System ABI implemented by this Hilo3D release. */
+declare const STAGE_SYSTEM_API_VERSION: 1;
+/** Typed identity used by systems to publish services without string-key collisions. */
+declare class StageSystemService<T> {
+    /** Human-readable token name used in diagnostics. */
+    readonly name: string;
+    private readonly serviceType;
+    constructor(name: string);
+}
+/** Create a typed service identity shared by a provider and its consumers. */
+declare function createStageSystemService<T>(name: string): StageSystemService<T>;
+/** Immutable metadata compiled before System setup begins. */
+interface StageSystemDescriptor {
+    /** Stable, package-qualified System identity. */
+    readonly id: string;
+    /** System implementation version for diagnostics. */
+    readonly version: string;
+    /** Exact Hilo3D Stage System ABI expected by this System. */
+    readonly apiVersion: typeof STAGE_SYSTEM_API_VERSION;
+    /** System identities that must be present, initialized first, and destroyed last. */
+    readonly requires?: readonly string[];
+    /** Optional System identities that this System runs before when they are present. */
+    readonly before?: readonly string[];
+    /** Optional System identities that this System runs after when they are present. */
+    readonly after?: readonly string[];
+    /** Complete set of typed services published during setup. */
+    readonly provides?: readonly StageSystemService<unknown>[];
+}
+/** Context available only while a System factory is being initialized. */
+interface StageSystemSetupContext {
+    /** Stage that owns this System runtime. */
+    readonly stage: Stage;
+    /** Publish one descriptor-declared service. */
+    provide<T>(service: StageSystemService<T>, value: T): void;
+    /** Read a required service published by an initialized dependency. */
+    get<T>(service: StageSystemService<T>): T;
+    /** Read an optional service published by an initialized dependency. */
+    getOptional<T>(service: StageSystemService<T>): T | undefined;
+}
+/** Synchronous phase hooks owned by one initialized Stage System. */
+interface StageSystemRuntime {
+    /** Run before scene-node updates for a frame. */
+    beforeUpdate?(deltaTimeMilliseconds: number): void;
+    /** Run after scene-node updates for a frame. */
+    afterUpdate?(deltaTimeMilliseconds: number): void;
+    /** Run immediately before rendering a frame. */
+    beforeRender?(): void;
+    /** Run after each render attempt, including a failed render. */
+    afterRender?(): void;
+    /** Release resources owned by this runtime. */
+    destroy?(): void;
+}
+/** Reusable factory. Each Stage receives a distinct runtime from `setup()`. */
+interface StageSystem {
+    /** Versioned identity, ordering, dependency, and service metadata. */
+    readonly descriptor: StageSystemDescriptor;
+    /** Create a fresh runtime for one Stage. */
+    setup(context: StageSystemSetupContext): StageSystemRuntime | Promise<StageSystemRuntime>;
+}
+/**
+ * Per-Stage System scheduler and service registry. Ordering is compiled only when the installed set
+ * changes; frame dispatch walks flat phase-specific callback arrays.
+ */
+declare class StageSystemRegistry {
+    /** Stage that owns this System registry. */
+    readonly stage: Stage;
+    private readonly installed;
+    private readonly installationOrder;
+    private readonly services;
+    private executionOrder;
+    private beforeUpdateHooks;
+    private afterUpdateHooks;
+    private beforeRenderHooks;
+    private afterRenderHooks;
+    private dispatching;
+    private initializing;
+    private settingUp;
+    private destroyingRuntime;
+    private initialized;
+    private destroyed;
+    constructor(stage: Stage);
+    /** Initialize an entire System set transactionally. Intended for `Stage.create()`. */
+    initialize(systems: readonly StageSystem[]): Promise<void>;
+    /** Install one System and recompile the frame schedule. */
+    install(system: StageSystem): Promise<void>;
+    /** Remove one leaf System. Hard dependants must be removed first. */
+    uninstall(id: string): void;
+    /** Return whether a System identity is currently installed. */
+    has(id: string): boolean;
+    /** Read an installed System runtime for diagnostics or explicit extension APIs. */
+    getRuntime(id: string): StageSystemRuntime | undefined;
+    /** Read a required typed service published by an installed System. */
+    get<T>(service: StageSystemService<T>): T;
+    /** Read a typed service when its provider is optional. */
+    getOptional<T>(service: StageSystemService<T>): T | undefined;
+    /** Dispatch the pre-update phase in compiled order. */
+    runBeforeUpdate(deltaTimeMilliseconds: number): void;
+    /** Dispatch the post-update phase in compiled order. */
+    runAfterUpdate(deltaTimeMilliseconds: number): void;
+    /** Dispatch the pre-render phase in compiled order. */
+    runBeforeRender(): void;
+    /** Dispatch the post-render phase in compiled order. */
+    runAfterRender(): void;
+    /** Destroy every runtime and its services in reverse compiled order. */
+    destroy(): void;
+    private installResolved;
+    private destroyInstalled;
+    private rebuildSchedule;
+    private clearSchedule;
+    private dispatchDelta;
+    private dispatch;
+    private beginDispatch;
+    private requireMutable;
+}
+
+interface SkinnedMeshParameters extends MeshParameters {
+    skeleton?: Skeleton | null;
+}
+/**
+ * 蒙皮Mesh
+ */
+declare class SkinnedMesh extends Mesh {
+    static readonly typeName: string;
+    private jointMat;
+    private clonedFrom;
+    isSkinnedMesh: boolean;
+    className: string;
+    /**
+     * 是否支持 Instanced
      */
-    removeCamera(camera: Camera): this;
+    useInstanced: boolean;
     /**
-     * 开启/关闭舞台的DOM事件响应。要让舞台上的可视对象响应用户交互，必须先使用此方法开启舞台的相应事件的响应。
-     * @param types - 要开启/关闭的事件名称或数组。
-     * @param enabled - 指定开启还是关闭。如果不传此参数，则默认为开启。
-     * @returns 舞台本身。链式调用支持。
+     * 是否开启视锥体裁剪
      */
-    enableDOMEvent(types: string | readonly string[], enabled?: boolean): this;
-    private updateTouchAction;
+    frustumTest: boolean;
     /**
-     * DOM事件处理函数。此方法会把事件调度到事件的坐标点所对应的可视对象。
+     * 骨架
      */
-    private _onDOMEvent;
+    skeleton: Skeleton | null;
     /**
-     * 更新 DOM viewport
-     * @returns DOM viewport，格式为 `{ left, top, right, bottom }`
+     * @param params - 初始化参数，所有params都会复制到实例上
+     * - `params.geometry`: 几何体
+     * - `params.material`: 材质
+     * - `params.skeleton`: 骨骼
      */
-    updateDomViewport(): DOMViewport;
+    constructor(params?: SkinnedMeshParameters);
     /**
-     * 获取指定点的 mesh
-     * @param x -
-     * @param y -
-     * @param eventMode -
+     * 获取每个骨骼对应的矩阵数组
+     * @returns 返回矩阵数组
      */
-    getMeshResultAtPoint(x: number, y: number, eventMode?: boolean): NodeRaycastInfo | null;
-    private sortCameras;
+    getJointMat(): Float32Array;
     /**
-     * 释放当前图形后端资源。
-     * @returns this
+     * 用新骨骼的 node name 重设 jointNames
+     * @param skeleton - 新骨架
      */
-    releaseGPUResources(): this;
+    resetJointNamesByNodeName(skeleton: Skeleton): void;
     /**
-     * 销毁
-     * @returns this
+     * 用新骨骼重置skinIndices
+     * @param skeleton -
      */
-    destroy(): this;
+    resetSkinIndices(skeleton: Skeleton): void;
+    clone(isChild?: boolean): SkinnedMesh;
+    getRenderOption(opt?: ShaderOptions): ShaderOptions;
 }
 
 type TweenEaseFunction = (ratio: number) => number;
@@ -8484,6 +9132,122 @@ declare class PerspectiveCamera extends Camera {
     getGeometry(forceUpdate?: boolean): Geometry;
 }
 
+/** Configuration for {@link OrbitControls}. */
+interface OrbitControlsOptions {
+    /** Perspective camera to control. Defaults to the Stage primary camera. */
+    camera?: PerspectiveCamera;
+    /** Orbit center in the camera parent's coordinate space. */
+    target?: Vector3;
+    /** Whether event listeners are attached immediately. Defaults to `true`. */
+    enabled?: boolean;
+    /** Whether pointer gestures can orbit the camera. Defaults to `true`. */
+    enableRotate?: boolean;
+    /** Whether wheel and pinch gestures can dolly the camera. Defaults to `true`. */
+    enableZoom?: boolean;
+    /** Whether secondary-drag, Shift-drag, and two-finger gestures can pan. Defaults to `true`. */
+    enablePan?: boolean;
+    /** Orbit sensitivity multiplier. Defaults to `1`. */
+    rotateSpeed?: number;
+    /** Dolly sensitivity multiplier. Defaults to `1`. */
+    zoomSpeed?: number;
+    /** Pan sensitivity multiplier. Defaults to `1`. */
+    panSpeed?: number;
+    /** Minimum camera distance from the target. Defaults to the camera near plane. */
+    minDistance?: number;
+    /** Maximum camera distance from the target. Defaults to positive infinity. */
+    maxDistance?: number;
+    /** Minimum polar orbit angle in radians. */
+    minPolarAngle?: number;
+    /** Maximum polar orbit angle in radians. */
+    maxPolarAngle?: number;
+}
+/**
+ * Camera-centric orbit, dolly, and pan controls for a {@link PerspectiveCamera}.
+ *
+ * Mouse: drag to orbit, right-drag or Shift-drag to pan, and wheel to dolly.
+ * Touch: drag with one finger to orbit, or use two fingers to pan and pinch-to-dolly.
+ */
+declare class OrbitControls {
+    /** Stage that owns the controlled canvas and default camera. */
+    readonly stage: Stage;
+    /** Canvas that receives pointer, wheel, and touch events. */
+    readonly canvas: HTMLCanvasElement;
+    /** Perspective camera manipulated by these controls. */
+    readonly camera: PerspectiveCamera;
+    /** Mutable orbit center in the camera parent's coordinate space. */
+    readonly target: Vector3;
+    /** Whether orbit gestures are accepted. */
+    enableRotate: boolean;
+    /** Whether dolly gestures are accepted. */
+    enableZoom: boolean;
+    /** Whether pan gestures are accepted. */
+    enablePan: boolean;
+    /** Orbit sensitivity multiplier. */
+    rotateSpeed: number;
+    /** Dolly sensitivity multiplier. */
+    zoomSpeed: number;
+    /** Pan sensitivity multiplier. */
+    panSpeed: number;
+    /** Minimum camera distance from the target. */
+    minDistance: number;
+    /** Maximum camera distance from the target. */
+    maxDistance: number;
+    /** Minimum polar orbit angle in radians. */
+    minPolarAngle: number;
+    /** Maximum polar orbit angle in radians. */
+    maxPolarAngle: number;
+    /** Whether browser event listeners are currently attached. */
+    isEnabled: boolean;
+    /** Optional callback invoked after the controls change the camera view. */
+    onChange: (() => void) | undefined;
+    private readonly initialCameraPosition;
+    private readonly initialTarget;
+    private readonly pointers;
+    private readonly offset;
+    private readonly right;
+    private readonly up;
+    private readonly panOffset;
+    private readonly initialTouchAction;
+    /** Create controls for a stage and optionally attach their browser event listeners. */
+    constructor(stage: Stage, options?: OrbitControlsOptions);
+    /** Attach pointer, wheel, touch, and context-menu listeners to the canvas. */
+    enable(): void;
+    /** Detach all listeners and restore the canvas touch-action style. */
+    disable(): void;
+    /** Release the browser event listeners owned by these controls. */
+    dispose(): void;
+    /** Reorient the camera toward the target and enforce the configured orbit limits. */
+    update(): void;
+    /** Replace the orbit center and reorient the camera toward it. */
+    setTarget(target: Vector3): void;
+    /**
+     * Set a complete camera view while applying the configured orbit limits.
+     *
+     * This is useful for scripted tours that should share the same camera contract as pointer
+     * interaction.
+     */
+    setView(position: Vector3, target: Vector3): void;
+    /** Orbit by a pointer delta measured in CSS pixels. */
+    rotate(deltaX: number, deltaY: number): void;
+    /**
+     * Move the camera toward its target. Values above one zoom in; values below one zoom out.
+     */
+    dolly(scale: number): void;
+    /** Pan in screen pixels while preserving the camera-to-target offset. */
+    pan(deltaX: number, deltaY: number): void;
+    /** Restore the camera position and target captured at construction time. */
+    reset(): void;
+    private validateLimits;
+    private readSpherical;
+    private applySpherical;
+    private readonly preventContextMenu;
+    private readonly handlePointerDown;
+    private readonly handlePointerMove;
+    private readonly handlePointerEnd;
+    private readonly handleWheel;
+    private readGesture;
+}
+
 interface BoxGeometryParameters extends GeometryParameters {
     width?: number;
     height?: number;
@@ -8695,85 +9459,35 @@ declare class SpriteFrame {
     writeUVRect(target: Float32Array): Float32Array;
 }
 
-type CustomRenderOptionProvider = (option: ShaderOptions) => ShaderOptions;
-interface ShaderMaterialParameters extends MaterialParameters {
-    vs?: string;
-    fs?: string;
-    useHeaderCache?: boolean;
-    getCustomRenderOption?: CustomRenderOptionProvider | null;
-}
-/**
- * Native GLSL ES 3.00 shader material.
- *
- * Numeric, vector and matrix data must be supplied through registered std140 uniform blocks.
- * Opaque sampler types are the only uniforms permitted outside a block.
- *
- * @example
- * ```ts
- * Hilo3d.registerUniformBlockBinding('EffectBlock');
- * const effectLayout = Hilo3d.createStd140Layout({
- *     effectColor: 'vec4',
- *     strength: 'float'
- * });
- * const effectBlock = Hilo3d.UniformBuffer.fromSchema(effectLayout, {
- *     effectColor: [0.6, 0.8, 1, 1],
- *     strength: 0.75
- * });
- *
- * const material = new Hilo3d.ShaderMaterial({
- *     attributes: { a_position: 'POSITION' },
- *     uniformBlocks: { EffectBlock: effectBlock },
- *     vs: `#version 300 es
- *         layout(std140) uniform EffectBlock {
- *             vec4 effectColor;
- *             float strength;
- *         };
- *         in vec3 a_position;
- *         out vec4 v_color;
- *         void main() {
- *             v_color = vec4(effectColor.rgb * strength, effectColor.a);
- *             gl_Position = vec4(a_position, 1.0);
- *         }`,
- *     fs: `#version 300 es
- *         precision highp float;
- *         layout(std140) uniform EffectBlock {
- *             vec4 effectColor;
- *             float strength;
- *         };
- *         in vec4 v_color;
- *         layout(location = 0) out vec4 outColor;
- *         void main() {
- *             outColor = v_color;
- *         }`
- * });
- *
- * effectBlock.set('strength', 1);
- * ```
- */
-declare class ShaderMaterial extends Material {
-    isShaderMaterial: boolean;
+interface ShaderMaterialRoleSource {
+    readonly role: MaterialPassRole;
+    readonly vertexSource: string;
+    readonly fragmentSource: string;
+    readonly fragmentOutput: MaterialFragmentOutput;
+    readonly fallback?: MaterialPassFallback;
+}
+interface ShaderMaterialTextureSlot {
+    readonly definition: Readonly<MaterialTextureSlotDefinition>;
+    readonly binding: MaterialTextureSlotInput;
+}
+interface ShaderMaterialParameters extends MaterialInstanceParameters {
+    readonly vs: string;
+    readonly fs: string;
+    readonly sourceRevision?: string;
+    readonly defines?: Readonly<Record<string, number>>;
+    readonly roles?: readonly Readonly<ShaderMaterialRoleSource>[];
+    readonly textureSlots?: readonly Readonly<ShaderMaterialTextureSlot>[];
+    readonly attributes?: Readonly<MaterialBindingMap>;
+    readonly uniforms?: Readonly<MaterialBindingMap>;
+    readonly frontFace?: MaterialFrontFace;
+    readonly cullMode?: MaterialCullMode;
+    readonly state?: Partial<Readonly<MaterialPipelineState>>;
+}
+/** Typed GLSL material whose source, roles and layout are immutable after construction. */
+declare class ShaderMaterial extends MaterialInstance {
+    readonly isShaderMaterial = true;
     readonly className: string;
-    /**
-     * vertex shader 代码
-     */
-    vs: string;
-    /**
-     * fragment shader 代码
-     */
-    fs: string;
-    /**
-     * 是否使用 header cache shader
-     */
-    useHeaderCache: boolean;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     */
-    constructor(params?: ShaderMaterialParameters);
-    getRenderOption(option?: ShaderOptions): ShaderOptions;
-    /**
-     * 获取定制的渲染参数
-     */
-    getCustomRenderOption: CustomRenderOptionProvider | null;
+    constructor(params: Readonly<ShaderMaterialParameters>);
 }
 
 interface SpriteMaterialParameters extends Omit<ShaderMaterialParameters, 'attributes' | 'uniforms' | 'uniformBlocks' | 'vs' | 'fs' | 'needBasicAttributes'> {
@@ -9032,175 +9746,67 @@ declare class Text2D extends Sprite {
     private readonly textTexture;
     constructor(params?: Text2DParameters);
     /** Current string, including newline-separated lines. */
-    get text(): string;
-    set text(value: string);
-    /** Immutable snapshot of the active raster style. */
-    get style(): Readonly<Required<Text2DStyle>>;
-    /** Replace text and rerasterize its Canvas 2D texture. */
-    setText(text: string): this;
-    /** Merge style changes and rerasterize. */
-    setStyle(style: Text2DStyle): this;
-    destroy(renderer?: Renderer, _destroyTextures?: boolean): this;
-    private replaceRaster;
-}
-
-type UiButtonState = 'up' | 'hover' | 'down' | 'disabled';
-interface UiButtonFrames {
-    /** Default button frame. */
-    up: SpriteFrame;
-    /** Pointer-hover frame. Defaults to `up`. */
-    hover?: SpriteFrame;
-    /** Pressed frame. Defaults to `hover`. */
-    down?: SpriteFrame;
-    /** Disabled frame. Defaults to `up`. */
-    disabled?: SpriteFrame;
-}
-interface UiButtonParameters extends Omit<SlicedSpriteParameters, 'frame' | 'texture'> {
-    /** Per-state nine-slice atlas frames. */
-    frames: UiButtonFrames;
-    /** Optional centered label. */
-    label?: string;
-    /** Canvas text style for the label. */
-    labelStyle?: Text2DStyle;
-    /** Initial enabled state. Defaults to `true`. */
-    enabled?: boolean;
-}
-/**
- * Nine-slice game UI button with hover, press, disabled, label, and click event support.
- *
- * Applications enable the desired pointer event types once through `Stage.enableDOMEvent()`.
- */
-declare class UiButton extends SlicedSprite {
-    static readonly typeName: string;
-    readonly isUiButton = true;
-    className: string;
-    readonly label: Text2D;
-    readonly frames: Readonly<UiButtonFrames>;
-    private enabledValue;
-    private stateValue;
-    constructor(params: UiButtonParameters);
-    /** Whether pointer interaction is enabled. */
-    get enabled(): boolean;
-    /** Current visual state. */
-    get state(): UiButtonState;
-    /** Enable or disable interaction and update the visual frame. */
-    setEnabled(enabled: boolean): this;
-    /** Replace the centered label text. */
-    setLabel(text: string): this;
-    setSize(width: number, height: number): this;
-    private readonly handlePointerOver;
-    private readonly handlePointerOut;
-    private readonly handlePointerDown;
-    private readonly handlePointerUp;
-    private updateState;
-}
-
-/** Sample interpretation supported by whole-subresource compute graph textures. */
-type ComputeTextureSampleType = 'float' | 'unfilterable-float' | 'depth';
-/** Compute graph textures currently expose one complete two-dimensional subresource. */
-type ComputeTextureViewDimension = '2d';
-/** Compute storage textures currently expose one complete two-dimensional subresource. */
-type ComputeStorageTextureViewDimension = '2d';
-/** Sample interpretation supported by storage-aware graphics shaders. */
-type ShaderTextureSampleType = ComputeTextureSampleType | 'sint' | 'uint';
-/** Texture views supported by the Material-backed storage graphics path. */
-type ShaderTextureViewDimension = ComputeTextureViewDimension | '2d-array' | '3d' | 'cube';
-/** Public color formats that can be requested for a storage-texture binding. */
-type ComputeStorageTextureFormat = Exclude<RenderTargetColorFormat, 'rgba8unorm-srgb'>;
-/** Graph initialization promise for a writable storage-buffer binding. */
-type ComputeStorageBufferAccess = 'read-write' | 'write-discard';
-/** Resource binding that a shader may only read. */
-type ShaderReadBinding = Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'uniform-buffer' | 'read-only-storage-buffer';
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampled-texture';
-    sampleType: ShaderTextureSampleType;
-    viewDimension?: ShaderTextureViewDimension;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampler' | 'comparison-sampler';
-}>;
-/** Explicit binding ABI for one Direct WGSL compute shader. */
-type ComputeShaderBinding = Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'uniform-buffer' | 'read-only-storage-buffer';
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampled-texture';
-    sampleType: ComputeTextureSampleType;
-    viewDimension?: ComputeTextureViewDimension;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'sampler' | 'non-filtering-sampler' | 'comparison-sampler';
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'storage-buffer';
-    /** Graph access promise; both modes use a WGSL `read_write` storage declaration. */
-    access: ComputeStorageBufferAccess;
-    minBindingSize?: number;
-    dynamicOffset?: boolean;
-}> | Readonly<{
-    name: string;
-    group: number;
-    binding: number;
-    kind: 'storage-texture';
-    /**
-     * WGSL access mode. Declaring this binding also promises that the pass completely
-     * replaces the bound texture subresource before a later graph read.
-     */
-    access: 'write-only';
-    format: ComputeStorageTextureFormat;
-    viewDimension?: ComputeStorageTextureViewDimension;
-}>;
-/** Immutable source, entry point, workgroup size, and binding ABI for {@link ComputeShader}. */
-interface ComputeShaderDescriptor {
-    /** Optional diagnostic label. */
-    readonly label?: string;
-    /** Direct WGSL source containing exactly the declared compute entry point and resources. */
-    readonly source: string;
-    /** Compute entry-point name. Defaults to `main`. */
-    readonly entryPoint?: string;
-    /** One to three positive literal dimensions, which must match `@workgroup_size`. */
-    readonly workgroupSize: readonly [number, number?, number?];
-    /** Complete explicit resource ABI; entries are snapshotted and sorted by group/binding. */
-    readonly bindings: readonly ComputeShaderBinding[];
+    get text(): string;
+    set text(value: string);
+    /** Immutable snapshot of the active raster style. */
+    get style(): Readonly<Required<Text2DStyle>>;
+    /** Replace text and rerasterize its Canvas 2D texture. */
+    setText(text: string): this;
+    /** Merge style changes and rerasterize. */
+    setStyle(style: Text2DStyle): this;
+    destroy(renderer?: Renderer, _destroyTextures?: boolean): this;
+    private replaceRaster;
 }
-/** Normalized three-dimensional compute workgroup size. */
-type NormalizedComputeWorkgroupSize = readonly [number, number, number];
-/** Immutable, backend-neutral Direct WGSL compute shader configuration. */
-declare class ComputeShader {
-    /** Stable diagnostic label, or an empty string. */
-    readonly label: string;
-    /** Validated Direct WGSL source. */
-    readonly source: string;
-    /** Validated compute entry point. */
-    readonly entryPoint: string;
-    /** Normalized workgroup dimensions. */
-    readonly workgroupSize: NormalizedComputeWorkgroupSize;
-    /** Immutable bindings in group/binding order. */
-    readonly bindings: readonly ComputeShaderBinding[];
-    /** Snapshot a Direct WGSL compute shader contract without creating device objects. */
-    constructor(descriptor: Readonly<ComputeShaderDescriptor>);
+
+type UiButtonState = 'up' | 'hover' | 'down' | 'disabled';
+interface UiButtonFrames {
+    /** Default button frame. */
+    up: SpriteFrame;
+    /** Pointer-hover frame. Defaults to `up`. */
+    hover?: SpriteFrame;
+    /** Pressed frame. Defaults to `hover`. */
+    down?: SpriteFrame;
+    /** Disabled frame. Defaults to `up`. */
+    disabled?: SpriteFrame;
+}
+interface UiButtonParameters extends Omit<SlicedSpriteParameters, 'frame' | 'texture'> {
+    /** Per-state nine-slice atlas frames. */
+    frames: UiButtonFrames;
+    /** Optional centered label. */
+    label?: string;
+    /** Canvas text style for the label. */
+    labelStyle?: Text2DStyle;
+    /** Initial enabled state. Defaults to `true`. */
+    enabled?: boolean;
+}
+/**
+ * Nine-slice game UI button with hover, press, disabled, label, and click event support.
+ *
+ * Applications enable the desired pointer event types once through `Stage.enableDOMEvent()`.
+ */
+declare class UiButton extends SlicedSprite {
+    static readonly typeName: string;
+    readonly isUiButton = true;
+    className: string;
+    readonly label: Text2D;
+    readonly frames: Readonly<UiButtonFrames>;
+    private enabledValue;
+    private stateValue;
+    constructor(params: UiButtonParameters);
+    /** Whether pointer interaction is enabled. */
+    get enabled(): boolean;
+    /** Current visual state. */
+    get state(): UiButtonState;
+    /** Enable or disable interaction and update the visual frame. */
+    setEnabled(enabled: boolean): this;
+    /** Replace the centered label text. */
+    setLabel(text: string): this;
+    setSize(width: number, height: number): this;
+    private readonly handlePointerOver;
+    private readonly handlePointerOut;
+    private readonly handlePointerDown;
+    private readonly handlePointerUp;
+    private updateState;
 }
 
 /** Value accepted by a fixed WGSL pipeline override constant. */
@@ -9288,37 +9894,6 @@ declare class ComputeSampler {
     constructor(descriptor?: Readonly<ComputeSamplerDescriptor>);
 }
 
-/** Constrained GLSL ES 3.10 graphics source and readonly resource ABI. */
-interface StorageGraphicsShaderDescriptor {
-    /** Optional diagnostic label. */
-    readonly label?: string;
-    /** GLSL ES 3.10 vertex source; storage blocks must be `readonly` and `std430`. */
-    readonly vertexSource: string;
-    /** GLSL ES 3.10 fragment source; storage blocks must be `readonly` and `std430`. */
-    readonly fragmentSource: string;
-    /** Complete read-only resource ABI shared by the two graphics stages. */
-    readonly bindings: readonly ShaderReadBinding[];
-}
-/**
- * Immutable WebGPU-only graphics shader configuration for readonly storage-buffer rendering.
- *
- * Sources use the constrained GLSL ES 3.10 contract. Compilation still runs through the shared
- * engine GLSL preprocessing and Naga translation path; this object never accepts hand-written
- * graphics WGSL.
- */
-declare class StorageGraphicsShader {
-    /** Stable diagnostic label, or an empty string. */
-    readonly label: string;
-    /** Immutable GLSL ES 3.10 vertex source. */
-    readonly vertexSource: string;
-    /** Immutable GLSL ES 3.10 fragment source. */
-    readonly fragmentSource: string;
-    /** Immutable bindings in group/binding order. */
-    readonly bindings: readonly ShaderReadBinding[];
-    /** Snapshot a WebGPU-only storage-aware graphics shader contract. */
-    constructor(descriptor: Readonly<StorageGraphicsShaderDescriptor>);
-}
-
 /** Scalar WGSL storage-address-space types supported by {@link StorageLayout}. */
 type StorageScalarType = 'f32' | 'i32' | 'u32' | 'atomic<i32>' | 'atomic<u32>';
 /** Two-, three-, and four-component WGSL storage vector types. */
@@ -9408,8 +9983,9 @@ declare const UNIFORM_BLOCK_BINDINGS: Readonly<{
     readonly GeometryBlock: 6;
     readonly SkinningBlock: 7;
     readonly MorphBlock: 8;
+    readonly MaterialTextureBlock: 9;
 }>;
-declare const BUILTIN_UNIFORM_BLOCK_BINDING_COUNT = 9;
+declare const BUILTIN_UNIFORM_BLOCK_BINDING_COUNT = 10;
 /** 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;
@@ -9420,20 +9996,44 @@ type ForwardRenderInjectionPoint = 'before-shadow' | 'after-shadow' | 'before-op
 interface ForwardRenderFeatureRequirements extends RenderPipelineRequirements {
     /** Route scene color through a linearly filterable sampled graph texture. */
     readonly sampledSceneColor: boolean;
+    /** Route scene depth through a single-sample graph texture that feature passes may sample. */
+    readonly sampledDepth: boolean;
+    /** Keep opaque and transparent renderer lists distinct even without a scene-color readback. */
+    readonly splitScene?: boolean;
     /**
-     * Reserved scene-depth sampling requirement. `true` is rejected until the public fullscreen
-     * binding ABI supports portable non-filtering depth sampling end to end.
+     * Minimum built-in scene color/depth resolution relative to the physical output. A runtime may
+     * return a higher scale through `getSceneScale()`; conflicting static floors are rejected.
      */
-    readonly sampledDepth: boolean;
+    readonly sceneScale?: number;
 }
 /** Renderer-local feature state created by a reusable feature configuration. */
 interface ForwardRenderPipelineFeatureRuntime {
+    /** Request sampled scene depth for this frame before Forward allocates its attachments. */
+    requiresSampledDepth?(context: RenderPipelineContext): boolean;
+    /**
+     * Request separate opaque and transparent scene passes for this frame. A conditional boundary
+     * feature is not recorded when every split request is inactive.
+     */
+    requiresSplitScene?(context: RenderPipelineContext): boolean;
     /**
      * Record this feature at its configured injection point.
      *
      * @returns An ignored synchronous value. Promise-like values are rejected before RHI execution.
      */
     record(context: ForwardRenderFeatureContext): unknown;
+    /** Commit feature-owned temporal CPU state after a valid frame submission. */
+    frameSubmitted?(frameIndex: number): void;
+    /** Roll back feature-owned temporal CPU state when recording or submission is discarded. */
+    frameDiscarded?(frameIndex: number): void;
+    /**
+     * Return this frame's scene scale. The value must stay between the feature's declared
+     * `sceneScale` floor and one. Omit for fixed-resolution features.
+     */
+    getSceneScale?(): number;
+    /** Consume asynchronous Render Graph CPU/GPU timing snapshots when adaptive work is enabled. */
+    recordRenderGraphTimeline?(snapshot: Readonly<RenderGraphTimelineSnapshot>): void;
+    /** Enable internal Render Graph timing when this feature actively consumes it. */
+    readonly usesRenderGraphTimeline?: boolean;
     /** Release renderer-local feature state exactly once. */
     destroy(): void;
 }
@@ -9455,10 +10055,34 @@ interface ForwardRenderPipelineFeature {
 interface ForwardRenderPipelineResources {
     /** Current attachment-zero scene color, or null for a depth-only output. */
     readonly color: RenderGraphTextureHandle | null;
+    /** Encoding of the current scene color. Lighting and HDR effects require `linear`. */
+    readonly colorEncoding: RenderColorEncoding;
     /** Current scene depth, or null when no depth resource was requested or configured. */
     readonly depth: RenderGraphTextureHandle | null;
+    /** Effective opaque render scale relative to the physical output. */
+    readonly sceneScale: number;
+    /** Reusable opaque motion/log-depth texture produced by an earlier feature, if any. */
+    readonly motionDepth: RenderGraphTextureHandle | null;
+    /** Reusable opaque view-normal/material texture produced by an earlier feature, if any. */
+    readonly materialAttributes: RenderGraphTextureHandle | null;
+    /**
+     * Declare that a feature has completely initialized the current opaque depth attachment.
+     * The built-in opaque pass will preserve it instead of clearing it.
+     */
+    markDepthPrepassed(): void;
+    /**
+     * Bind a full-resolution GTAO visibility texture to the following built-in opaque PBR pass.
+     * May only be called from a `before-opaque` feature after depth has been initialized.
+     */
+    setAmbientOcclusionTexture(texture: RenderGraphTextureHandle): void;
+    /** Publish opaque motion/log-depth data for later temporal features in this frame. */
+    setMotionDepth(texture: RenderGraphTextureHandle): void;
+    /** Publish opaque view-normal/material data for later screen-space features in this frame. */
+    setMaterialAttributes(texture: RenderGraphTextureHandle): void;
     /** Replace attachment-zero scene color for subsequent features and final output. */
-    replaceColor(texture: RenderGraphTextureHandle): void;
+    replaceColor(texture: RenderGraphTextureHandle, encoding: RenderColorEncoding): void;
+    /** Replace scene depth for subsequent scene passes, for example after temporal upscaling. */
+    replaceDepth(texture: RenderGraphTextureHandle): void;
 }
 /** Callback-scoped inputs passed to one forward feature runtime. */
 interface ForwardRenderFeatureContext {
@@ -9484,8 +10108,9 @@ interface ForwardRenderPipelineFactoryOptions {
      */
     readonly opaqueTexture?: boolean;
 }
-/** Default forward pipeline factory. An empty feature set retains the direct renderer fast path. */
+/** Default forward pipeline factory with a shared linear scene and final surface transfer. */
 declare class ForwardRenderPipelineFactory implements RenderPipelineFactory {
+    #private;
     /** Stable factory name. */
     readonly name = "forward";
     /** Merged static requirements from every feature configuration. */
@@ -9501,6 +10126,724 @@ 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;
+}
+/** 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;
+}
+/**
+ * Temporal anti-aliasing, temporal upscaling, and GPU-time dynamic-resolution feature.
+ *
+ * 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 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>;
+}
+
+/** 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;
+}
+
+/** 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;
+}
+
+/** 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;
+}
+/** 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;
+}
+/**
+ * WebGPU histogram auto exposure with percentile clipping and submission-aware eye adaptation.
+ *
+ * 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 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;
+}
+
+/** 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;
+}
+/** 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>;
+}
+/** 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;
+}
+/** 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;
+}
+
+/** 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;
+    /**
+     * 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.
+     */
+    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 {
+    /**
+     * 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;
+    /**
+     * Temporally accumulated screen-space diffuse global illumination. Disabled by default.
+     * The GPU Scene path reuses motion and material attributes and therefore requires `temporalAA`.
+     */
+    readonly screenSpaceGlobalIllumination?: Readonly<ScreenSpaceGlobalIlluminationOptions> | false;
+    /**
+     * Hierarchical, temporally accumulated screen-space reflections. Disabled by default.
+     * Enabling this production path requires both `hiZ` and `temporalAA`.
+     */
+    readonly screenSpaceReflections?: Readonly<ScreenSpaceReflectionsOptions> | false;
+    /**
+     * 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.
+     */
+    readonly volumetricLighting?: Readonly<VolumetricLightingOptions> | false;
+    /** Optional bounded material/deformation topology manifest translated during async creation. */
+    readonly variantManifest?: Readonly<ClusteredMaterialVariantManifest>;
+}
+/** 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. */
+    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 high-end factory combining G0 GPU Scene/Hi-Z and L0 Clustered Forward+.
+ *
+ * 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.
+ */
+declare class ClusteredForwardPlusPipelineFactory implements RenderPipelineFactory {
+    #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>>;
+}
+
+/** 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;
+}
+/** 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;
+}
+/** 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. */
@@ -9513,7 +10856,7 @@ interface ComputeBufferBinding {
 /** One graph texture consumed by a sampled- or storage-texture binding. */
 interface ComputeTextureBinding {
     /** Complete single-sample two-dimensional graph texture subresource. */
-    readonly texture: RenderGraphTextureHandle;
+    readonly texture: RenderGraphTextureAccessHandle;
 }
 /** A whole std140 uniform buffer or one explicitly selected range. */
 type ComputeUniformBufferBinding = UniformBuffer | UniformBufferRange;
@@ -9634,7 +10977,7 @@ declare class Shader {
      * @param fog - fog
      * @param useLogDepth - 是否使用对数深度
      */
-    static getHeaderKey(mesh: Mesh, material: Material, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean): string;
+    static getHeaderKey(mesh: Mesh, material: MaterialInstance, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, role?: MaterialPassRole): string;
     /**
      * 获取header
      * @param mesh -
@@ -9642,7 +10985,7 @@ declare class Shader {
      * @param lightManager -
      * @param fog -
      */
-    static getHeader(mesh: Mesh, material: Material, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean): string;
+    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;
@@ -9657,15 +11000,16 @@ declare class Shader {
      * @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: Material, isUseInstance: boolean, lightManager: LightManager, fog: Fog | null, useLogDepth: boolean, renderer?: ShaderPrecisionProvider, linearOutput?: boolean): Shader | null;
+    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: Material, isUseInstance: boolean, header: string, renderer?: ShaderPrecisionProvider): Shader;
+    static getBasicShader(material: MaterialInstance, isUseInstance: boolean, header: string, renderer?: ShaderPrecisionProvider, role?: MaterialPassRole): Shader;
     private static getNumericId;
     /**
      * 获取自定义shader
@@ -9705,14 +11049,14 @@ interface FullscreenRenderPassOptions {
     /** GLSL ES 3.00 shader with no vertex attributes. */
     readonly shader: Shader;
     /** Fixed raster, depth, blend, and culling state. */
-    readonly material: Material;
+    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 {
-    /** Linear-filterable sampled textures in reflected sampler order. */
-    readonly inputTextures: readonly RenderGraphTextureHandle[];
+    /** 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. */
@@ -9728,8 +11072,9 @@ interface FullscreenRenderPassParameters {
  * 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. Input formats must
- * support filterable sampling because the shared fullscreen path uses one fixed linear sampler.
+ * 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. */
@@ -9737,7 +11082,7 @@ declare class FullscreenRenderPass implements ScriptableRenderPass<FullscreenRen
     /** Shader compiled through the shared GLSL-to-backend pipeline. */
     readonly shader: Shader;
     /** Fixed material state for the fullscreen triangle. */
-    readonly material: Material;
+    readonly pipelineState: Readonly<MaterialPipelineState>;
     /** Uniform buffers in reflected block order. */
     readonly uniformBuffers: readonly UniformBuffer[];
     constructor(options: Readonly<FullscreenRenderPassOptions>);
@@ -9794,7 +11139,7 @@ interface GPUDrivenRenderPassOptions {
     /** WebGPU storage-aware GLSL ES 3.10 graphics shader. */
     readonly shader: StorageGraphicsShader;
     /** Raster/depth/blend state only; resource bindings come from pass parameters. */
-    readonly material: Material;
+    readonly pipelineState: Readonly<MaterialPipelineState>;
     /** Immutable positional vertex-buffer ABI; omit for vertex pulling. */
     readonly vertexLayouts?: readonly GPUDrivenVertexBufferLayout[];
     /** Index format required by indexed indirect draws. */
@@ -9839,7 +11184,7 @@ declare class GPUDrivenRenderPass implements ScriptableRenderPass<GPUDrivenRende
     /** Immutable storage-aware graphics shader. */
     readonly shader: StorageGraphicsShader;
     /** Material supplying raster, depth, stencil, and blend state. */
-    readonly material: Material;
+    readonly pipelineState: Readonly<MaterialPipelineState>;
     /** Snapshotted positional vertex-buffer ABI. */
     readonly vertexLayouts: readonly Readonly<GPUDrivenVertexBufferLayout>[];
     /** Index format for indexed indirect draws, when configured. */
@@ -9871,8 +11216,15 @@ interface SceneStorageBufferBinding {
  * explicit: it does not automatically rewrite built-in Basic/PBR shader source.
  */
 interface SceneStorageShaderVariant {
-    /** Storage-aware shader used by every direct mesh in this renderer list. */
+    /** 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>[];
 }
@@ -9894,7 +11246,13 @@ interface SceneRenderPassParameters {
      * 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 opaqueTexture?: RenderGraphTextureHandle;
+    readonly opaqueTexture?: RenderGraphTextureAccessHandle;
+    /**
+     * 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 ambientOcclusionTexture?: RenderGraphTextureAccessHandle;
     /** Optional WebGPU-only storage-aware shader variant for the ordinary renderer-list path. */
     readonly storageShaderVariant?: Readonly<SceneStorageShaderVariant>;
 }
@@ -9933,14 +11291,14 @@ declare class ShadowRenderPass {
     record(context: RenderPipelineContext, parameters: Readonly<ShadowRenderPassParameters>): void;
 }
 
-/** Full-subresource texture copy parameters. Both textures must have matching descriptors. */
+/** Full selected-subresource copy parameters. Views may have different parent descriptors. */
 interface TextureCopyPassParameters {
     /** Initialized single-sample copy source. */
-    readonly source: RenderGraphTextureHandle;
+    readonly source: RenderGraphTextureAccessHandle;
     /** Same-format, same-extent single-sample copy destination. */
-    readonly destination: RenderGraphTextureHandle;
+    readonly destination: RenderGraphTextureAccessHandle;
 }
-/** Portable full-texture copy pass emitted through the selected RHI backend. */
+/** 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;
@@ -9997,7 +11355,7 @@ declare class Bloom implements ForwardRenderPipelineFeature {
 }
 
 /** Display tone-mapping operator used by {@link ColorUber}. */
-type ToneMappingMode = 'pbr-neutral' | 'aces' | 'reinhard' | 'none';
+type ToneMappingMode = 'pbr-neutral' | 'aces' | 'reinhard' | 'filmic' | 'none';
 /** Linear-HDR color grading and display transform settings. */
 interface ColorUberOptions {
     /** Exposure compensation in EV stops. */
@@ -10023,6 +11381,16 @@ interface ColorUberOptions {
     readonly vignetteIntensity?: number;
     readonly vignetteSmoothness?: number;
     readonly toneMapping?: ToneMappingMode;
+    /** Filmic mid-tone slope multiplier in [0.01, 4]. */
+    readonly filmicSlope?: number;
+    /** Filmic toe strength in [0, 1]. */
+    readonly filmicToe?: number;
+    /** Filmic shoulder strength in [0, 1]. */
+    readonly filmicShoulder?: number;
+    /** Filmic black clipping offset in [0, 0.25]. */
+    readonly filmicBlackClip?: number;
+    /** Filmic white clipping amount in [0, 0.25]. */
+    readonly filmicWhiteClip?: number;
     readonly dithering?: boolean;
 }
 /**
@@ -10053,8 +11421,16 @@ declare class ColorUber implements ForwardRenderPipelineFeature {
 
 /** Turnkey HDR forward/post-processing pipeline configuration. */
 interface PostProcessRenderPipelineOptions {
+    /** Ground-truth ambient occlusion settings, or false to omit GTAO. */
+    readonly groundTruthAmbientOcclusion?: Readonly<GroundTruthAmbientOcclusionOptions> | false;
+    /** Screen-space diffuse global illumination settings, or false to omit SSGI. */
+    readonly screenSpaceGlobalIllumination?: Readonly<ScreenSpaceGlobalIlluminationOptions> | false;
+    /** Temporal anti-aliasing/upscaling settings, or false to omit the temporal pass. */
+    readonly temporalAA?: Readonly<TemporalAAOptions> | false;
     /** Bloom settings, or false to omit bloom. Bloom is enabled by default. */
     readonly bloom?: Readonly<BloomOptions> | false;
+    /** GPU histogram eye adaptation, or false to keep manual exposure. */
+    readonly autoExposure?: Readonly<AutoExposureOptions> | false;
     /** Final color grading/tone mapping settings. */
     readonly colorUber?: Readonly<ColorUberOptions>;
     /** Capture opaque scene color for transmission and volume. Defaults to true. */
@@ -10063,7 +11439,8 @@ interface PostProcessRenderPipelineOptions {
     readonly features?: readonly ForwardRenderPipelineFeature[];
 }
 /**
- * Turnkey linear-HDR forward pipeline with high-quality bloom, Color Uber, and opaque scene color.
+ * Turnkey linear-HDR forward pipeline with optional GTAO/TAA, high-quality bloom, Color Uber,
+ * and opaque scene color.
  */
 declare class PostProcessRenderPipelineFactory implements RenderPipelineFactory {
     #private;
@@ -10327,91 +11704,43 @@ declare class LazyTexture extends Texture {
 }
 
 type BasicLightType = 'NONE' | 'PHONG' | 'BLINN-PHONG' | 'LAMBERT';
-interface BasicMaterialParameters extends MaterialParameters {
-    lightType?: BasicLightType;
-    diffuse?: MaterialTextureValue;
-    ambient?: MaterialTextureValue;
-    specular?: MaterialTextureValue;
-    emission?: MaterialTextureValue;
-    specularEnvMap?: MaterialTexture | null;
-    specularEnvMatrix?: Matrix4 | null;
-    reflectivity?: number;
-    refractRatio?: number;
-    refractivity?: number;
-    shininess?: number;
-}
-/**
- * 基础材质，支持 NONE, PHONG, BLINN-PHONG, LAMBERT光照模型
- * @example
- * ```ts
- * const material = new Hilo3d.BasicMaterial({
- *     diffuse: new Hilo3d.Color(1, 0, 0, 1)
- * });
- * ```
- */
-declare class BasicMaterial extends Material {
-    isBasicMaterial: boolean;
+type MaterialColorOrTextureInput = Color | Texture<unknown> | MaterialTextureSlotInput | null;
+interface BasicMaterialParameters extends MaterialInstanceParameters {
+    readonly lightType?: BasicLightType;
+    readonly diffuse?: MaterialColorOrTextureInput;
+    readonly ambient?: MaterialColorOrTextureInput;
+    readonly specular?: MaterialColorOrTextureInput;
+    readonly emission?: MaterialColorOrTextureInput;
+    readonly specularEnvMap?: MaterialTexture | MaterialTextureSlotInput | null;
+    readonly specularEnvMatrix?: Matrix4 | null;
+    readonly reflectivity?: number;
+    readonly refractRatio?: number;
+    readonly refractivity?: number;
+    readonly shininess?: number;
+    readonly frontFace?: MaterialFrontFace;
+    readonly cullMode?: MaterialCullMode;
+    readonly state?: Partial<Readonly<MaterialPipelineState>>;
+}
+/** Built-in Blinn/Phong/Lambert or unlit material instance. */
+declare class BasicMaterial extends MaterialInstance {
+    #private;
+    readonly isBasicMaterial = true;
     readonly className: string;
-    /**
-     * 光照类型，支持: NONE, PHONG, BLINN-PHONG, LAMBERT
-     */
-    lightType: BasicLightType;
-    /**
-     * 漫反射贴图，或颜色
-     */
-    diffuse: MaterialTextureValue;
-    /**
-     * 环境光贴图，或颜色
-     */
-    ambient: MaterialTextureValue;
-    /**
-     * 镜面贴图，或颜色
-     */
-    specular: MaterialTextureValue;
-    /**
-     * 放射光贴图，或颜色
-     */
-    emission: MaterialTextureValue;
-    /**
-     * 环境贴图
-     */
-    specularEnvMap: MaterialTexture | null;
-    /**
-     * 环境贴图变化矩阵，如旋转等
-     */
-    specularEnvMatrix: Matrix4 | null;
-    /**
-     * 反射率
-     */
-    reflectivity: number;
-    /**
-     * 折射比率
-     */
-    refractRatio: number;
-    /**
-     * 折射率
-     */
-    refractivity: number;
-    /**
-     * 高光发光值
-     */
-    shininess: number;
-    usedUniformVectors: number;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     * - `params.lightType`: 光照类型，支持: NONE, PHONG, BLINN-PHONG, LAMBERT
-     * - `params.diffuse`: 漫反射贴图，或颜色
-     * - `params.ambient`: 环境光贴图，或颜色
-     * - `params.specular`: 镜面贴图，或颜色
-     * - `params.emission`: 放射光贴图，或颜色
-     * - `params.specularEnvMap`: 环境贴图
-     * - `params.specularEnvMatrix`: 环境贴图变化矩阵，如旋转等
-     * - `params.reflectivity`: 反射率
-     * - `params.refractRatio`: 折射比率
-     * - `params.refractivity`: 折射率
-     * - `params.shininess`: 高光发光值
-     */
-    constructor(params?: BasicMaterialParameters);
+    readonly diffuse: MaterialTextureValue;
+    readonly ambient: MaterialTextureValue;
+    readonly specular: MaterialTextureValue;
+    readonly emission: MaterialTextureValue;
+    readonly specularEnvMap: MaterialTexture | null;
+    readonly specularEnvMatrix: Matrix4 | null;
+    constructor(params?: Readonly<BasicMaterialParameters>);
+    get reflectivity(): number;
+    set reflectivity(value: number);
+    get refractRatio(): number;
+    set refractRatio(value: number);
+    get refractivity(): number;
+    set refractivity(value: number);
+    get shininess(): number;
+    set shininess(value: number);
     protected initializeBasicMaterialBindings(): void;
     getRenderOption(option?: ShaderOptions): ShaderOptions;
 }
@@ -10434,38 +11763,90 @@ declare namespace Hilo {
 }
 
 type GeometryVertexType = typeof POSITION | typeof NORMAL | typeof DEPTH$1 | typeof DISTANCE;
-interface GeometryMaterialParameters extends BasicMaterialParameters {
-    vertexType?: GeometryVertexType;
-    writeOriginData?: boolean;
-}
-/**
- * 几何材质，支持 POSITION, NORMAL, DEPTH, DISTANCE 顶点类型
- * @example
- * ```ts
- * const material = new Hilo3d.GeometryMaterial({
- *     diffuse: new Hilo3d.Color(1, 0, 0, 1)
- * });
- * ```
- */
-declare class GeometryMaterial extends BasicMaterial {
-    isGeometryMaterial: boolean;
-    readonly className: string;
-    /**
-     * 顶点类型 POSITION, NORMAL, DEPTH, DISTANCE
-     */
-    vertexType: GeometryVertexType;
-    lightType: "NONE";
-    /**
-     * 是否直接存储
-     */
-    writeOriginData: boolean;
-    /**
-     * @param params - 初始化参数，所有params都会复制到实例上
-     */
-    constructor(params?: GeometryMaterialParameters);
+interface GeometryMaterialParameters extends MaterialInstanceParameters {
+    readonly vertexType?: GeometryVertexType;
+    readonly writeOriginData?: boolean;
+    readonly frontFace?: MaterialFrontFace;
+    readonly cullMode?: MaterialCullMode;
+}
+/** Immutable-topology material for position, normal, depth and distance outputs. */
+declare class GeometryMaterial extends MaterialInstance {
+    readonly isGeometryMaterial = true;
+    readonly className = "GeometryMaterial";
+    readonly vertexType: GeometryVertexType;
+    readonly writeOriginData: boolean;
+    constructor(params?: Readonly<GeometryMaterialParameters>);
     getRenderOption(option?: ShaderOptions): ShaderOptions;
 }
 
+/** Stable MaterialBlock texture-slot indices shared by built-in families and shader source. */
+declare const MATERIAL_TEXTURE_SLOT_COUNT = 24;
+declare const MaterialTextureSlot: Readonly<{
+    readonly NORMAL: 0;
+    readonly PARALLAX: 1;
+    readonly EMISSION: 2;
+    readonly OPACITY: 3;
+    readonly DIFFUSE: 4;
+    readonly SPECULAR: 5;
+    readonly AMBIENT: 6;
+    readonly BASE_COLOR: 7;
+    readonly METALLIC: 8;
+    readonly ROUGHNESS: 9;
+    readonly METALLIC_ROUGHNESS: 10;
+    readonly OCCLUSION: 11;
+    readonly SPECULAR_GLOSSINESS: 12;
+    readonly LIGHT: 13;
+    readonly CLEARCOAT: 14;
+    readonly CLEARCOAT_ROUGHNESS: 15;
+    readonly CLEARCOAT_NORMAL: 16;
+    readonly ANISOTROPY: 17;
+    readonly TRANSMISSION: 18;
+    readonly THICKNESS: 19;
+    readonly IRIDESCENCE: 20;
+    readonly IRIDESCENCE_THICKNESS: 21;
+    readonly DIFFUSE_ENVIRONMENT: 22;
+    readonly SPECULAR_ENVIRONMENT: 23;
+}>;
+type BuiltInMaterialTextureSlotName = keyof typeof MaterialTextureSlot;
+
+interface MaterialTargetSignature {
+    readonly colorFormats: readonly (string | null)[];
+    readonly depthStencilFormat: string | null;
+    readonly sampleCount: number;
+}
+interface MaterialCompileRequest {
+    readonly instance: MaterialInstance;
+    readonly role: MaterialPassRole;
+    readonly target: Readonly<MaterialTargetSignature>;
+    readonly vertexLayoutClass: string;
+    readonly renderingProfile: MaterialRenderingProfile;
+    readonly backend: RendererBackend;
+}
+interface PreparedMaterialVariant {
+    readonly definitionId: string;
+    readonly materialId: number;
+    readonly role: MaterialPassRole;
+    readonly shader: MaterialShaderModule;
+    readonly fragmentOutput: MaterialFragmentOutput;
+    readonly state: Readonly<MaterialPipelineState>;
+    readonly key: string;
+}
+/** Canonical immutable blend equations shared by materials and low-level render passes. */
+declare const MaterialBlendPreset: Readonly<{
+    PREMULTIPLIED_ALPHA: Readonly<MaterialBlendState>;
+    STRAIGHT_ALPHA: Readonly<MaterialBlendState>;
+    PREMULTIPLIED_ADDITIVE: Readonly<MaterialBlendState>;
+    STRAIGHT_ALPHA_ADDITIVE: Readonly<MaterialBlendState>;
+}>;
+/** Resolve the backend-neutral state for a material role before RHI descriptor mapping. */
+declare function resolveMaterialPassState(instance: MaterialInstance, role: MaterialPassRole): Readonly<MaterialPipelineState> | null;
+/** Resolve a declared semantic pass or an explicitly safe depth/shadow fallback. */
+declare function resolveMaterialPassDefinition(instance: MaterialInstance, role: MaterialPassRole): MaterialPassDefinition | null;
+/** Compiles immutable definition structure and one semantic role into a stable draw variant. */
+declare class MaterialCompiler {
+    compile(request: Readonly<MaterialCompileRequest>): PreparedMaterialVariant | null;
+}
+
 interface SemanticRenderer {
     width: number;
     height: number;
@@ -10476,7 +11857,7 @@ interface SemanticMesh extends Mesh {
     isSkinnedMesh: boolean;
     getJointMat(): Float32Array;
 }
-interface SemanticMaterial extends Material {
+interface SemanticMaterial extends MaterialInstance {
     baseColor: Color;
     baseColorMap: Texture | null;
     brdfLUT: Texture | null;
@@ -10584,12 +11965,15 @@ declare const semantic: {
     TEXCOORD_1: {
         get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
-    UVMATRIX_0: {
-        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
+    MATERIALTEXTURETRANSFORMS: {
+        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
-    UVMATRIX_1: {
+    MATERIALTEXTUREINFO: {
         get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
+    MATERIALTEXTURECHANNELS: {
+        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
+    };
     CAMERAFAR: {
         get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
@@ -10634,6 +12018,11 @@ declare const semantic: {
         isDependMesh: boolean;
         notSupportInstanced: boolean;
     };
+    MODELLAYERPARAMS: {
+        get(mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): Uint32Array;
+        isDependMesh: boolean;
+        notSupportInstanced: boolean;
+    };
     VIEW: {
         get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
@@ -10882,11 +12271,14 @@ declare const semantic: {
     ALPHACUTOFF: {
         get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
+    TEMPORALREACTIVEFACTOR: {
+        get(_mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
+    };
     EXPOSURE: {
-        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
+        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
     GAMMAFACTOR: {
-        get(mesh: SemanticMesh, material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
+        get(_mesh: SemanticMesh, _material: SemanticMaterial, _programInfo: ProgramBindingInfo): unknown;
     };
     MORPHWEIGHTS: {
         isDependMesh: boolean;
@@ -10942,6 +12334,9 @@ declare const semantic: {
     OPAQUETEXTURE: {
         get(): unknown;
     };
+    GTAOTEXTURE: {
+        get(): unknown;
+    };
 };
 
 interface AxisHelperParameters extends NodeParameters {
@@ -11092,6 +12487,7 @@ declare class MeshPicker {
     /** Active renderer owned by this picker's Stage. */
     readonly renderer: Renderer;
     private renderTarget;
+    private renderTargetDepthMode;
     private readonly idMeshMap;
     private operation;
     private destroyed;
@@ -13612,6 +15008,6 @@ declare const math: {
     nextPowerOfTwo(value: number): number;
 };
 
-export { AmbientLight, Animation, AnimationStates, AreaLight, AxisHelper, AxisNetHelper, BUILTIN_UNIFORM_BLOCK_BINDING_COUNT, BasicLoader, BasicMaterial, Bloom, BoxGeometry, Cache, Camera, Camera2D, CameraHelper, Color, ColorUber, ComputeKernel, ComputeRenderPass, ComputeSampler, ComputeShader, CubeTexture, CubeTextureLoader, DEFAULT_2D_LAYER, DataTexture, DirectionalLight, Euler, EulerNotifier, EventDispatcher, Fog, ForwardRenderPipelineFactory, Frustum, FullscreenRenderPass, GLTFExtensions_d as GLTFExtensions, GLTFLoader, GLTFParser, GPUDrivenRenderPass, Geometry, GeometryData, GeometryMaterial, HDRLoader, HiloEvent, KTXLoader, LazyTexture, Light, LightManager, LoadCache, LoadQueue, LoadState, Loader, LogLevel, Logger, Material, Matrix3, Matrix4, Matrix4Notifier, Mesh, MeshPicker, MorphGeometry, Node, OrthographicCamera, PBRMaterial, PerspectiveCamera, Plane, PlaneGeometry, PointLight, PostProcessRenderPipelineFactory, PresentRenderPass, Quaternion, QuaternionNotifier, Ray, RenderInfo, RenderPassParameterPool, Renderer, SCENE_STORAGE_BIND_GROUP, STATE_TYPES, SceneRenderPass, Shader, ShaderMaterial, ShaderMaterialLoader, ShadowRenderPass, Skeleton, SkinnedMesh, SlicedSprite, Sphere, SphereGeometry, SphericalHarmonics3, SpotLight, Sprite, SpriteFrame, SpriteMaterial, Stage, Std140Layout, StorageGraphicsShader, StorageLayout, Text2D, Texture, TextureCopyPass, TextureLoader, Ticker, Tween, UNIFORM_BLOCK_BINDINGS, UiButton, UniformBuffer, Vector2, Vector3, Vector3Notifier, Vector4, WebGLSupport, browser, collectionEntries, constants, createEmptyGLTFRoot, createStd140Layout, createStorageLayout, detectBrowserFeatures, detectWebGLSupport, Hilo as engineConstants, getCollectionItem, getUniformBlockBinding, isArrayCollection, isGLTFRoot, log, math, parseRadianceHDR, registerUniformBlockBinding, 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, AxisAlignedBox, AxisHelperParameters, AxisNetHelperParameters, BackEaseObject, BasicLightType, BasicLoadRequest, BasicLoaderResource, BasicMaterialParameters, BasicResource, BasicResourceType, BloomOptions, Bounds, BoxGeometryParameters, BrowserFeatures, BuiltInAnimationStateType, Camera2DParameters, CameraHelperParameters, CameraParameters, ColorUberOptions, ComputeBufferBinding, ComputeDispatch, ComputeKernelDescriptor, ComputePipelineConstant, ComputeRenderPassParameters, ComputeSamplerAddressMode, ComputeSamplerDescriptor, ComputeSamplerFilterMode, ComputeShaderBinding, ComputeShaderDescriptor, ComputeStorageBufferAccess, ComputeStorageTextureFormat, ComputeStorageTextureViewDimension, ComputeTextureBinding, ComputeTextureSampleType, ComputeTextureViewDimension, ComputeUniformBufferBinding, CubeTextureImage, CubeTextureLoadRequest, CubeTextureParameters, CullingOptions, CullingResultsHandle, CustomRenderOptionProvider, DataTextureParameters, DirectionalLightInfo, DirectionalLightParameters, DispatchEvent, 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, GeometryAttributeValue, GeometryComponentSize, GeometryDataComponentCallback, GeometryDataLike, GeometryDataParameters, GeometryDataTraverseCallback, GeometryMaterialParameters, GeometryParameters, GeometryVertexType, HDRLoadRequest, ImageCrossOrigin, InstancedUniform, InterpolatedValue, InterpolationFunction, JsonPrimitive, JsonValue, KTXLoadRequest, KTXTextureOptions, LazyTextureParameters, LightGroupName, LightInfo, LightManagerParameters, LightParameters, LightShadowOptions, ListenerEntry, ListenerMap, LoadCacheFile, LoadQueueItem, LoadQueueSource, LoadStateValue, LoaderRequest, LoaderTextureOptions, LogLevelValue, MaterialBeforeCompile, MaterialBinding, MaterialBindingInfo, MaterialBindingMap, MaterialParameters, MaterialShaderSource, MaterialTexture, MaterialTextureValue, MeshParameters, MeshPickerParameters, MorphGeometryParameters, MorphTargets, MutableArrayLike, MutableNumberArray, NetworkResourceType, NodeGetChildByCallback, NodeParameters, NodePointerEvent, NodeRaycastInfo, NodeTraverseCallback, NodeTraverseResult, NormalizedComputeWorkgroupSize, OrthographicCameraParameters, PBRMaterialParameters, PerspectiveCameraParameters, PlaneGeometryParameters, Point2, Point3, PointLightInfo, PointLightParameters, PointLightShadowOptions, PointShadowCameraParameters, PostProcessRenderPipelineOptions, ProgramBindingInfo, RadianceHDRImage, RayCamera, RayParameters, RenderGraphBufferHandle, RenderGraphBufferReadUse, RenderGraphBufferWriteUse, RenderGraphFramePlan, RenderGraphPassHandle, RenderGraphTextureHandle, RenderPassParameterFactory, RenderPassParameterReset, RenderPipeline, RenderPipelineBufferDescriptor, RenderPipelineCapabilities, RenderPipelineCapabilityName, RenderPipelineColorAttachment, RenderPipelineContext, RenderPipelineCreateContext, RenderPipelineDepthStencilAttachment, RenderPipelineExtent, RenderPipelineFactory, RenderPipelineLimits, RenderPipelineOutput, RenderPipelineOutputColorAttachment, RenderPipelineOutputDepthStencilAttachment, RenderPipelineOutputResources, RenderPipelinePersistentTargetDescriptor, RenderPipelineRequirements, RenderPipelineTargetResources, RenderPipelineTextureDescriptor, RenderPipelineTextureRequirement, RenderPipelineTextureUse, RenderTarget, RenderTargetColor, RenderTargetColorAttachmentOptions, RenderTargetColorAttachmentReadback, RenderTargetColorFormat, RenderTargetCompareFunction, RenderTargetDepthStencilAttachmentOptions, RenderTargetDepthStencilFormat, RenderTargetLoadOp, RenderTargetParameters, RenderTargetReadColorAttachmentOptions, RenderTargetSampleCount, RenderTargetSelectionOptions, RenderTargetStoreOp, RendererAdapterPowerPreference, RendererAutoOptions, RendererBackend, RendererCommonOptions, RendererContextPowerPreference, RendererContract, RendererCreateOptions, RendererExplicitOptions, RendererFeatureName, RendererFrame, RendererFrameCallback, RendererListDescriptor, RendererListHandle, RendererListQueue, RendererListSorting, RendererOptions, RendererOptionsMap, RendererResourceDiagnostics, RendererResourceManager, RendererScene, RendererSupportOptions, RendererViewport, RendererWebGL2Options, RendererWebGPUOptions, ResizableTextureImage, Resource, ResourceLoader, ResourceLoaderConstructor, ResourceRequestOptions, SceneRenderPassParameters, SceneStorageBufferBinding, SceneStorageShaderVariant, ScriptableRenderCommands, ScriptableRenderGraph, ScriptableRenderPass, ScriptableRenderPassBuilder, ScriptableRenderPassContext, ScriptableRenderPrepareContext, SemanticMaterial, SemanticMesh, SemanticRenderer, ShaderDefineValue, ShaderMaterialLoadRequest, ShaderMaterialParameters, ShaderOptions, ShaderParameters, ShaderPrecision, ShaderPrecisionProvider, ShaderReadBinding, ShaderRenderer, ShaderTextureSampleType, ShaderTextureViewDimension, ShadowCameraParameters, ShadowCastingLightParameters, ShadowRenderPassParameters, Size, SkeletonParameters, SkinnedMeshParameters, SlicedSpriteInsets, SlicedSpriteParameters, SphereGeometryParameters, SpotLightInfo, SpotLightParameters, SpriteFrameParameters, SpriteFrameUpdateOptions, SpriteFramesUpdateOptions, SpriteMaterialParameters, SpriteParameters, StageBackend, StageBackendParameters, StageCommonParameters, StageParameters, StagePointerEvent, 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, 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, XYZObject };
+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, 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, 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