@headless-three/renderer 0.1.7 → 0.1.9

package/native.d.ts

@@ -23,10 +23,22 @@ export interface Camera {
   far?: number
   /** Optional column-major 4x4 view-projection matrix in WebGPU clip space. */
   viewProjection?: Array<number>
+  /** Optional column-major 4x4 view matrix. */
+  viewMatrix?: Array<number>
   /** Camera world position `[x, y, z]` for PBR lighting. */
   cameraPosition?: Array<number>
 }
 
+export interface DecodedImage {
+  data: Buffer
+  width: number
+  height: number
+}
+
+export declare function decodeImage(data: Buffer): DecodedImage
+
+export declare function encodePng(data: Buffer, width: number, height: number): Buffer
+
 export declare function renderNative(scene: RenderScene, camera: Camera): Buffer
 
 export interface RenderScene {
@@ -36,8 +48,52 @@ export interface RenderScene {
   height?: number
   /** Clear color as `[r, g, b]` or `[r, g, b, a]`, with values in the 0..1 range. */
   background?: Array<number>
+  /** Background color/texture intensity multiplier. Defaults to 1. */
+  backgroundIntensity?: number
+  /** Optional output viewport `[x, y, width, height]` in top-left pixel coordinates. */
+  viewport?: Array<number>
+  /** Optional output scissor rectangle `[x, y, width, height]` in top-left pixel coordinates. */
+  scissor?: Array<number>
+  /** Optional scene background texture image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP). */
+  backgroundTexture?: Buffer
+  /** Background texture width in pixels (required when `background_texture` is raw RGBA8 bytes). */
+  backgroundTextureWidth?: number
+  /** Background texture height in pixels (required when `background_texture` is raw RGBA8 bytes). */
+  backgroundTextureHeight?: number
+  /** Background texture horizontal wrap mode: `"repeat"`, `"clamp"`, or `"mirror"`. Defaults to `"clamp"`. */
+  backgroundTextureWrapS?: string
+  /** Background texture vertical wrap mode: `"repeat"`, `"clamp"`, or `"mirror"`. Defaults to `"clamp"`. */
+  backgroundTextureWrapT?: string
+  /** Background texture magnification filter: `"nearest"` or `"linear"`. Defaults to `"linear"`. */
+  backgroundTextureMagFilter?: string
+  /** Background texture minification filter: `"nearest"` or `"linear"`. Defaults to `"linear"`. */
+  backgroundTextureMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  backgroundTextureAnisotropy?: number
+  /** Background texture UV transform `[a, c, tx, b, d, ty]`. */
+  backgroundTextureTransform?: Array<number>
+  /** Background texture color space. `"srgb"` is decoded to linear before output conversion. */
+  backgroundTextureColorSpace?: string
+  /** Background texture mapping: `"uv"` (default) or `"equirectangular"`. */
+  backgroundTextureMapping?: string
+  /** Background texture direction rotation matrix columns, flattened 3x3. */
+  backgroundTextureRotation?: Array<number>
+  /** Approximate 2D background texture blur amount in the 0..1 range. */
+  backgroundTextureBlurriness?: number
   /** Output format. Supported values are `"png"` (default) and `"rgba"`. */
   format?: string
+  /** Output color space. Supported values are `"srgb"` (default), `"srgb-linear"`, `"linear-srgb"`, `"linearsrgb"`, and `"linear"`. */
+  outputColorSpace?: string
+  /** Three.js tone-mapping mode. Supports No, Linear, Reinhard, Cineon, ACES Filmic, Custom, AgX, and Neutral. Defaults to ACES Filmic. */
+  toneMapping?: number
+  /** Material tone-mapping exposure multiplier. Defaults to 1. */
+  toneMappingExposure?: number
+  /** Scene-color texture resolution scale for physical transmission. Defaults to 1. */
+  transmissionResolutionScale?: number
+  /** MSAA sample count. Supports `4`; omitted, `0`, or `1` use the single-sample path. */
+  sampleCount?: number
+  /** Three.js shadow-map type. Supports Basic, PCF, PCFSoft, and VSM constants; defaults to PCF. */
+  shadowMapType?: number
   /** Triangle-list meshes generated by the JavaScript Three.js adapter. */
   meshes?: Array<SceneMesh>
   /** Scene lights. */
@@ -46,6 +102,8 @@ export interface RenderScene {
   ambientLight?: Array<number>
   /** Ambient light intensity. Defaults to 0. */
   ambientIntensity?: number
+  /** Flattened LightProbe spherical-harmonics coefficients: 9 RGB triplets. */
+  lightProbe?: Array<number>
   /** Optional environment map image data (equirectangular HDR/LDR, encoded or raw RGBA/Float). */
   environmentMap?: Buffer
   /** Environment map width in pixels (required when data is raw typed-array bytes). */
@@ -54,10 +112,36 @@ export interface RenderScene {
   environmentMapHeight?: number
   /** Environment map intensity multiplier. Defaults to 1. */
   environmentMapIntensity?: number
+  /** Environment map color space. `"srgb"` is decoded to linear; omitted defaults to sRGB for 8-bit inputs. */
+  environmentMapColorSpace?: string
+  /** Environment map direction rotation matrix columns, flattened 3x3. */
+  environmentMapRotation?: Array<number>
+  /** Scene fog mode: `"linear"` for THREE.Fog or `"exp2"` for THREE.FogExp2. */
+  fogType?: string
+  /** Fog color `[r, g, b]` in 0..1 range. */
+  fogColor?: Array<number>
+  /** Linear fog near distance. Defaults to 1. */
+  fogNear?: number
+  /** Linear fog far distance. Defaults to 1000. */
+  fogFar?: number
+  /** Exponential squared fog density. Defaults to 0.00025. */
+  fogDensity?: number
+  /** Post-processing exposure adjustment in stops. Defaults to 0. */
+  postExposure?: number
+  /** Post-processing contrast multiplier. Defaults to 1. */
+  postContrast?: number
+  /** Post-processing saturation multiplier. Defaults to 1. */
+  postSaturation?: number
+  /** Post-processing vignette amount 0..1. Defaults to 0. */
+  postVignette?: number
+  /** Post-processing grayscale blend 0..1. Defaults to 0. */
+  postGrayscale?: number
+  /** Post-processing inversion blend 0..1. Defaults to 0. */
+  postInvert?: number
 }
 
 export interface SceneLight {
-  /** Light type: `"directional"`, `"point"`, `"spot"`, or `"hemisphere"`. */
+  /** Light type: `"directional"`, `"point"`, `"spot"`, `"rectArea"`, or `"hemisphere"`. */
   lightType: string
   /** Light color `[r, g, b]` in 0..1 range. */
   color?: Array<number>
@@ -75,16 +159,30 @@ export interface SceneLight {
   angle?: number
   /** Spotlight penumbra 0..1. Defaults to 0. */
   penumbra?: number
+  /** RectAreaLight width in world units. */
+  width?: number
+  /** RectAreaLight height in world units. */
+  height?: number
   /** Hemisphere light ground color `[r, g, b]` in 0..1 range. */
   groundColor?: Array<number>
-  /** Whether this light casts shadows (directional lights only). */
+  /** Whether this light casts shadows (directional, spot, and point lights). */
   castShadow?: boolean
-  /** Shadow map resolution (square, pixels). Defaults to 512. */
+  /** Legacy square shadow map resolution in pixels. 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 in shadow-map NDC. */
   shadowBias?: number
   /** Normal-offset bias in world space at the receiver. */
   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
@@ -92,9 +190,19 @@ export interface SceneLight {
   shadowCameraBottom?: number
   shadowCameraNear?: number
   shadowCameraFar?: number
+  /** Cascaded shadow split distances from the active camera. */
+  shadowCascadeSplits?: Array<number>
+  /** Flattened cascade bounds: `[left, right, top, bottom, near, far, ...]`. */
+  shadowCascadeBounds?: Array<number>
 }
 
 export interface SceneMesh {
+  /** Stable renderer-local key for reusing cached native mesh buffers. */
+  nativeMeshKey?: number
+  /** Vertex count for cached native mesh-buffer references. */
+  nativeVertexCount?: number
+  /** Index count for cached native mesh-buffer references. */
+  nativeIndexCount?: number
   /** Flat xyz positions: `[x0, y0, z0, x1, y1, z1, ...]`. */
   positions: Array<number>
   /** Optional uint32 triangle-list indices. */
@@ -109,6 +217,12 @@ export interface SceneMesh {
   transform?: Array<number>
   /** Optional per-vertex UV coordinates: `[u0, v0, u1, v1, ...]`. */
   uvs?: Array<number>
+  /** Optional secondary UV coordinates, used by AO/light-style maps. */
+  uvs2?: Array<number>
+  /** Use per-face normals for flat-shaded triangle materials. */
+  flatShading?: boolean
+  /** Whether this material is affected by scene fog. Defaults to true. */
+  fog?: boolean
   /** Optional texture image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP). */
   texture?: Buffer
   /** Texture width in pixels (required when `texture` is raw RGBA8 bytes). */
@@ -119,16 +233,372 @@ export interface SceneMesh {
   textureWrapS?: string
   /** Texture vertical wrap mode: `"repeat"`, `"clamp"`, or `"mirror"`. Defaults to `"clamp"`. */
   textureWrapT?: string
+  /** Texture magnification filter: `"nearest"` or `"linear"`. Defaults to `"linear"`. */
+  textureMagFilter?: string
+  /** Texture minification filter: `"nearest"` or `"linear"`. Defaults to `"linear"`. */
+  textureMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  textureAnisotropy?: number
+  /** Base-color map UV transform `[a, c, tx, b, d, ty]`. */
+  textureTransform?: Array<number>
+  /** Base-color texture color space. `"srgb"` is decoded to linear before shading. */
+  textureColorSpace?: string
+  /** Whether base-color map sampling uses the secondary UV stream. */
+  textureUsesUv2?: boolean
   /** Optional metallic-roughness texture (glTF convention: G=roughness, B=metallic). */
   metallicRoughnessTexture?: Buffer
   /** Metallic-roughness texture width (required when texture is raw RGBA8 bytes). */
   metallicRoughnessTextureWidth?: number
   /** Metallic-roughness texture height (required when texture is raw RGBA8 bytes). */
   metallicRoughnessTextureHeight?: number
+  /** Metallic-roughness texture horizontal wrap mode. */
+  metallicRoughnessTextureWrapS?: string
+  /** Metallic-roughness texture vertical wrap mode. */
+  metallicRoughnessTextureWrapT?: string
+  /** Metallic-roughness texture magnification filter. */
+  metallicRoughnessTextureMagFilter?: string
+  /** Metallic-roughness texture minification filter. */
+  metallicRoughnessTextureMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  metallicRoughnessTextureAnisotropy?: number
+  /** Metallic-roughness map UV transform `[a, c, tx, b, d, ty]`. */
+  metallicRoughnessTextureTransform?: Array<number>
+  /** Metallic-roughness texture color space. `"srgb"` is decoded to linear before shading. */
+  metallicRoughnessTextureColorSpace?: string
+  /** Whether metallic-roughness map sampling uses the secondary UV stream. */
+  metallicRoughnessTextureUsesUv2?: boolean
+  /** Optional specular strength map. Red channel multiplies MeshPhongMaterial specular. */
+  specularMap?: Buffer
+  /** Specular map width (required when map is raw RGBA8 bytes). */
+  specularMapWidth?: number
+  /** Specular map height (required when map is raw RGBA8 bytes). */
+  specularMapHeight?: number
+  /** Specular map horizontal wrap mode. */
+  specularMapWrapS?: string
+  /** Specular map vertical wrap mode. */
+  specularMapWrapT?: string
+  /** Specular map magnification filter. */
+  specularMapMagFilter?: string
+  /** Specular map minification filter. */
+  specularMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  specularMapAnisotropy?: number
+  /** Specular map UV transform `[a, c, tx, b, d, ty]`. */
+  specularMapTransform?: Array<number>
+  /** Specular map color space. `"srgb"` is decoded to linear before shading. */
+  specularMapColorSpace?: string
+  /** Whether specular map sampling uses the secondary UV stream. */
+  specularMapUsesUv2?: boolean
   /** Metallic factor (0..1). Defaults to 0. */
   metallic?: number
   /** Roughness factor (0..1). Defaults to 1. */
   roughness?: number
+  /** Clearcoat intensity (0..1) for MeshPhysicalMaterial. Defaults to 0. */
+  clearcoat?: number
+  /** Optional clearcoat intensity map. Red channel multiplies `clearcoat`. */
+  clearcoatMap?: Buffer
+  /** Clearcoat map width (required when map is raw RGBA8 bytes). */
+  clearcoatMapWidth?: number
+  /** Clearcoat map height (required when map is raw RGBA8 bytes). */
+  clearcoatMapHeight?: number
+  /** Clearcoat map horizontal wrap mode. */
+  clearcoatMapWrapS?: string
+  /** Clearcoat map vertical wrap mode. */
+  clearcoatMapWrapT?: string
+  /** Clearcoat map magnification filter. */
+  clearcoatMapMagFilter?: string
+  /** Clearcoat map minification filter. */
+  clearcoatMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  clearcoatMapAnisotropy?: number
+  /** Clearcoat map UV transform `[a, c, tx, b, d, ty]`. */
+  clearcoatMapTransform?: Array<number>
+  /** Clearcoat map color space. `"srgb"` is decoded to linear before shading. */
+  clearcoatMapColorSpace?: string
+  /** Whether clearcoat map sampling uses the secondary UV stream. */
+  clearcoatMapUsesUv2?: boolean
+  /** Clearcoat roughness (0..1). Defaults to 0. */
+  clearcoatRoughness?: number
+  /** Optional clearcoat roughness map. Green channel multiplies `clearcoatRoughness`. */
+  clearcoatRoughnessMap?: Buffer
+  /** Clearcoat roughness map width (required when map is raw RGBA8 bytes). */
+  clearcoatRoughnessMapWidth?: number
+  /** Clearcoat roughness map height (required when map is raw RGBA8 bytes). */
+  clearcoatRoughnessMapHeight?: number
+  /** Clearcoat roughness map horizontal wrap mode. */
+  clearcoatRoughnessMapWrapS?: string
+  /** Clearcoat roughness map vertical wrap mode. */
+  clearcoatRoughnessMapWrapT?: string
+  /** Clearcoat roughness map magnification filter. */
+  clearcoatRoughnessMapMagFilter?: string
+  /** Clearcoat roughness map minification filter. */
+  clearcoatRoughnessMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  clearcoatRoughnessMapAnisotropy?: number
+  /** Clearcoat roughness map UV transform `[a, c, tx, b, d, ty]`. */
+  clearcoatRoughnessMapTransform?: Array<number>
+  /** Clearcoat roughness map color space. `"srgb"` is decoded to linear before shading. */
+  clearcoatRoughnessMapColorSpace?: string
+  /** Whether clearcoat roughness map sampling uses the secondary UV stream. */
+  clearcoatRoughnessMapUsesUv2?: boolean
+  /** Optional clearcoat normal map. */
+  clearcoatNormalMap?: Buffer
+  /** Clearcoat normal map width (required when map is raw RGBA8 bytes). */
+  clearcoatNormalMapWidth?: number
+  /** Clearcoat normal map height (required when map is raw RGBA8 bytes). */
+  clearcoatNormalMapHeight?: number
+  /** Clearcoat normal map horizontal wrap mode. */
+  clearcoatNormalMapWrapS?: string
+  /** Clearcoat normal map vertical wrap mode. */
+  clearcoatNormalMapWrapT?: string
+  /** Clearcoat normal map magnification filter. */
+  clearcoatNormalMapMagFilter?: string
+  /** Clearcoat normal map minification filter. */
+  clearcoatNormalMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  clearcoatNormalMapAnisotropy?: number
+  /** Clearcoat normal map UV transform `[a, c, tx, b, d, ty]`. */
+  clearcoatNormalMapTransform?: Array<number>
+  /** Clearcoat normal map color space. `"srgb"` decodes RGB channels before normal sampling. */
+  clearcoatNormalMapColorSpace?: string
+  /** Whether clearcoat normal map sampling uses the secondary UV stream. */
+  clearcoatNormalMapUsesUv2?: boolean
+  /** Clearcoat normal map scale `[x, y]`. Defaults to `[1, 1]`. */
+  clearcoatNormalScale?: Array<number>
+  /** Sheen color/intensity `[r, g, b]` in 0..1 range. */
+  sheenColor?: Array<number>
+  /** Optional sheen color map. RGB channels multiply `sheenColor`. */
+  sheenColorMap?: Buffer
+  /** Sheen color map width (required when map is raw RGBA8 bytes). */
+  sheenColorMapWidth?: number
+  /** Sheen color map height (required when map is raw RGBA8 bytes). */
+  sheenColorMapHeight?: number
+  /** Sheen color map horizontal wrap mode. */
+  sheenColorMapWrapS?: string
+  /** Sheen color map vertical wrap mode. */
+  sheenColorMapWrapT?: string
+  /** Sheen color map magnification filter. */
+  sheenColorMapMagFilter?: string
+  /** Sheen color map minification filter. */
+  sheenColorMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  sheenColorMapAnisotropy?: number
+  /** Sheen color map UV transform `[a, c, tx, b, d, ty]`. */
+  sheenColorMapTransform?: Array<number>
+  /** Sheen color texture color space. `"srgb"` is decoded to linear before shading. */
+  sheenColorMapColorSpace?: string
+  /** Whether sheen color map sampling uses the secondary UV stream. */
+  sheenColorMapUsesUv2?: boolean
+  /** Sheen roughness (0..1). Defaults to 1 when sheen is present. */
+  sheenRoughness?: number
+  /** Optional sheen roughness map. Alpha channel multiplies `sheenRoughness`. */
+  sheenRoughnessMap?: Buffer
+  /** Sheen roughness map width (required when map is raw RGBA8 bytes). */
+  sheenRoughnessMapWidth?: number
+  /** Sheen roughness map height (required when map is raw RGBA8 bytes). */
+  sheenRoughnessMapHeight?: number
+  /** Sheen roughness map horizontal wrap mode. */
+  sheenRoughnessMapWrapS?: string
+  /** Sheen roughness map vertical wrap mode. */
+  sheenRoughnessMapWrapT?: string
+  /** Sheen roughness map magnification filter. */
+  sheenRoughnessMapMagFilter?: string
+  /** Sheen roughness map minification filter. */
+  sheenRoughnessMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  sheenRoughnessMapAnisotropy?: number
+  /** Sheen roughness map UV transform `[a, c, tx, b, d, ty]`. */
+  sheenRoughnessMapTransform?: Array<number>
+  /** Sheen roughness map color space metadata. Alpha roughness sampling is unchanged. */
+  sheenRoughnessMapColorSpace?: string
+  /** Whether sheen roughness map sampling uses the secondary UV stream. */
+  sheenRoughnessMapUsesUv2?: boolean
+  /** Anisotropy strength (0..1). Defaults to 0. */
+  anisotropy?: number
+  /** Anisotropy rotation in tangent space, radians. */
+  anisotropyRotation?: number
+  /** Optional anisotropy map. RG encode direction and B encodes strength. */
+  anisotropyMap?: Buffer
+  /** Anisotropy map width (required when map is raw RGBA8 bytes). */
+  anisotropyMapWidth?: number
+  /** Anisotropy map height (required when map is raw RGBA8 bytes). */
+  anisotropyMapHeight?: number
+  /** Anisotropy map horizontal wrap mode. */
+  anisotropyMapWrapS?: string
+  /** Anisotropy map vertical wrap mode. */
+  anisotropyMapWrapT?: string
+  /** Anisotropy map magnification filter. */
+  anisotropyMapMagFilter?: string
+  /** Anisotropy map minification filter. */
+  anisotropyMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  anisotropyMapAnisotropy?: number
+  /** Anisotropy map UV transform `[a, c, tx, b, d, ty]`. */
+  anisotropyMapTransform?: Array<number>
+  /** Anisotropy map color space. `"srgb"` is decoded to linear before shading. */
+  anisotropyMapColorSpace?: string
+  /** Whether anisotropy map sampling uses the secondary UV stream. */
+  anisotropyMapUsesUv2?: boolean
+  /** MeshPhysicalMaterial iridescence factor (0..1). Defaults to 0. */
+  iridescence?: number
+  /** Optional iridescence factor map. Red channel multiplies `iridescence`. */
+  iridescenceMap?: Buffer
+  /** Iridescence factor map width (required when map is raw RGBA8 bytes). */
+  iridescenceMapWidth?: number
+  /** Iridescence factor map height (required when map is raw RGBA8 bytes). */
+  iridescenceMapHeight?: number
+  /** Iridescence factor map horizontal wrap mode. */
+  iridescenceMapWrapS?: string
+  /** Iridescence factor map vertical wrap mode. */
+  iridescenceMapWrapT?: string
+  /** Iridescence factor map magnification filter. */
+  iridescenceMapMagFilter?: string
+  /** Iridescence factor map minification filter. */
+  iridescenceMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  iridescenceMapAnisotropy?: number
+  /** Iridescence factor map UV transform `[a, c, tx, b, d, ty]`. */
+  iridescenceMapTransform?: Array<number>
+  /** Iridescence factor map color space. `"srgb"` is decoded to linear before shading. */
+  iridescenceMapColorSpace?: string
+  /** Whether iridescence factor map sampling uses the secondary UV stream. */
+  iridescenceMapUsesUv2?: boolean
+  /** Iridescence film IOR. Defaults to 1.3. */
+  iridescenceIor?: number
+  /** Iridescence film thickness range minimum in nanometers. Defaults to 100. */
+  iridescenceThicknessMin?: number
+  /** Iridescence film thickness range maximum in nanometers. Defaults to 400. */
+  iridescenceThicknessMax?: number
+  /** Optional iridescence thickness map. Green channel interpolates the configured thickness range. */
+  iridescenceThicknessMap?: Buffer
+  /** Iridescence thickness map width (required when map is raw RGBA8 bytes). */
+  iridescenceThicknessMapWidth?: number
+  /** Iridescence thickness map height (required when map is raw RGBA8 bytes). */
+  iridescenceThicknessMapHeight?: number
+  /** Iridescence thickness map horizontal wrap mode. */
+  iridescenceThicknessMapWrapS?: string
+  /** Iridescence thickness map vertical wrap mode. */
+  iridescenceThicknessMapWrapT?: string
+  /** Iridescence thickness map magnification filter. */
+  iridescenceThicknessMapMagFilter?: string
+  /** Iridescence thickness map minification filter. */
+  iridescenceThicknessMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  iridescenceThicknessMapAnisotropy?: number
+  /** Iridescence thickness map UV transform `[a, c, tx, b, d, ty]`. */
+  iridescenceThicknessMapTransform?: Array<number>
+  /** Iridescence thickness map color space. `"srgb"` is decoded to linear before shading. */
+  iridescenceThicknessMapColorSpace?: string
+  /** Whether iridescence thickness map sampling uses the secondary UV stream. */
+  iridescenceThicknessMapUsesUv2?: boolean
+  /** Physical transmission factor (0..1). Defaults to 0. */
+  transmission?: number
+  /** Optional transmission map. Red channel multiplies `transmission`. */
+  transmissionMap?: Buffer
+  /** Transmission map width (required when map is raw RGBA8 bytes). */
+  transmissionMapWidth?: number
+  /** Transmission map height (required when map is raw RGBA8 bytes). */
+  transmissionMapHeight?: number
+  /** Transmission map horizontal wrap mode. */
+  transmissionMapWrapS?: string
+  /** Transmission map vertical wrap mode. */
+  transmissionMapWrapT?: string
+  /** Transmission map magnification filter. */
+  transmissionMapMagFilter?: string
+  /** Transmission map minification filter. */
+  transmissionMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  transmissionMapAnisotropy?: number
+  /** Transmission map UV transform `[a, c, tx, b, d, ty]`. */
+  transmissionMapTransform?: Array<number>
+  /** Transmission map color space. `"srgb"` is decoded to linear before shading. */
+  transmissionMapColorSpace?: string
+  /** Whether transmission map sampling uses the secondary UV stream. */
+  transmissionMapUsesUv2?: boolean
+  /** MeshPhysicalMaterial dispersion factor. Defaults to 0. */
+  dispersion?: number
+  /** Index of refraction for physical materials. Defaults to 1.5. */
+  ior?: number
+  /** Transmission volume thickness in model units. Defaults to 0. */
+  thickness?: number
+  /** Optional thickness map. Green channel multiplies `thickness`. */
+  thicknessMap?: Buffer
+  /** Thickness map width (required when map is raw RGBA8 bytes). */
+  thicknessMapWidth?: number
+  /** Thickness map height (required when map is raw RGBA8 bytes). */
+  thicknessMapHeight?: number
+  /** Thickness map horizontal wrap mode. */
+  thicknessMapWrapS?: string
+  /** Thickness map vertical wrap mode. */
+  thicknessMapWrapT?: string
+  /** Thickness map magnification filter. */
+  thicknessMapMagFilter?: string
+  /** Thickness map minification filter. */
+  thicknessMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  thicknessMapAnisotropy?: number
+  /** Thickness map UV transform `[a, c, tx, b, d, ty]`. */
+  thicknessMapTransform?: Array<number>
+  /** Thickness map color space. `"srgb"` is decoded to linear before shading. */
+  thicknessMapColorSpace?: string
+  /** Whether thickness map sampling uses the secondary UV stream. */
+  thicknessMapUsesUv2?: boolean
+  /** Transmission attenuation distance. Defaults to a very large distance. */
+  attenuationDistance?: number
+  /** Transmission attenuation color `[r, g, b]` in 0..1 range. */
+  attenuationColor?: Array<number>
+  /** MeshPhysicalMaterial specular color factor `[r, g, b]` in 0..1 range. */
+  physicalSpecularColor?: Array<number>
+  /** MeshPhysicalMaterial specular intensity factor (0..1). Defaults to 1. */
+  physicalSpecularIntensity?: number
+  /** Optional MeshPhysicalMaterial specular color map. RGB channels multiply `specularColor`. */
+  specularColorMap?: Buffer
+  /** Specular color map width (required when map is raw RGBA8 bytes). */
+  specularColorMapWidth?: number
+  /** Specular color map height (required when map is raw RGBA8 bytes). */
+  specularColorMapHeight?: number
+  /** Specular color map horizontal wrap mode. */
+  specularColorMapWrapS?: string
+  /** Specular color map vertical wrap mode. */
+  specularColorMapWrapT?: string
+  /** Specular color map magnification filter. */
+  specularColorMapMagFilter?: string
+  /** Specular color map minification filter. */
+  specularColorMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  specularColorMapAnisotropy?: number
+  /** Specular color map UV transform `[a, c, tx, b, d, ty]`. */
+  specularColorMapTransform?: Array<number>
+  /** Specular color texture color space. `"srgb"` is decoded to linear before shading. */
+  specularColorMapColorSpace?: string
+  /** Whether specular color map sampling uses the secondary UV stream. */
+  specularColorMapUsesUv2?: boolean
+  /** Optional MeshPhysicalMaterial specular intensity map. Alpha channel multiplies `specularIntensity`. */
+  specularIntensityMap?: Buffer
+  /** Specular intensity map width (required when map is raw RGBA8 bytes). */
+  specularIntensityMapWidth?: number
+  /** Specular intensity map height (required when map is raw RGBA8 bytes). */
+  specularIntensityMapHeight?: number
+  /** Specular intensity map horizontal wrap mode. */
+  specularIntensityMapWrapS?: string
+  /** Specular intensity map vertical wrap mode. */
+  specularIntensityMapWrapT?: string
+  /** Specular intensity map magnification filter. */
+  specularIntensityMapMagFilter?: string
+  /** Specular intensity map minification filter. */
+  specularIntensityMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  specularIntensityMapAnisotropy?: number
+  /** Specular intensity map UV transform `[a, c, tx, b, d, ty]`. */
+  specularIntensityMapTransform?: Array<number>
+  /** Specular intensity map color space metadata. Alpha intensity sampling is unchanged. */
+  specularIntensityMapColorSpace?: string
+  /** Whether specular intensity map sampling uses the secondary UV stream. */
+  specularIntensityMapUsesUv2?: boolean
+  /** MeshPhongMaterial specular color `[r, g, b]` in 0..1 range. */
+  specularColor?: Array<number>
+  /** MeshPhongMaterial shininess. Defaults to 30. */
+  shininess?: number
   /** Emissive color `[r, g, b]` in 0..1 range. */
   emissive?: Array<number>
   /** Emissive intensity multiplier. Defaults to 1. */
@@ -139,14 +609,149 @@ export interface SceneMesh {
   normalMapWidth?: number
   /** Normal map height in pixels (required when `normal_map` is raw RGBA8 bytes). */
   normalMapHeight?: number
+  /** Normal map horizontal wrap mode. */
+  normalMapWrapS?: string
+  /** Normal map vertical wrap mode. */
+  normalMapWrapT?: string
+  /** Normal map magnification filter. */
+  normalMapMagFilter?: string
+  /** Normal map minification filter. */
+  normalMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  normalMapAnisotropy?: number
+  /** Normal map UV transform `[a, c, tx, b, d, ty]`. */
+  normalMapTransform?: Array<number>
+  /** Normal map color space. `"srgb"` decodes RGB channels before normal sampling. */
+  normalMapColorSpace?: string
+  /** Whether normal map sampling uses the secondary UV stream. */
+  normalMapUsesUv2?: boolean
+  /** Normal map space: "tangent" (default) or "object". */
+  normalMapType?: string
   /** Normal map scale `[x, y]`. Defaults to `[1, 1]`. */
   normalScale?: Array<number>
+  /** Optional bump map image data. Red channel is used as height. */
+  bumpMap?: Buffer
+  /** Bump map width (required when `bump_map` is raw RGBA8 bytes). */
+  bumpMapWidth?: number
+  /** Bump map height (required when `bump_map` is raw RGBA8 bytes). */
+  bumpMapHeight?: number
+  /** Bump map horizontal wrap mode. */
+  bumpMapWrapS?: string
+  /** Bump map vertical wrap mode. */
+  bumpMapWrapT?: string
+  /** Bump map magnification filter. */
+  bumpMapMagFilter?: string
+  /** Bump map minification filter. */
+  bumpMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  bumpMapAnisotropy?: number
+  /** Bump map UV transform `[a, c, tx, b, d, ty]`. */
+  bumpMapTransform?: Array<number>
+  /** Bump map color space. `"srgb"` decodes RGB channels before bump sampling. */
+  bumpMapColorSpace?: string
+  /** Whether bump map sampling uses the secondary UV stream. */
+  bumpMapUsesUv2?: boolean
+  /** Bump map scale. Defaults to 1. */
+  bumpScale?: number
+  /** Optional MeshMatcapMaterial color map image data. */
+  matcapMap?: Buffer
+  /** Matcap color map width (required when `matcap_map` is raw RGBA8 bytes). */
+  matcapMapWidth?: number
+  /** Matcap color map height (required when `matcap_map` is raw RGBA8 bytes). */
+  matcapMapHeight?: number
+  /** Matcap color map horizontal wrap mode. */
+  matcapMapWrapS?: string
+  /** Matcap color map vertical wrap mode. */
+  matcapMapWrapT?: string
+  /** Matcap color map magnification filter. */
+  matcapMapMagFilter?: string
+  /** Matcap color map minification filter. */
+  matcapMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  matcapMapAnisotropy?: number
+  /** Matcap color map UV transform `[a, c, tx, b, d, ty]`. */
+  matcapMapTransform?: Array<number>
+  /** Matcap color map color space: `"srgb"` or `"linear"`. */
+  matcapMapColorSpace?: string
+  /** Whether matcap color map sampling uses the secondary UV stream. */
+  matcapMapUsesUv2?: boolean
+  /** MeshDepthMaterial packing mode. Uses Three.js constants: 3200 basic, 3201 RGBA, 3202 RGB, 3203 RG. */
+  depthPacking?: number
+  /** Optional MeshDistanceMaterial world-space reference position. Defaults to camera position. */
+  distanceReferencePosition?: Array<number>
+  /** Optional MeshDistanceMaterial near distance. Defaults to camera near plane. */
+  distanceNear?: number
+  /** Optional MeshDistanceMaterial far distance. Defaults to camera far plane. */
+  distanceFar?: number
+  /** Optional MeshToonMaterial gradient ramp map. Red channel controls diffuse ramp strength. */
+  gradientMap?: Buffer
+  /** Gradient map width (required when `gradient_map` is raw RGBA8 bytes). */
+  gradientMapWidth?: number
+  /** Gradient map height (required when `gradient_map` is raw RGBA8 bytes). */
+  gradientMapHeight?: number
+  /** Gradient map horizontal wrap mode. */
+  gradientMapWrapS?: string
+  /** Gradient map vertical wrap mode. */
+  gradientMapWrapT?: string
+  /** Gradient map magnification filter. */
+  gradientMapMagFilter?: string
+  /** Gradient map minification filter. */
+  gradientMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  gradientMapAnisotropy?: number
+  /** Gradient map color space: `"srgb"` or `"linear"`. */
+  gradientMapColorSpace?: string
+  /**
+   * Optional displacement map image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP).
+   * Red channel displaces vertices along their object-space normals.
+   */
+  displacementMap?: Buffer
+  /** Displacement map width in pixels (required when `displacement_map` is raw RGBA8 bytes). */
+  displacementMapWidth?: number
+  /** Displacement map height in pixels (required when `displacement_map` is raw RGBA8 bytes). */
+  displacementMapHeight?: number
+  /** Displacement map horizontal wrap mode. */
+  displacementMapWrapS?: string
+  /** Displacement map vertical wrap mode. */
+  displacementMapWrapT?: string
+  /** Displacement map magnification filter. */
+  displacementMapMagFilter?: string
+  /** Displacement map minification filter. */
+  displacementMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  displacementMapAnisotropy?: number
+  /** Displacement map UV transform `[a, c, tx, b, d, ty]`. */
+  displacementMapTransform?: Array<number>
+  /** Displacement map color space. `"srgb"` decodes the red channel before displacement. */
+  displacementMapColorSpace?: string
+  /** Whether displacement map sampling uses the secondary UV stream. */
+  displacementMapUsesUv2?: boolean
+  /** Displacement scale multiplier. Defaults to 1. */
+  displacementScale?: number
+  /** Displacement bias added after map sampling. Defaults to 0. */
+  displacementBias?: number
   /** Optional emissive map image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP). */
   emissiveMap?: Buffer
   /** Emissive map width in pixels (required when `emissive_map` is raw RGBA8 bytes). */
   emissiveMapWidth?: number
   /** Emissive map height in pixels (required when `emissive_map` is raw RGBA8 bytes). */
   emissiveMapHeight?: number
+  /** Emissive map horizontal wrap mode. */
+  emissiveMapWrapS?: string
+  /** Emissive map vertical wrap mode. */
+  emissiveMapWrapT?: string
+  /** Emissive map magnification filter. */
+  emissiveMapMagFilter?: string
+  /** Emissive map minification filter. */
+  emissiveMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  emissiveMapAnisotropy?: number
+  /** Emissive map UV transform `[a, c, tx, b, d, ty]`. */
+  emissiveMapTransform?: Array<number>
+  /** Emissive texture color space. `"srgb"` is decoded to linear before shading. */
+  emissiveMapColorSpace?: string
+  /** Whether emissive map sampling uses the secondary UV stream. */
+  emissiveMapUsesUv2?: boolean
   /**
    * Optional ambient occlusion map image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP).
    * Red channel is used as the occlusion factor (Three.js / glTF convention).
@@ -156,23 +761,182 @@ export interface SceneMesh {
   aoMapWidth?: number
   /** AO map height in pixels (required when `ao_map` is raw RGBA8 bytes). */
   aoMapHeight?: number
+  /** AO map horizontal wrap mode. */
+  aoMapWrapS?: string
+  /** AO map vertical wrap mode. */
+  aoMapWrapT?: string
+  /** AO map magnification filter. */
+  aoMapMagFilter?: string
+  /** AO map minification filter. */
+  aoMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  aoMapAnisotropy?: number
+  /** AO map UV transform `[a, c, tx, b, d, ty]`. */
+  aoMapTransform?: Array<number>
+  /** AO map color space. `"srgb"` decodes the red channel to linear before shading. */
+  aoMapColorSpace?: string
+  /** Whether AO map sampling uses the secondary UV stream. */
+  aoMapUsesUv2?: boolean
   /** AO map intensity multiplier (0..1). Defaults to 1. */
   aoMapIntensity?: number
+  /**
+   * Optional light map image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP).
+   * RGB channels add baked indirect diffuse lighting.
+   */
+  lightMap?: Buffer
+  /** Light map width in pixels (required when `light_map` is raw RGBA8 bytes). */
+  lightMapWidth?: number
+  /** Light map height in pixels (required when `light_map` is raw RGBA8 bytes). */
+  lightMapHeight?: number
+  /** Light map horizontal wrap mode. */
+  lightMapWrapS?: string
+  /** Light map vertical wrap mode. */
+  lightMapWrapT?: string
+  /** Light map magnification filter. */
+  lightMapMagFilter?: string
+  /** Light map minification filter. */
+  lightMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  lightMapAnisotropy?: number
+  /** Light map UV transform `[a, c, tx, b, d, ty]`. */
+  lightMapTransform?: Array<number>
+  /** Light-map texture color space. `"srgb"` is decoded to linear before shading. */
+  lightMapColorSpace?: string
+  /** Whether light-map sampling uses the secondary UV stream. */
+  lightMapUsesUv2?: boolean
+  /** Light map intensity multiplier. Defaults to 1. */
+  lightMapIntensity?: number
+  /**
+   * Optional alpha map image data (raw RGBA8 bytes or encoded PNG/JPEG/WebP).
+   * Green channel multiplies material opacity, matching Three.js.
+   */
+  alphaMap?: Buffer
+  /** Alpha map width in pixels (required when `alpha_map` is raw RGBA8 bytes). */
+  alphaMapWidth?: number
+  /** Alpha map height in pixels (required when `alpha_map` is raw RGBA8 bytes). */
+  alphaMapHeight?: number
+  /** Alpha map horizontal wrap mode. */
+  alphaMapWrapS?: string
+  /** Alpha map vertical wrap mode. */
+  alphaMapWrapT?: string
+  /** Alpha map magnification filter. */
+  alphaMapMagFilter?: string
+  /** Alpha map minification filter. */
+  alphaMapMinFilter?: string
+  /** Texture anisotropy clamp requested for this sampler. Defaults to 1. */
+  alphaMapAnisotropy?: number
+  /** Alpha map UV transform `[a, c, tx, b, d, ty]`. */
+  alphaMapTransform?: Array<number>
+  /** Alpha map color space. `"srgb"` decodes the green channel to linear before opacity. */
+  alphaMapColorSpace?: string
+  /** Whether alpha map sampling uses the secondary UV stream. */
+  alphaMapUsesUv2?: boolean
   /** Alpha test cutoff threshold (0..1). Fragments with alpha below this are discarded. */
   alphaTest?: number
+  /** Whether to apply stochastic alpha hashing before depth/color writes. */
+  alphaHash?: boolean
+  /** Whether to enable MSAA alpha-to-coverage when the render sample count is greater than 1. */
+  alphaToCoverage?: boolean
+  /** Whether fragment RGB output is multiplied by output alpha before blending. */
+  premultipliedAlpha?: boolean
+  /** Whether material output is tone mapped before output color-space conversion. Defaults to true. */
+  toneMapped?: boolean
+  /**
+   * Flattened world-space clipping planes `[nx, ny, nz, constant, ...]`, up to 8 planes.
+   * Fragments with `dot(normal, worldPosition) + constant < 0` are clipped.
+   */
+  clippingPlanes?: Array<number>
+  /**
+   * Number of leading clipping planes evaluated as union planes. Remaining planes use
+   * intersection semantics. Defaults to all planes as union planes.
+   */
+  clippingUnionCount?: number
+  /** Whether clipping planes affect this mesh in the shadow pass. */
+  clipShadows?: boolean
   /** Whether the mesh is transparent (sorted back-to-front, no depth write). */
   transparent?: boolean
+  /** Material blending mode: `"none"`, `"normal"`, `"additive"`, `"subtractive"`, `"multiply"`, or `"custom"`. */
+  blending?: string
+  /** Custom blending equation constants when `blending` is `"custom"`. */
+  blendEquation?: number
+  blendSrc?: number
+  blendDst?: number
+  blendEquationAlpha?: number
+  blendSrcAlpha?: number
+  blendDstAlpha?: number
+  /** Custom blend constant color `[r, g, b]`. */
+  blendColor?: Array<number>
+  /** Custom blend constant alpha. */
+  blendAlpha?: number
+  /** Whether depth testing is enabled. Defaults to true. */
+  depthTest?: boolean
+  /** Depth comparison function. Defaults to `"less-equal"`. */
+  depthFunc?: string
+  /** Whether passing fragments write depth. Defaults to true for opaque meshes and false for transparent meshes. */
+  depthWrite?: boolean
+  /** Whether fragments write color. Defaults to true. */
+  colorWrite?: boolean
+  /** Whether to apply material polygon offset as depth bias in the main pass. */
+  polygonOffset?: boolean
+  /** Slope-scaled polygon offset factor. */
+  polygonOffsetFactor?: number
+  /** Constant polygon offset units. */
+  polygonOffsetUnits?: number
+  /** Whether stencil testing/writes are enabled for this material. */
+  stencilWrite?: boolean
+  /** Stencil write bit mask. Defaults to 0xff. */
+  stencilWriteMask?: number
+  /** Stencil comparison function constant. Defaults to AlwaysStencilFunc. */
+  stencilFunc?: number
+  /** Stencil reference value. Defaults to 0. */
+  stencilRef?: number
+  /** Stencil comparison bit mask. Defaults to 0xff. */
+  stencilFuncMask?: number
+  /** Operation when the stencil test fails. Defaults to KeepStencilOp. */
+  stencilFail?: number
+  /** Operation when the stencil test passes but depth fails. Defaults to KeepStencilOp. */
+  stencilZFail?: number
+  /** Operation when both stencil and depth pass. Defaults to KeepStencilOp. */
+  stencilZPass?: number
   /** Which faces to render: `"front"` (default), `"back"`, or `"double"`. */
   side?: string
+  /** Optional shadow-pass face filter: `"front"`, `"back"`, or `"double"`. Unset preserves no-cull shadow casters. */
+  shadowSide?: string
   /**
    * Shading model: `"standard"` (default PBR), `"basic"` (unlit / MeshBasicMaterial),
    * or `"lambert"` (diffuse-only / MeshLambertMaterial).
    */
   shadingModel?: string
+  /** Whether this mesh samples the scene/material environment map when one exists. */
+  useEnvironmentMap?: boolean
+  /** Per-mesh environment intensity. Defaults to the scene environment intensity. */
+  environmentMapIntensity?: number
+  /** Legacy environment blend operation: 0=multiply, 1=mix, 2=add. */
+  environmentMapCombine?: number
+  /** Legacy material environment reflectivity multiplier. */
+  environmentMapReflectivity?: number
+  /** Whether the material environment map uses refraction instead of reflection. */
+  environmentMapRefraction?: boolean
+  /** Legacy material environment refraction ratio. */
+  environmentMapRefractionRatio?: number
   /** Primitive topology: `"triangles"` (default), `"lines"` (LineList), or `"points"`. */
   topology?: string
+  /** WGSL fragment shader body for 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
+  /** Three.js groupOrder inherited from the nearest Group.renderOrder. Defaults to 0. */
+  groupOrder?: number
+  /** Explicit Three.js object renderOrder. Defaults to 0. */
+  renderOrder?: number
+  /** Projected camera-space sort key provided by the Three.js adapter. */
+  sortZ?: number
+  /** Stable object id / adapter insertion-order tie-breaker. */
+  sortIndex?: number
+  /** WebGLRenderer material variant sort key: skinned meshes add 1, instanced meshes add 2. */
+  materialVariant?: number
+  /** Material id sort key used for opaque draw ordering. */
+  materialSortKey?: number
 }