@headless-three/renderer 0.1.7 → 0.1.8

package/dist/types.d.ts

@@ -1,17 +1,81 @@
-export type RenderOutputFormat = 'png' | 'rgba' | 'raw' | 'raw-rgba';
+export type RenderOutputFormat = 'png' | 'rgba';
+export type RenderOutputColorSpace = 'srgb' | 'srgb-linear' | 'linear-srgb' | 'linearsrgb' | 'linear';
+export type RenderMode = 'color' | 'mask' | 'object-id' | 'normal' | 'depth';
+export type RenderAnimationLoopCallback = (time: number, frame?: unknown) => void;
+export type RendererPowerPreferenceLike = 'default' | 'high-performance' | 'low-power';
+export interface RendererInspectorLike {
+    currentFrame?: unknown;
+    setRenderer(renderer: unknown): unknown;
+    getRenderer?(): unknown;
+    init?(): unknown;
+    begin?(): unknown;
+    finish?(): unknown;
+    inspect?(node: unknown): unknown;
+    computeAsync?(computeNode: unknown, dispatchSizeOrCount?: unknown): unknown;
+    beginCompute?(uid: unknown, computeNode?: unknown): unknown;
+    finishCompute?(uid?: unknown): unknown;
+    beginRender?(uid: unknown, scene?: unknown, camera?: unknown, renderTarget?: unknown): unknown;
+    finishRender?(uid?: unknown): unknown;
+    copyTextureToTexture?(srcTexture: unknown, dstTexture: unknown): unknown;
+    copyFramebufferToTexture?(framebufferTexture: unknown): unknown;
+}
+export interface RendererParametersLike {
+    canvas?: unknown;
+    context?: unknown;
+    alpha?: boolean;
+    depth?: boolean;
+    stencil?: boolean;
+    antialias?: boolean;
+    premultipliedAlpha?: boolean;
+    preserveDrawingBuffer?: boolean;
+    powerPreference?: RendererPowerPreferenceLike;
+    failIfMajorPerformanceCaveat?: boolean;
+    samples?: number;
+    outputBufferType?: number;
+    logarithmicDepthBuffer?: boolean;
+    reversedDepthBuffer?: boolean;
+    reverseDepthBuffer?: boolean;
+}
+export interface RendererContextAttributesLike {
+    alpha: boolean;
+    depth: boolean;
+    stencil: boolean;
+    antialias: boolean;
+    premultipliedAlpha: boolean;
+    preserveDrawingBuffer: boolean;
+    powerPreference: RendererPowerPreferenceLike;
+    failIfMajorPerformanceCaveat: boolean;
+}
 export interface ThreeColorLike {
     r: number;
     g: number;
     b: number;
     isColor?: boolean;
 }
+export type ThreeColorInput = ThreeColorLike | string | number[];
 export interface ThreeMatrix4Like {
     elements: ArrayLike<number>;
 }
+export interface ThreeMatrix3Like {
+    elements: ArrayLike<number>;
+}
+export interface ThreeSphereLike {
+    center?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    } | ArrayLike<number>;
+    radius?: number;
+}
 export interface ThreeBufferAttributeLike {
     count: number;
+    version?: number;
     itemSize?: number;
     normalized?: boolean;
+    isPacked?: boolean;
+    packingMethod?: unknown;
+    isInstancedBufferAttribute?: boolean;
+    meshPerAttribute?: number;
     array?: ArrayLike<number>;
     data?: {
         array: ArrayLike<number>;
@@ -24,6 +88,9 @@ export interface ThreeBufferAttributeLike {
     getW?(index: number): number;
 }
 export interface ThreeBufferGeometryLike {
+    version?: number;
+    isInstancedBufferGeometry?: boolean;
+    instanceCount?: number;
     attributes?: Record<string, ThreeBufferAttributeLike | undefined>;
     index?: ThreeBufferAttributeLike | null;
     groups?: Array<{
@@ -36,15 +103,35 @@ export interface ThreeBufferGeometryLike {
         count?: number;
     };
     getAttribute?(name: string): ThreeBufferAttributeLike | undefined;
+    boundingSphere?: ThreeSphereLike | null;
+    computeBoundingSphere?(): void;
     morphAttributes?: Record<string, ThreeBufferAttributeLike[] | undefined>;
     morphTargetsRelative?: boolean;
 }
 export interface ThreeTextureLike {
+    version?: number;
+    isTexture?: boolean;
+    isCubeTexture?: boolean;
+    isFramebufferTexture?: boolean;
+    isDepthTexture?: boolean;
+    isVideoTexture?: boolean;
+    isStorageTexture?: boolean;
+    isCompressedTexture?: boolean;
+    isCompressedArrayTexture?: boolean;
+    isCompressedCubeTexture?: boolean;
+    isDataArrayTexture?: boolean;
+    isData3DTexture?: boolean;
+    isArrayTexture?: boolean;
+    is3DTexture?: boolean;
     image?: {
         data?: ArrayLike<number>;
         width?: number;
         height?: number;
-    } | Buffer | Uint8Array;
+    } | Buffer | Uint8Array | Array<{
+        data?: ArrayLike<number>;
+        width?: number;
+        height?: number;
+    } | Buffer | Uint8Array>;
     source?: {
         data?: {
             data?: ArrayLike<number>;
@@ -54,37 +141,239 @@ export interface ThreeTextureLike {
     };
     wrapS?: number;
     wrapT?: number;
+    magFilter?: number;
+    minFilter?: number;
+    format?: number;
+    type?: number;
+    generateMipmaps?: boolean;
+    needsUpdate?: boolean;
+    mipmaps?: Array<{
+        data?: ArrayLike<number>;
+        width?: number;
+        height?: number;
+    }>;
+    anisotropy?: number;
+    mapping?: number;
+    channel?: number;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+    repeat?: {
+        x?: number;
+        y?: number;
+    };
+    rotation?: number;
+    center?: {
+        x?: number;
+        y?: number;
+    };
+    matrix?: ThreeMatrix3Like;
+    matrixAutoUpdate?: boolean;
+    flipY?: boolean;
+    premultiplyAlpha?: boolean;
+    unpackAlignment?: number;
+    colorSpace?: string;
+    encoding?: number;
+}
+export interface ThreeVector3Like {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+export interface ThreeEulerLike {
+    x?: number;
+    y?: number;
+    z?: number;
+    order?: string;
+    isEuler?: boolean;
+}
+export type ThreePlaneLike = {
+    normal?: ThreeVector3Like | ArrayLike<number>;
+    constant?: number;
+} | ArrayLike<number>;
+export type RenderPixelRectLike = {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    z?: number;
+    w?: number;
+} | ArrayLike<number>;
+export type RenderSizeLike = {
+    width?: number;
+    height?: number;
+    x?: number;
+    y?: number;
+    set?(width: number, height: number): unknown;
+} | ArrayLike<number>;
+export interface ThreeLayersLike {
+    mask?: number;
+    test?(layers: ThreeLayersLike): boolean;
 }
 export interface ThreeMaterialLike {
-    color?: ThreeColorLike;
+    type?: string;
+    color?: ThreeColorInput;
     opacity?: number;
     visible?: boolean;
     vertexColors?: boolean;
+    userData?: Record<string, any>;
+    onBeforeCompile?: (...args: any[]) => void;
+    blending?: number;
+    blendEquation?: number;
+    blendSrc?: number;
+    blendDst?: number;
+    blendEquationAlpha?: number | null;
+    blendSrcAlpha?: number | null;
+    blendDstAlpha?: number | null;
+    blendColor?: ThreeColorInput;
+    blendAlpha?: number;
+    premultipliedAlpha?: boolean;
+    toneMapped?: boolean;
+    dithering?: boolean;
+    precision?: 'highp' | 'mediump' | 'lowp' | null;
     map?: ThreeTextureLike | null;
+    envMap?: ThreeTextureLike | null;
+    envMapIntensity?: number;
+    envMapRotation?: ThreeEulerLike | ArrayLike<number> | null;
+    combine?: number;
+    reflectivity?: number;
+    refractionRatio?: number;
     metalness?: number;
     roughness?: number;
-    emissive?: ThreeColorLike;
+    clearcoat?: number;
+    clearcoatMap?: ThreeTextureLike | null;
+    clearcoatRoughness?: number;
+    clearcoatRoughnessMap?: ThreeTextureLike | null;
+    clearcoatNormalMap?: ThreeTextureLike | null;
+    clearcoatNormalScale?: {
+        x: number;
+        y: number;
+    };
+    sheen?: number;
+    sheenColor?: ThreeColorInput;
+    sheenColorMap?: ThreeTextureLike | null;
+    sheenRoughness?: number;
+    sheenRoughnessMap?: ThreeTextureLike | null;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: ThreeTextureLike | null;
+    iridescence?: number;
+    iridescenceMap?: ThreeTextureLike | null;
+    iridescenceIOR?: number;
+    iridescenceThicknessRange?: ArrayLike<number>;
+    iridescenceThicknessMap?: ThreeTextureLike | null;
+    dispersion?: number;
+    transmission?: number;
+    transmissionMap?: ThreeTextureLike | null;
+    ior?: number;
+    thickness?: number;
+    thicknessMap?: ThreeTextureLike | null;
+    attenuationDistance?: number;
+    attenuationColor?: ThreeColorInput;
+    specularColor?: ThreeColorInput;
+    specularColorMap?: ThreeTextureLike | null;
+    specularIntensity?: number;
+    specularIntensityMap?: ThreeTextureLike | null;
+    specular?: ThreeColorInput;
+    shininess?: number;
+    emissive?: ThreeColorInput;
     emissiveIntensity?: number;
     emissiveMap?: ThreeTextureLike | null;
     normalMap?: ThreeTextureLike | null;
+    normalMapType?: number;
     normalScale?: {
         x: number;
         y: number;
     };
+    bumpMap?: ThreeTextureLike | null;
+    bumpScale?: number;
+    displacementMap?: ThreeTextureLike | null;
+    displacementScale?: number;
+    displacementBias?: number;
+    matcap?: ThreeTextureLike | null;
+    gradientMap?: ThreeTextureLike | null;
     metalnessMap?: ThreeTextureLike | null;
     roughnessMap?: ThreeTextureLike | null;
+    specularMap?: ThreeTextureLike | null;
+    lightMap?: ThreeTextureLike | null;
+    lightMapIntensity?: number;
     aoMap?: ThreeTextureLike | null;
     aoMapIntensity?: number;
+    alphaMap?: ThreeTextureLike | null;
     alphaTest?: number;
+    alphaHash?: boolean;
+    alphaToCoverage?: boolean;
+    clippingPlanes?: ThreePlaneLike[] | null;
+    clipIntersection?: boolean;
+    clipShadows?: boolean;
+    depthTest?: boolean;
+    depthFunc?: number;
+    depthWrite?: boolean;
+    colorWrite?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    polygonOffsetUnits?: number;
+    stencilWrite?: boolean;
+    stencilWriteMask?: number;
+    stencilFunc?: number;
+    stencilRef?: number;
+    stencilFuncMask?: number;
+    stencilFail?: number;
+    stencilZFail?: number;
+    stencilZPass?: number;
     transparent?: boolean;
+    forceSinglePass?: boolean;
     side?: number;
+    shadowSide?: number | null;
+    flatShading?: boolean;
+    wireframe?: boolean;
+    wireframeLinewidth?: number | null;
+    wireframeLinecap?: 'butt' | 'round' | 'square' | null;
+    wireframeLinejoin?: 'round' | 'bevel' | 'miter' | null;
+    fog?: boolean;
+    isLineDashedMaterial?: boolean;
     isMeshBasicMaterial?: boolean;
+    isMeshDepthMaterial?: boolean;
+    isMeshDistanceMaterial?: boolean;
     isMeshLambertMaterial?: boolean;
+    isMeshMatcapMaterial?: boolean;
+    isMeshNormalMaterial?: boolean;
+    isMeshPhongMaterial?: boolean;
     isMeshStandardMaterial?: boolean;
     isMeshPhysicalMaterial?: boolean;
+    isMeshToonMaterial?: boolean;
+    isShadowMaterial?: boolean;
     isLineBasicMaterial?: boolean;
     isPointsMaterial?: boolean;
+    isSpriteMaterial?: boolean;
+    isShaderMaterial?: boolean;
+    isRawShaderMaterial?: boolean;
+    isNodeMaterial?: boolean;
+    name?: string;
+    vertexShader?: string;
+    fragmentShader?: string;
+    uniforms?: Record<string, {
+        value?: unknown;
+    } | unknown>;
+    depthPacking?: number;
+    referencePosition?: ThreeVector3Like | ArrayLike<number>;
+    nearDistance?: number;
+    farDistance?: number;
+    dashSize?: number;
+    gapSize?: number;
+    scale?: number;
+    linewidth?: number;
+    linecap?: 'butt' | 'round' | 'square' | null;
+    linejoin?: 'round' | 'bevel' | 'miter' | null;
+    rotation?: number;
+    customFragmentShader?: string;
+    customFragmentWgsl?: string;
+    headlessFragmentShader?: string;
+    headlessFragmentWgsl?: string;
     size?: number;
+    sizeAttenuation?: boolean;
+    id?: number;
 }
 export interface ThreeBoneLike {
     matrixWorld?: ThreeMatrix4Like;
@@ -95,35 +384,125 @@ export interface ThreeSkeletonLike {
     update?(): void;
 }
 export interface ThreeObject3DLike {
+    isObject3D?: boolean;
     visible?: boolean;
+    layers?: ThreeLayersLike;
+    renderOrder?: number;
+    id?: number;
     children?: ThreeObject3DLike[];
+    userData?: Record<string, any>;
     isMesh?: boolean;
+    isBatchedMesh?: boolean;
+    isInstancedMesh?: boolean;
     isSkinnedMesh?: boolean;
+    isLOD?: boolean;
+    isGroup?: boolean;
+    isClippingGroup?: boolean;
     isLine?: boolean;
     isLineSegments?: boolean;
     isLineLoop?: boolean;
     isPoints?: boolean;
+    isSprite?: boolean;
     isLight?: boolean;
     isDirectionalLight?: boolean;
     isPointLight?: boolean;
     isSpotLight?: boolean;
+    isRectAreaLight?: boolean;
     isHemisphereLight?: boolean;
     isAmbientLight?: boolean;
+    isLightProbe?: boolean;
+    frustumCulled?: boolean;
+    boundingSphere?: ThreeSphereLike | null;
+    computeBoundingSphere?(): void;
     geometry?: ThreeBufferGeometryLike;
     material?: ThreeMaterialLike | ThreeMaterialLike[];
+    onBeforeRender?: (...args: unknown[]) => unknown;
+    onAfterRender?: (...args: unknown[]) => unknown;
+    clippingPlanes?: ThreePlaneLike[] | null;
+    enabled?: boolean;
+    clipIntersection?: boolean;
+    clipShadows?: boolean;
+    customDepthMaterial?: ThreeMaterialLike;
+    customDistanceMaterial?: ThreeMaterialLike;
+    center?: {
+        x?: number;
+        y?: number;
+    };
+    scale?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    count?: number;
+    instanceCount?: number;
+    perObjectFrustumCulled?: boolean;
+    sortObjects?: boolean;
+    customSort?: ((items: Array<{
+        start: number;
+        count: number;
+        z: number;
+        index: number;
+    }>, camera?: ThreeCameraLike) => void) | null;
+    maxInstanceCount?: number;
+    instanceMatrix?: ThreeBufferAttributeLike;
+    instanceColor?: ThreeBufferAttributeLike | null;
+    _instanceInfo?: Array<{
+        visible?: boolean;
+        active?: boolean;
+        geometryIndex?: number;
+    }>;
+    _geometryInfo?: Array<{
+        active?: boolean;
+        start?: number;
+        count?: number;
+        vertexStart?: number;
+        vertexCount?: number;
+        reservedVertexCount?: number;
+        indexStart?: number;
+        indexCount?: number;
+        reservedIndexCount?: number;
+        boundingSphere?: ThreeSphereLike | null;
+    }>;
+    _matricesTexture?: {
+        image?: {
+            data?: ArrayLike<number>;
+        };
+    } | null;
+    _colorsTexture?: {
+        image?: {
+            data?: ArrayLike<number>;
+        };
+    } | null;
+    getGeometryRangeAt?(geometryId: number, target?: Record<string, unknown>): Record<string, unknown> | null;
     matrixWorld?: ThreeMatrix4Like;
+    autoUpdate?: boolean;
+    levels?: Array<{
+        object: ThreeObject3DLike;
+        distance?: number;
+        hysteresis?: number;
+    }>;
+    update?(camera: ThreeCameraLike): void;
     skeleton?: ThreeSkeletonLike;
     bindMatrix?: ThreeMatrix4Like;
     bindMatrixInverse?: ThreeMatrix4Like;
     morphTargetInfluences?: number[];
     morphTargetDictionary?: Record<string, number>;
-    color?: ThreeColorLike;
-    groundColor?: ThreeColorLike;
+    color?: ThreeColorInput;
+    groundColor?: ThreeColorInput;
+    sh?: {
+        coefficients?: Array<ThreeColorLike | {
+            x?: number;
+            y?: number;
+            z?: number;
+        } | ArrayLike<number>>;
+    };
     intensity?: number;
     distance?: number;
     decay?: number;
     angle?: number;
     penumbra?: number;
+    width?: number;
+    height?: number;
     target?: ThreeObject3DLike & {
         matrixWorld?: ThreeMatrix4Like;
     };
@@ -139,9 +518,16 @@ export interface ThreeObject3DLike {
             width?: number;
             height?: number;
         };
+        map?: object | null;
+        mapPass?: object | null;
+        matrix?: ThreeMatrix4Like;
+        autoUpdate?: boolean;
+        needsUpdate?: boolean;
         bias?: number;
         normalBias?: number;
         radius?: number;
+        intensity?: number;
+        blurSamples?: number;
         camera?: {
             left?: number;
             right?: number;
@@ -152,30 +538,199 @@ export interface ThreeObject3DLike {
         };
     };
 }
-export interface ThreeSceneLike extends ThreeObject3DLike {
-    isScene: true;
-    background?: ThreeColorLike | null;
+export interface ThreeSceneRootLike extends ThreeObject3DLike {
+    isScene?: boolean;
+    overrideMaterial?: ThreeMaterialLike | null;
+    background?: ThreeColorInput | ThreeTextureLike | null;
+    backgroundIntensity?: number;
+    backgroundBlurriness?: number;
+    backgroundRotation?: ThreeEulerLike | ArrayLike<number> | null;
+    fog?: {
+        isFog?: boolean;
+        isFogExp2?: boolean;
+        color?: ThreeColorInput;
+        near?: number;
+        far?: number;
+        density?: number;
+    } | null;
     environment?: ThreeTextureLike | null;
     environmentIntensity?: number;
+    environmentRotation?: ThreeEulerLike | ArrayLike<number> | null;
     updateMatrixWorld?(force?: boolean): void;
 }
+export interface ThreeSceneLike extends ThreeSceneRootLike {
+    isScene: true;
+}
 export interface ThreeCameraLike {
     isCamera: true;
+    layers?: ThreeLayersLike;
     projectionMatrix: ThreeMatrix4Like;
     matrixWorldInverse: ThreeMatrix4Like;
     matrixWorld?: ThreeMatrix4Like;
+    isPerspectiveCamera?: boolean;
+    isOrthographicCamera?: boolean;
+    isArrayCamera?: boolean;
+    isCubeCamera?: boolean;
+    cameras?: ThreeCameraLike[];
+    viewport?: RenderPixelRectLike | ({
+        x?: number;
+        y?: number;
+        z?: number;
+        w?: number;
+    } & Record<string, unknown>) | null;
     aspect?: number;
+    zoom?: number;
+    near?: number;
+    far?: number;
     userData?: {
         width?: number;
         height?: number;
     };
     updateMatrixWorld?(force?: boolean): void;
 }
+export interface ThreeCubeCameraLike {
+    isObject3D?: boolean;
+    isCubeCamera?: boolean;
+    type?: string;
+    renderTarget?: RenderTargetLike;
+    children?: ThreeCameraLike[];
+    coordinateSystem?: number | null;
+    activeMipmapLevel?: number;
+    updateCoordinateSystem?(): void;
+    updateMatrixWorld?(force?: boolean): void;
+}
+export type ThreeRenderCameraLike = ThreeCameraLike | ThreeCubeCameraLike;
+export interface RenderSortItem {
+    id: number;
+    object?: ThreeObject3DLike;
+    geometry?: ThreeBufferGeometryLike;
+    material?: ThreeMaterialLike;
+    group?: GeometryGroup;
+    groupOrder: number;
+    renderOrder: number;
+    z: number;
+    materialVariant: number;
+}
+export type RenderSortFunction = (a: RenderSortItem, b: RenderSortItem) => number;
 export interface RenderOptions {
     width?: number;
     height?: number;
-    background?: number[] | ThreeColorLike;
+    background?: ThreeColorInput | ThreeTextureLike | null;
+    backgroundIntensity?: number;
+    backgroundBlurriness?: number;
+    backgroundRotation?: ThreeEulerLike | ArrayLike<number> | null;
+    environmentIntensity?: number;
+    environmentRotation?: ThreeEulerLike | ArrayLike<number> | null;
+    viewport?: RenderPixelRectLike | null;
+    scissor?: RenderPixelRectLike | null;
+    clippingPlanes?: ThreePlaneLike[] | null;
+    /**
+     * Controls whether material-local clippingPlanes are included. Defaults to true
+     * for the scene-oriented API; set false to mimic disabled WebGL local clipping.
+     */
+    localClippingEnabled?: boolean;
     format?: RenderOutputFormat;
+    outputColorSpace?: RenderOutputColorSpace;
+    /** Per-render tone-mapping mode. Defaults to Renderer.toneMapping. */
+    toneMapping?: number;
+    /** Per-render tone-mapping exposure. Defaults to Renderer.toneMappingExposure. */
+    toneMappingExposure?: number;
+    /** Alternate flat render passes. Defaults to normal color rendering. */
+    renderMode?: RenderMode;
+    /** Whether render-list sorting is enabled. Defaults to true. */
+    sortObjects?: boolean;
+    /** Whether opaque render-list buckets are rendered. Defaults to Renderer.opaque. */
+    opaque?: boolean;
+    /** Whether transmissive/transparent render-list buckets are rendered. Defaults to Renderer.transparent. */
+    transparent?: boolean;
+    /** Per-render transmission scene-color resolution scale. Defaults to Renderer.transmissionResolutionScale. */
+    transmissionResolutionScale?: number;
+    /** Custom opaque-bucket sort callback. `null` uses the default sort. */
+    opaqueSort?: RenderSortFunction | null;
+    /** Custom transmissive/transparent-bucket sort callback. `null` uses the default sort. */
+    transparentSort?: RenderSortFunction | null;
+    /** MSAA sample count. Supports 4x MSAA; omitted, 0, or 1 use the single-sample path. */
+    samples?: number;
+    /** MSAA sample count. Supports 4x MSAA; omitted, 0, or 1 use the single-sample path. */
+    sampleCount?: number;
+    target?: RenderTargetLike;
+    postProcessing?: PostProcessingOptions;
+}
+export interface RenderTargetTextureLike {
+    image?: RenderTargetImageLike | RenderTargetImageLike[];
+    mipmaps?: Array<RenderTargetImageLike & {
+        image?: RenderTargetImageLike | RenderTargetImageLike[];
+    }>;
+    source?: {
+        data?: RenderTargetImageLike | RenderTargetImageLike[];
+    };
+    userData?: Record<string, any>;
+    isCubeTexture?: boolean;
+    isFramebufferTexture?: boolean;
+    isDepthTexture?: boolean;
+    isStorageTexture?: boolean;
+    isCompressedTexture?: boolean;
+    isDataArrayTexture?: boolean;
+    isData3DTexture?: boolean;
+    isArrayTexture?: boolean;
+    is3DTexture?: boolean;
+    format?: number;
+    /** Color targets support Alpha/Red/RG/RGB/RGBA and integer channel formats with byte, signed/unsigned integer, packed color, FloatType, and HalfFloatType arrays. */
+    type?: number;
+    generateMipmaps?: boolean;
+    needsUpdate?: boolean;
+    needsPMREMUpdate?: boolean;
+    pmremVersion?: number;
+}
+export interface RenderTargetImageLike {
+    data?: Buffer | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array;
+    width?: number;
+    height?: number;
+    depth?: number;
+}
+export interface RenderTargetLike {
+    isRenderTarget?: boolean;
+    isWebGLRenderTarget?: boolean;
+    width?: number;
+    height?: number;
+    viewport?: RenderPixelRectLike | null;
+    scissor?: RenderPixelRectLike | null;
+    scissorTest?: boolean;
+    texture?: RenderTargetTextureLike | RenderTargetTextureLike[];
+    textures?: RenderTargetTextureLike[];
+    objectIdEntries?: RenderObjectIdEntry[];
+    objectIdMap?: Record<string, RenderObjectIdEntry>;
+    /** Optional normalized depth readback texture-like target. FloatType receives Float32Array data; HalfFloatType receives Uint16Array half-float data; unsigned depth types receive scalar Uint8Array/Uint16Array/Uint32Array data; UnsignedInt248Type packs depth24 in the high bits with zero stencil; plain objects receive RGBA8 bytes. */
+    depthTexture?: RenderTargetTextureLike;
+    /** MSAA sample count. Supports 4x MSAA; omitted, 0, or 1 use the single-sample path. */
+    samples?: number;
+    /** MSAA sample count. Supports 4x MSAA; omitted, 0, or 1 use the single-sample path. */
+    sampleCount?: number;
+    isWebGLCubeRenderTarget?: boolean;
+    isWebGLMultipleRenderTargets?: boolean;
+    image?: {
+        data?: Buffer;
+        width?: number;
+        height?: number;
+    };
+    data?: Buffer;
+}
+export interface RenderObjectIdEntry {
+    /** Adapter object sort id, usually `THREE.Object3D.id`. */
+    id: number;
+    /** 24-bit integer encoded in RGB, with 0 reserved for background. */
+    encodedId: number;
+    rgb: [number, number, number];
+    hex: string;
+}
+export interface PostProcessingOptions {
+    enabled?: boolean;
+    exposure?: number;
+    contrast?: number;
+    saturation?: number;
+    vignette?: number;
+    grayscale?: number | boolean;
+    invert?: number | boolean;
 }
 export interface NativeCamera {
     width?: number;
@@ -187,6 +742,7 @@ export interface NativeCamera {
     near?: number;
     far?: number;
     viewProjection?: number[];
+    viewMatrix?: number[];
     cameraPosition?: number[];
 }
 export interface NativeSceneLight {
@@ -199,15 +755,27 @@ export interface NativeSceneLight {
     decay?: number;
     angle?: number;
     penumbra?: number;
+    width?: number;
+    height?: number;
     groundColor?: number[];
-    /** Whether this light casts shadows (directional only for now). */
+    /** Whether this light casts shadows (directional, spot, and point lights). */
     castShadow?: boolean;
-    /** Shadow map resolution (square). Defaults to 512. */
+    /** Legacy square shadow map resolution. Defaults to 512 when width/height are absent. */
     shadowMapSize?: number;
+    /** Shadow map width in pixels. Defaults to `shadowMapSize` or 512. */
+    shadowMapWidth?: number;
+    /** Shadow map height in pixels. Defaults to `shadowMapSize` or 512. */
+    shadowMapHeight?: number;
     /** Depth bias applied when sampling the shadow map. */
     shadowBias?: number;
     /** Normal-offset bias (world space units) applied at receivers. */
     shadowNormalBias?: number;
+    /** PCF shadow radius multiplier. Defaults to 1. */
+    shadowRadius?: number;
+    /** Shadow darkness multiplier. Defaults to 1; 0 disables received shadow darkening. */
+    shadowIntensity?: number;
+    /** VSM blur sample count. Defaults to Three.js' LightShadow default of 8. */
+    shadowBlurSamples?: number;
     /** Orthographic shadow-camera frustum bounds. */
     shadowCameraLeft?: number;
     shadowCameraRight?: number;
@@ -215,6 +783,9 @@ export interface NativeSceneLight {
     shadowCameraBottom?: number;
     shadowCameraNear?: number;
     shadowCameraFar?: number;
+    /** Directional cascaded shadow maps: split distances from camera and flattened [left,right,top,bottom,near,far] bounds. */
+    shadowCascadeSplits?: number[];
+    shadowCascadeBounds?: number[];
 }
 export interface NativeSceneMesh {
     positions: number[];
@@ -224,52 +795,416 @@ export interface NativeSceneMesh {
     color?: number[];
     transform?: number[];
     uvs?: number[];
+    uvs2?: number[];
     texture?: Buffer;
     textureWidth?: number;
     textureHeight?: number;
     textureWrapS?: string;
     textureWrapT?: string;
+    textureMagFilter?: string;
+    textureMinFilter?: string;
+    textureAnisotropy?: number;
+    textureTransform?: number[];
+    textureColorSpace?: string;
+    textureUsesUv2?: boolean;
+    specularColor?: number[];
+    shininess?: number;
     metallic?: number;
     roughness?: number;
+    clearcoat?: number;
+    clearcoatMap?: Buffer;
+    clearcoatMapWidth?: number;
+    clearcoatMapHeight?: number;
+    clearcoatMapWrapS?: string;
+    clearcoatMapWrapT?: string;
+    clearcoatMapMagFilter?: string;
+    clearcoatMapMinFilter?: string;
+    clearcoatMapAnisotropy?: number;
+    clearcoatMapTransform?: number[];
+    clearcoatMapColorSpace?: string;
+    clearcoatMapUsesUv2?: boolean;
+    clearcoatRoughness?: number;
+    clearcoatRoughnessMap?: Buffer;
+    clearcoatRoughnessMapWidth?: number;
+    clearcoatRoughnessMapHeight?: number;
+    clearcoatRoughnessMapWrapS?: string;
+    clearcoatRoughnessMapWrapT?: string;
+    clearcoatRoughnessMapMagFilter?: string;
+    clearcoatRoughnessMapMinFilter?: string;
+    clearcoatRoughnessMapAnisotropy?: number;
+    clearcoatRoughnessMapTransform?: number[];
+    clearcoatRoughnessMapColorSpace?: string;
+    clearcoatRoughnessMapUsesUv2?: boolean;
+    clearcoatNormalMap?: Buffer;
+    clearcoatNormalMapWidth?: number;
+    clearcoatNormalMapHeight?: number;
+    clearcoatNormalMapWrapS?: string;
+    clearcoatNormalMapWrapT?: string;
+    clearcoatNormalMapMagFilter?: string;
+    clearcoatNormalMapMinFilter?: string;
+    clearcoatNormalMapAnisotropy?: number;
+    clearcoatNormalMapTransform?: number[];
+    clearcoatNormalMapColorSpace?: string;
+    clearcoatNormalMapUsesUv2?: boolean;
+    clearcoatNormalScale?: number[];
+    sheenColor?: number[];
+    sheenColorMap?: Buffer;
+    sheenColorMapWidth?: number;
+    sheenColorMapHeight?: number;
+    sheenColorMapWrapS?: string;
+    sheenColorMapWrapT?: string;
+    sheenColorMapMagFilter?: string;
+    sheenColorMapMinFilter?: string;
+    sheenColorMapAnisotropy?: number;
+    sheenColorMapTransform?: number[];
+    sheenColorMapColorSpace?: string;
+    sheenColorMapUsesUv2?: boolean;
+    sheenRoughness?: number;
+    sheenRoughnessMap?: Buffer;
+    sheenRoughnessMapWidth?: number;
+    sheenRoughnessMapHeight?: number;
+    sheenRoughnessMapWrapS?: string;
+    sheenRoughnessMapWrapT?: string;
+    sheenRoughnessMapMagFilter?: string;
+    sheenRoughnessMapMinFilter?: string;
+    sheenRoughnessMapAnisotropy?: number;
+    sheenRoughnessMapTransform?: number[];
+    sheenRoughnessMapColorSpace?: string;
+    sheenRoughnessMapUsesUv2?: boolean;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: Buffer;
+    anisotropyMapWidth?: number;
+    anisotropyMapHeight?: number;
+    anisotropyMapWrapS?: string;
+    anisotropyMapWrapT?: string;
+    anisotropyMapMagFilter?: string;
+    anisotropyMapMinFilter?: string;
+    anisotropyMapAnisotropy?: number;
+    anisotropyMapTransform?: number[];
+    anisotropyMapColorSpace?: string;
+    anisotropyMapUsesUv2?: boolean;
+    iridescence?: number;
+    iridescenceMap?: Buffer;
+    iridescenceMapWidth?: number;
+    iridescenceMapHeight?: number;
+    iridescenceMapWrapS?: string;
+    iridescenceMapWrapT?: string;
+    iridescenceMapMagFilter?: string;
+    iridescenceMapMinFilter?: string;
+    iridescenceMapAnisotropy?: number;
+    iridescenceMapTransform?: number[];
+    iridescenceMapColorSpace?: string;
+    iridescenceMapUsesUv2?: boolean;
+    iridescenceIor?: number;
+    iridescenceThicknessMin?: number;
+    iridescenceThicknessMax?: number;
+    iridescenceThicknessMap?: Buffer;
+    iridescenceThicknessMapWidth?: number;
+    iridescenceThicknessMapHeight?: number;
+    iridescenceThicknessMapWrapS?: string;
+    iridescenceThicknessMapWrapT?: string;
+    iridescenceThicknessMapMagFilter?: string;
+    iridescenceThicknessMapMinFilter?: string;
+    iridescenceThicknessMapAnisotropy?: number;
+    iridescenceThicknessMapTransform?: number[];
+    iridescenceThicknessMapColorSpace?: string;
+    iridescenceThicknessMapUsesUv2?: boolean;
+    transmission?: number;
+    transmissionMap?: Buffer;
+    transmissionMapWidth?: number;
+    transmissionMapHeight?: number;
+    transmissionMapWrapS?: string;
+    transmissionMapWrapT?: string;
+    transmissionMapMagFilter?: string;
+    transmissionMapMinFilter?: string;
+    transmissionMapAnisotropy?: number;
+    transmissionMapTransform?: number[];
+    transmissionMapColorSpace?: string;
+    transmissionMapUsesUv2?: boolean;
+    dispersion?: number;
+    ior?: number;
+    thickness?: number;
+    thicknessMap?: Buffer;
+    thicknessMapWidth?: number;
+    thicknessMapHeight?: number;
+    thicknessMapWrapS?: string;
+    thicknessMapWrapT?: string;
+    thicknessMapMagFilter?: string;
+    thicknessMapMinFilter?: string;
+    thicknessMapAnisotropy?: number;
+    thicknessMapTransform?: number[];
+    thicknessMapColorSpace?: string;
+    thicknessMapUsesUv2?: boolean;
+    attenuationDistance?: number;
+    attenuationColor?: number[];
+    physicalSpecularColor?: number[];
+    physicalSpecularIntensity?: number;
+    specularColorMap?: Buffer;
+    specularColorMapWidth?: number;
+    specularColorMapHeight?: number;
+    specularColorMapWrapS?: string;
+    specularColorMapWrapT?: string;
+    specularColorMapMagFilter?: string;
+    specularColorMapMinFilter?: string;
+    specularColorMapAnisotropy?: number;
+    specularColorMapTransform?: number[];
+    specularColorMapColorSpace?: string;
+    specularColorMapUsesUv2?: boolean;
+    specularIntensityMap?: Buffer;
+    specularIntensityMapWidth?: number;
+    specularIntensityMapHeight?: number;
+    specularIntensityMapWrapS?: string;
+    specularIntensityMapWrapT?: string;
+    specularIntensityMapMagFilter?: string;
+    specularIntensityMapMinFilter?: string;
+    specularIntensityMapAnisotropy?: number;
+    specularIntensityMapTransform?: number[];
+    specularIntensityMapColorSpace?: string;
+    specularIntensityMapUsesUv2?: boolean;
     emissive?: number[];
     emissiveIntensity?: number;
     normalMap?: Buffer;
     normalMapWidth?: number;
     normalMapHeight?: number;
+    normalMapWrapS?: string;
+    normalMapWrapT?: string;
+    normalMapMagFilter?: string;
+    normalMapMinFilter?: string;
+    normalMapAnisotropy?: number;
+    normalMapTransform?: number[];
+    normalMapColorSpace?: string;
+    normalMapUsesUv2?: boolean;
+    normalMapType?: 'tangent' | 'object';
     normalScale?: number[];
+    bumpMap?: Buffer;
+    bumpMapWidth?: number;
+    bumpMapHeight?: number;
+    bumpMapWrapS?: string;
+    bumpMapWrapT?: string;
+    bumpMapMagFilter?: string;
+    bumpMapMinFilter?: string;
+    bumpMapAnisotropy?: number;
+    bumpMapTransform?: number[];
+    bumpMapColorSpace?: string;
+    bumpMapUsesUv2?: boolean;
+    bumpScale?: number;
+    matcapMap?: Buffer;
+    matcapMapWidth?: number;
+    matcapMapHeight?: number;
+    matcapMapWrapS?: string;
+    matcapMapWrapT?: string;
+    matcapMapMagFilter?: string;
+    matcapMapMinFilter?: string;
+    matcapMapAnisotropy?: number;
+    matcapMapTransform?: number[];
+    matcapMapColorSpace?: string;
+    matcapMapUsesUv2?: boolean;
+    depthPacking?: number;
+    distanceReferencePosition?: number[];
+    distanceNear?: number;
+    distanceFar?: number;
+    gradientMap?: Buffer;
+    gradientMapWidth?: number;
+    gradientMapHeight?: number;
+    gradientMapWrapS?: string;
+    gradientMapWrapT?: string;
+    gradientMapMagFilter?: string;
+    gradientMapMinFilter?: string;
+    gradientMapAnisotropy?: number;
+    gradientMapColorSpace?: string;
+    displacementMap?: Buffer;
+    displacementMapWidth?: number;
+    displacementMapHeight?: number;
+    displacementMapWrapS?: string;
+    displacementMapWrapT?: string;
+    displacementMapMagFilter?: string;
+    displacementMapMinFilter?: string;
+    displacementMapAnisotropy?: number;
+    displacementMapTransform?: number[];
+    displacementMapColorSpace?: string;
+    displacementMapUsesUv2?: boolean;
+    displacementScale?: number;
+    displacementBias?: number;
     metallicRoughnessTexture?: Buffer;
     metallicRoughnessTextureWidth?: number;
     metallicRoughnessTextureHeight?: number;
+    metallicRoughnessTextureWrapS?: string;
+    metallicRoughnessTextureWrapT?: string;
+    metallicRoughnessTextureMagFilter?: string;
+    metallicRoughnessTextureMinFilter?: string;
+    metallicRoughnessTextureAnisotropy?: number;
+    metallicRoughnessTextureTransform?: number[];
+    metallicRoughnessTextureColorSpace?: string;
+    metallicRoughnessTextureUsesUv2?: boolean;
     emissiveMap?: Buffer;
     emissiveMapWidth?: number;
     emissiveMapHeight?: number;
+    emissiveMapWrapS?: string;
+    emissiveMapWrapT?: string;
+    emissiveMapMagFilter?: string;
+    emissiveMapMinFilter?: string;
+    emissiveMapAnisotropy?: number;
+    emissiveMapTransform?: number[];
+    emissiveMapColorSpace?: string;
+    emissiveMapUsesUv2?: boolean;
     aoMap?: Buffer;
     aoMapWidth?: number;
     aoMapHeight?: number;
+    aoMapWrapS?: string;
+    aoMapWrapT?: string;
+    aoMapMagFilter?: string;
+    aoMapMinFilter?: string;
+    aoMapAnisotropy?: number;
+    aoMapTransform?: number[];
+    aoMapColorSpace?: string;
+    aoMapUsesUv2?: boolean;
     aoMapIntensity?: number;
+    lightMap?: Buffer;
+    lightMapWidth?: number;
+    lightMapHeight?: number;
+    lightMapWrapS?: string;
+    lightMapWrapT?: string;
+    lightMapMagFilter?: string;
+    lightMapMinFilter?: string;
+    lightMapAnisotropy?: number;
+    lightMapTransform?: number[];
+    lightMapColorSpace?: string;
+    lightMapUsesUv2?: boolean;
+    lightMapIntensity?: number;
+    specularMap?: Buffer;
+    specularMapWidth?: number;
+    specularMapHeight?: number;
+    specularMapWrapS?: string;
+    specularMapWrapT?: string;
+    specularMapMagFilter?: string;
+    specularMapMinFilter?: string;
+    specularMapAnisotropy?: number;
+    specularMapTransform?: number[];
+    specularMapColorSpace?: string;
+    specularMapUsesUv2?: boolean;
+    alphaMap?: Buffer;
+    alphaMapWidth?: number;
+    alphaMapHeight?: number;
+    alphaMapWrapS?: string;
+    alphaMapWrapT?: string;
+    alphaMapMagFilter?: string;
+    alphaMapMinFilter?: string;
+    alphaMapAnisotropy?: number;
+    alphaMapTransform?: number[];
+    alphaMapColorSpace?: string;
+    alphaMapUsesUv2?: boolean;
     alphaTest?: number;
+    alphaHash?: boolean;
+    alphaToCoverage?: boolean;
+    premultipliedAlpha?: boolean;
+    toneMapped?: boolean;
+    flatShading?: boolean;
+    fog?: boolean;
+    /** Flattened world-space clipping planes `[nx, ny, nz, constant, ...]`, up to 8 planes. */
+    clippingPlanes?: number[];
+    /** Number of leading clipping planes evaluated as union planes; remaining planes use intersection semantics. */
+    clippingUnionCount?: number;
+    /** Whether material clipping planes affect this mesh in the shadow pass. */
+    clipShadows?: boolean;
+    blending?: string;
+    blendEquation?: number;
+    blendSrc?: number;
+    blendDst?: number;
+    blendEquationAlpha?: number;
+    blendSrcAlpha?: number;
+    blendDstAlpha?: number;
+    blendColor?: number[];
+    blendAlpha?: number;
+    depthTest?: boolean;
+    depthFunc?: string;
+    depthWrite?: boolean;
+    colorWrite?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    polygonOffsetUnits?: number;
+    stencilWrite?: boolean;
+    stencilWriteMask?: number;
+    stencilFunc?: number;
+    stencilRef?: number;
+    stencilFuncMask?: number;
+    stencilFail?: number;
+    stencilZFail?: number;
+    stencilZPass?: number;
     transparent?: boolean;
     side?: string;
+    /** Optional shadow-pass face filter from material.shadowSide. Unset preserves the renderer's default no-cull caster behavior. */
+    shadowSide?: string;
     shadingModel?: string;
+    useEnvironmentMap?: boolean;
+    environmentMapIntensity?: number;
+    environmentMapCombine?: number;
+    environmentMapReflectivity?: number;
+    environmentMapRefraction?: boolean;
+    environmentMapRefractionRatio?: number;
     topology?: string;
+    /** WGSL fragment body used by the custom material path. */
+    customFragmentShader?: string;
     /** Whether this mesh casts shadows in the shadow pass. Defaults to false. */
     castShadow?: boolean;
     /** Whether this mesh receives shadows in the main pass. Defaults to false. */
     receiveShadow?: boolean;
+    groupOrder?: number;
+    renderOrder?: number;
+    sortZ?: number;
+    sortIndex?: number;
+    materialVariant?: number;
+    materialSortKey?: number;
 }
 export interface NativeRenderScene {
     width?: number;
     height?: number;
     background?: number[];
+    backgroundIntensity?: number;
+    viewport?: number[];
+    scissor?: number[];
+    backgroundTexture?: Buffer;
+    backgroundTextureWidth?: number;
+    backgroundTextureHeight?: number;
+    backgroundTextureWrapS?: string;
+    backgroundTextureWrapT?: string;
+    backgroundTextureMagFilter?: string;
+    backgroundTextureMinFilter?: string;
+    backgroundTextureAnisotropy?: number;
+    backgroundTextureTransform?: number[];
+    backgroundTextureColorSpace?: string;
+    backgroundTextureMapping?: string;
+    backgroundTextureRotation?: number[];
+    backgroundTextureBlurriness?: number;
     format?: string;
+    outputColorSpace?: string;
+    toneMapping?: number;
+    toneMappingExposure?: number;
+    transmissionResolutionScale?: number;
+    sampleCount?: number;
+    shadowMapType?: number;
     meshes?: NativeSceneMesh[];
     lights?: NativeSceneLight[];
     ambientLight?: number[];
     ambientIntensity?: number;
+    lightProbe?: number[];
     environmentMap?: Buffer;
     environmentMapWidth?: number;
     environmentMapHeight?: number;
     environmentMapIntensity?: number;
+    environmentMapColorSpace?: string;
+    environmentMapRotation?: number[];
+    fogType?: string;
+    fogColor?: number[];
+    fogNear?: number;
+    fogFar?: number;
+    fogDensity?: number;
+    postExposure?: number;
+    postContrast?: number;
+    postSaturation?: number;
+    postVignette?: number;
+    postGrayscale?: number;
+    postInvert?: number;
 }
 export type Color4 = [number, number, number, number];
 export type Mat4 = number[];
@@ -277,26 +1212,333 @@ export type Vec3 = [number, number, number];
 export interface PbrProperties {
     metallic?: number;
     roughness?: number;
+    clearcoat?: number;
+    clearcoatMap?: Buffer;
+    clearcoatMapWidth?: number;
+    clearcoatMapHeight?: number;
+    clearcoatMapWrapS?: string;
+    clearcoatMapWrapT?: string;
+    clearcoatMapMagFilter?: string;
+    clearcoatMapMinFilter?: string;
+    clearcoatMapAnisotropy?: number;
+    clearcoatMapTransform?: number[];
+    clearcoatMapColorSpace?: string;
+    clearcoatMapUsesUv2?: boolean;
+    clearcoatRoughness?: number;
+    clearcoatRoughnessMap?: Buffer;
+    clearcoatRoughnessMapWidth?: number;
+    clearcoatRoughnessMapHeight?: number;
+    clearcoatRoughnessMapWrapS?: string;
+    clearcoatRoughnessMapWrapT?: string;
+    clearcoatRoughnessMapMagFilter?: string;
+    clearcoatRoughnessMapMinFilter?: string;
+    clearcoatRoughnessMapAnisotropy?: number;
+    clearcoatRoughnessMapTransform?: number[];
+    clearcoatRoughnessMapColorSpace?: string;
+    clearcoatRoughnessMapUsesUv2?: boolean;
+    clearcoatNormalMap?: Buffer;
+    clearcoatNormalMapWidth?: number;
+    clearcoatNormalMapHeight?: number;
+    clearcoatNormalMapWrapS?: string;
+    clearcoatNormalMapWrapT?: string;
+    clearcoatNormalMapMagFilter?: string;
+    clearcoatNormalMapMinFilter?: string;
+    clearcoatNormalMapAnisotropy?: number;
+    clearcoatNormalMapTransform?: number[];
+    clearcoatNormalMapColorSpace?: string;
+    clearcoatNormalMapUsesUv2?: boolean;
+    clearcoatNormalScale?: number[];
+    sheenColor?: number[];
+    sheenColorMap?: Buffer;
+    sheenColorMapWidth?: number;
+    sheenColorMapHeight?: number;
+    sheenColorMapWrapS?: string;
+    sheenColorMapWrapT?: string;
+    sheenColorMapMagFilter?: string;
+    sheenColorMapMinFilter?: string;
+    sheenColorMapAnisotropy?: number;
+    sheenColorMapTransform?: number[];
+    sheenColorMapColorSpace?: string;
+    sheenColorMapUsesUv2?: boolean;
+    sheenRoughness?: number;
+    sheenRoughnessMap?: Buffer;
+    sheenRoughnessMapWidth?: number;
+    sheenRoughnessMapHeight?: number;
+    sheenRoughnessMapWrapS?: string;
+    sheenRoughnessMapWrapT?: string;
+    sheenRoughnessMapMagFilter?: string;
+    sheenRoughnessMapMinFilter?: string;
+    sheenRoughnessMapAnisotropy?: number;
+    sheenRoughnessMapTransform?: number[];
+    sheenRoughnessMapColorSpace?: string;
+    sheenRoughnessMapUsesUv2?: boolean;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: Buffer;
+    anisotropyMapWidth?: number;
+    anisotropyMapHeight?: number;
+    anisotropyMapWrapS?: string;
+    anisotropyMapWrapT?: string;
+    anisotropyMapMagFilter?: string;
+    anisotropyMapMinFilter?: string;
+    anisotropyMapAnisotropy?: number;
+    anisotropyMapTransform?: number[];
+    anisotropyMapColorSpace?: string;
+    anisotropyMapUsesUv2?: boolean;
+    iridescence?: number;
+    iridescenceMap?: Buffer;
+    iridescenceMapWidth?: number;
+    iridescenceMapHeight?: number;
+    iridescenceMapWrapS?: string;
+    iridescenceMapWrapT?: string;
+    iridescenceMapMagFilter?: string;
+    iridescenceMapMinFilter?: string;
+    iridescenceMapAnisotropy?: number;
+    iridescenceMapTransform?: number[];
+    iridescenceMapColorSpace?: string;
+    iridescenceMapUsesUv2?: boolean;
+    iridescenceIor?: number;
+    iridescenceThicknessMin?: number;
+    iridescenceThicknessMax?: number;
+    iridescenceThicknessMap?: Buffer;
+    iridescenceThicknessMapWidth?: number;
+    iridescenceThicknessMapHeight?: number;
+    iridescenceThicknessMapWrapS?: string;
+    iridescenceThicknessMapWrapT?: string;
+    iridescenceThicknessMapMagFilter?: string;
+    iridescenceThicknessMapMinFilter?: string;
+    iridescenceThicknessMapAnisotropy?: number;
+    iridescenceThicknessMapTransform?: number[];
+    iridescenceThicknessMapColorSpace?: string;
+    iridescenceThicknessMapUsesUv2?: boolean;
+    transmission?: number;
+    transmissionMap?: Buffer;
+    transmissionMapWidth?: number;
+    transmissionMapHeight?: number;
+    transmissionMapWrapS?: string;
+    transmissionMapWrapT?: string;
+    transmissionMapMagFilter?: string;
+    transmissionMapMinFilter?: string;
+    transmissionMapAnisotropy?: number;
+    transmissionMapTransform?: number[];
+    transmissionMapColorSpace?: string;
+    transmissionMapUsesUv2?: boolean;
+    dispersion?: number;
+    ior?: number;
+    thickness?: number;
+    thicknessMap?: Buffer;
+    thicknessMapWidth?: number;
+    thicknessMapHeight?: number;
+    thicknessMapWrapS?: string;
+    thicknessMapWrapT?: string;
+    thicknessMapMagFilter?: string;
+    thicknessMapMinFilter?: string;
+    thicknessMapAnisotropy?: number;
+    thicknessMapTransform?: number[];
+    thicknessMapColorSpace?: string;
+    thicknessMapUsesUv2?: boolean;
+    attenuationDistance?: number;
+    attenuationColor?: number[];
+    physicalSpecularColor?: number[];
+    physicalSpecularIntensity?: number;
+    useEnvironmentMap?: boolean;
+    environmentMapIntensity?: number;
+    environmentMapCombine?: number;
+    environmentMapReflectivity?: number;
+    environmentMapRefraction?: boolean;
+    environmentMapRefractionRatio?: number;
+    specularColorMap?: Buffer;
+    specularColorMapWidth?: number;
+    specularColorMapHeight?: number;
+    specularColorMapWrapS?: string;
+    specularColorMapWrapT?: string;
+    specularColorMapMagFilter?: string;
+    specularColorMapMinFilter?: string;
+    specularColorMapAnisotropy?: number;
+    specularColorMapTransform?: number[];
+    specularColorMapColorSpace?: string;
+    specularColorMapUsesUv2?: boolean;
+    specularIntensityMap?: Buffer;
+    specularIntensityMapWidth?: number;
+    specularIntensityMapHeight?: number;
+    specularIntensityMapWrapS?: string;
+    specularIntensityMapWrapT?: string;
+    specularIntensityMapMagFilter?: string;
+    specularIntensityMapMinFilter?: string;
+    specularIntensityMapAnisotropy?: number;
+    specularIntensityMapTransform?: number[];
+    specularIntensityMapColorSpace?: string;
+    specularIntensityMapUsesUv2?: boolean;
     emissive?: number[];
     emissiveIntensity?: number;
+    specularColor?: number[];
+    shininess?: number;
     normalMap?: Buffer;
     normalMapWidth?: number;
     normalMapHeight?: number;
+    normalMapWrapS?: string;
+    normalMapWrapT?: string;
+    normalMapMagFilter?: string;
+    normalMapMinFilter?: string;
+    normalMapAnisotropy?: number;
+    normalMapTransform?: number[];
+    normalMapColorSpace?: string;
+    normalMapUsesUv2?: boolean;
+    normalMapType?: 'tangent' | 'object';
     normalScale?: number[];
+    bumpMap?: Buffer;
+    bumpMapWidth?: number;
+    bumpMapHeight?: number;
+    bumpMapWrapS?: string;
+    bumpMapWrapT?: string;
+    bumpMapMagFilter?: string;
+    bumpMapMinFilter?: string;
+    bumpMapAnisotropy?: number;
+    bumpMapTransform?: number[];
+    bumpMapColorSpace?: string;
+    bumpMapUsesUv2?: boolean;
+    bumpScale?: number;
+    matcapMap?: Buffer;
+    matcapMapWidth?: number;
+    matcapMapHeight?: number;
+    matcapMapWrapS?: string;
+    matcapMapWrapT?: string;
+    matcapMapMagFilter?: string;
+    matcapMapMinFilter?: string;
+    matcapMapAnisotropy?: number;
+    matcapMapTransform?: number[];
+    matcapMapColorSpace?: string;
+    matcapMapUsesUv2?: boolean;
+    depthPacking?: number;
+    distanceReferencePosition?: number[];
+    distanceNear?: number;
+    distanceFar?: number;
+    gradientMap?: Buffer;
+    gradientMapWidth?: number;
+    gradientMapHeight?: number;
+    gradientMapWrapS?: string;
+    gradientMapWrapT?: string;
+    gradientMapMagFilter?: string;
+    gradientMapMinFilter?: string;
+    gradientMapAnisotropy?: number;
+    gradientMapColorSpace?: string;
+    displacementMap?: Buffer;
+    displacementMapWidth?: number;
+    displacementMapHeight?: number;
+    displacementMapWrapS?: string;
+    displacementMapWrapT?: string;
+    displacementMapMagFilter?: string;
+    displacementMapMinFilter?: string;
+    displacementMapAnisotropy?: number;
+    displacementMapTransform?: number[];
+    displacementMapColorSpace?: string;
+    displacementMapUsesUv2?: boolean;
+    displacementScale?: number;
+    displacementBias?: number;
     metallicRoughnessTexture?: Buffer;
     metallicRoughnessTextureWidth?: number;
     metallicRoughnessTextureHeight?: number;
+    metallicRoughnessTextureWrapS?: string;
+    metallicRoughnessTextureWrapT?: string;
+    metallicRoughnessTextureMagFilter?: string;
+    metallicRoughnessTextureMinFilter?: string;
+    metallicRoughnessTextureAnisotropy?: number;
+    metallicRoughnessTextureTransform?: number[];
+    metallicRoughnessTextureColorSpace?: string;
+    metallicRoughnessTextureUsesUv2?: boolean;
     emissiveMap?: Buffer;
     emissiveMapWidth?: number;
     emissiveMapHeight?: number;
+    emissiveMapWrapS?: string;
+    emissiveMapWrapT?: string;
+    emissiveMapMagFilter?: string;
+    emissiveMapMinFilter?: string;
+    emissiveMapAnisotropy?: number;
+    emissiveMapTransform?: number[];
+    emissiveMapColorSpace?: string;
+    emissiveMapUsesUv2?: boolean;
     aoMap?: Buffer;
     aoMapWidth?: number;
     aoMapHeight?: number;
+    aoMapWrapS?: string;
+    aoMapWrapT?: string;
+    aoMapMagFilter?: string;
+    aoMapMinFilter?: string;
+    aoMapAnisotropy?: number;
+    aoMapTransform?: number[];
+    aoMapColorSpace?: string;
+    aoMapUsesUv2?: boolean;
     aoMapIntensity?: number;
+    lightMap?: Buffer;
+    lightMapWidth?: number;
+    lightMapHeight?: number;
+    lightMapWrapS?: string;
+    lightMapWrapT?: string;
+    lightMapMagFilter?: string;
+    lightMapMinFilter?: string;
+    lightMapAnisotropy?: number;
+    lightMapTransform?: number[];
+    lightMapColorSpace?: string;
+    lightMapUsesUv2?: boolean;
+    lightMapIntensity?: number;
+    specularMap?: Buffer;
+    specularMapWidth?: number;
+    specularMapHeight?: number;
+    specularMapWrapS?: string;
+    specularMapWrapT?: string;
+    specularMapMagFilter?: string;
+    specularMapMinFilter?: string;
+    specularMapAnisotropy?: number;
+    specularMapTransform?: number[];
+    specularMapColorSpace?: string;
+    specularMapUsesUv2?: boolean;
+    alphaMap?: Buffer;
+    alphaMapWidth?: number;
+    alphaMapHeight?: number;
+    alphaMapWrapS?: string;
+    alphaMapWrapT?: string;
+    alphaMapMagFilter?: string;
+    alphaMapMinFilter?: string;
+    alphaMapAnisotropy?: number;
+    alphaMapTransform?: number[];
+    alphaMapColorSpace?: string;
+    alphaMapUsesUv2?: boolean;
     alphaTest?: number;
+    alphaHash?: boolean;
+    alphaToCoverage?: boolean;
+    premultipliedAlpha?: boolean;
+    toneMapped?: boolean;
+    flatShading?: boolean;
+    fog?: boolean;
     transparent?: boolean;
+    blending?: string;
+    blendEquation?: number;
+    blendSrc?: number;
+    blendDst?: number;
+    blendEquationAlpha?: number;
+    blendSrcAlpha?: number;
+    blendDstAlpha?: number;
+    blendColor?: number[];
+    blendAlpha?: number;
+    depthTest?: boolean;
+    depthFunc?: string;
+    depthWrite?: boolean;
+    colorWrite?: boolean;
+    polygonOffset?: boolean;
+    polygonOffsetFactor?: number;
+    polygonOffsetUnits?: number;
+    stencilWrite?: boolean;
+    stencilWriteMask?: number;
+    stencilFunc?: number;
+    stencilRef?: number;
+    stencilFuncMask?: number;
+    stencilFail?: number;
+    stencilZFail?: number;
+    stencilZPass?: number;
     side?: string;
+    shadowSide?: string;
     shadingModel?: string;
+    customFragmentShader?: string;
 }
 export interface TextureInfo {
     data: Buffer;
@@ -304,6 +1546,13 @@ export interface TextureInfo {
     height: number;
     wrapS?: string;
     wrapT?: string;
+    magFilter?: string;
+    minFilter?: string;
+    anisotropy?: number;
+    transform?: number[];
+    colorSpace?: string;
+    mapping?: 'uv' | 'equirectangular';
+    usesUv2?: boolean;
 }
 export interface GeometryGroup {
     start: number;