@forgeax/engine-gltf 0.1.23 → 0.1.25

package/src/errors.ts

@@ -73,6 +73,18 @@ export interface GltfMaterialTransmissionInvalidDetail {
   readonly actual?: unknown;
 }
 
+export interface GltfMaterialPhysicalInvalidDetail {
+  readonly extension:
+    | 'KHR_materials_clearcoat'
+    | 'KHR_materials_anisotropy'
+    | 'KHR_materials_sheen'
+    | 'KHR_materials_iridescence'
+    | 'KHR_materials_specular';
+  readonly field: string;
+  readonly reason: 'type' | 'range' | 'non-finite';
+  readonly actual?: unknown;
+}
+
 /** `gltf-accessor-type-mismatch` payload: 4-member closed reason discriminator. */
 export interface GltfAccessorTypeMismatchDetail {
   readonly accessorIndex: number;
@@ -266,8 +278,9 @@ const gltfErrorPolicy = {
     hint: 'rebuild .gltf with valid bufferViews; check accessor index; ensure accessor.byteOffset + EFFECTIVE_STRIDE * (count - 1) + element_size <= bufferView.byteLength',
   },
   'gltf-extension-unsupported': {
-    expected: 'extension listed in v1 allowlist (see EXTENSION_ALLOWLIST in @forgeax/engine-gltf)',
-    hint: 'see feat-future-gltf-extensions-allowlist; remove this extension or wait for the allowlist to expand',
+    expected:
+      'extension listed in the supported allowlist (see EXTENSION_ALLOWLIST in @forgeax/engine-gltf)',
+    hint: 'remove the unsupported required extension or use a supported glTF extension; extensionsUsed-only entries remain diagnostic',
   },
   'gltf-lod-invalid': {
     expected: 'MSFT_lod ids to reference unique existing node indices with valid coverage',
@@ -277,6 +290,11 @@ const gltfErrorPolicy = {
     expected: 'KHR transmission, IOR, and volume values are finite and within their glTF ranges',
     hint: 'repair the named glTF material extension value and re-import the source',
   },
+  'gltf-material-physical-invalid': {
+    expected:
+      'KHR clearcoat, anisotropy, sheen, iridescence, and specular values are finite and within their glTF ranges',
+    hint: 'repair the named physical material extension value and re-import the source',
+  },
   'gltf-accessor-type-mismatch': {
     expected: 'dense fixed-stride accessor with supported componentType',
     hint: 'sparse: see feat-future-gltf-sparse-accessor; morph: see feat-future-gltf-morph; interleaved: see feat-future-gltf-mesh-multi-section',
@@ -387,6 +405,7 @@ interface DetailFor {
   readonly 'gltf-color-accessor-malformed': GltfColorAccessorMalformedDetail;
   readonly 'gltf-mesh-bridge-invalid': GltfMeshBridgeInvalidDetail;
   readonly 'gltf-material-transmission-invalid': GltfMaterialTransmissionInvalidDetail;
+  readonly 'gltf-material-physical-invalid': GltfMaterialPhysicalInvalidDetail;
 }
 
 /**

package/src/gltf-importer.ts

@@ -59,6 +59,7 @@ import {
   gltfDocToSceneAsset,
   meshIrToMeshAsset,
   toMaterialAsset,
+  validateMaterialTangentInputs,
   validateMaterialUvSets,
 } from './bridge.js';
 import { gltfErr } from './errors.js';
@@ -415,6 +416,16 @@ export function materialRefsForPack(
   pushRefsForSlot(mat.emissiveTexture, 'emissiveTexture');
   pushRefsForSlot(mat.transmissionTexture, 'transmissionTexture');
   pushRefsForSlot(mat.thicknessTexture, 'thicknessTexture');
+  pushRefsForSlot(mat.clearcoatTexture, 'clearcoatTexture');
+  pushRefsForSlot(mat.clearcoatRoughnessTexture, 'clearcoatRoughnessTexture');
+  pushRefsForSlot(mat.clearcoatNormalTexture, 'clearcoatNormalTexture');
+  pushRefsForSlot(mat.anisotropyTexture, 'anisotropyTexture');
+  pushRefsForSlot(mat.sheenColorTexture, 'sheenColorTexture');
+  pushRefsForSlot(mat.sheenRoughnessTexture, 'sheenRoughnessTexture');
+  pushRefsForSlot(mat.iridescenceTexture, 'iridescenceTexture');
+  pushRefsForSlot(mat.iridescenceThicknessTexture, 'iridescenceThicknessTexture');
+  pushRefsForSlot(mat.specularTexture, 'specularTexture');
+  pushRefsForSlot(mat.specularColorTexture, 'specularColorTexture');
   return refs;
 }
 
@@ -444,6 +455,16 @@ function rewriteMaterialAssetRefs(
       | 'emissiveTexture'
       | 'transmissionTexture'
       | 'thicknessTexture'
+      | 'clearcoatTexture'
+      | 'clearcoatRoughnessTexture'
+      | 'clearcoatNormalTexture'
+      | 'anisotropyTexture'
+      | 'sheenColorTexture'
+      | 'sheenRoughnessTexture'
+      | 'iridescenceTexture'
+      | 'iridescenceThicknessTexture'
+      | 'specularTexture'
+      | 'specularColorTexture'
     ),
     GltfTextureInfoIr | number | undefined,
   ][] = [
@@ -454,6 +475,16 @@ function rewriteMaterialAssetRefs(
     ['emissiveTexture', mat.emissiveTexture],
     ['transmissionTexture', mat.transmissionTexture],
     ['thicknessTexture', mat.thicknessTexture],
+    ['clearcoatTexture', mat.clearcoatTexture],
+    ['clearcoatRoughnessTexture', mat.clearcoatRoughnessTexture],
+    ['clearcoatNormalTexture', mat.clearcoatNormalTexture],
+    ['anisotropyTexture', mat.anisotropyTexture],
+    ['sheenColorTexture', mat.sheenColorTexture],
+    ['sheenRoughnessTexture', mat.sheenRoughnessTexture],
+    ['iridescenceTexture', mat.iridescenceTexture],
+    ['iridescenceThicknessTexture', mat.iridescenceThicknessTexture],
+    ['specularTexture', mat.specularTexture],
+    ['specularColorTexture', mat.specularColorTexture],
   ];
   let cursor = 0;
   for (const [slot, rawBinding] of slots) {
@@ -750,6 +781,10 @@ async function importGltf(
         if (!uvResult.ok) {
           throw Object.assign(new Error(uvResult.error.message), uvResult.error);
         }
+        const tangentResult = validateMaterialTangentInputs(mat, meshIr);
+        if (!tangentResult.ok) {
+          throw Object.assign(new Error(tangentResult.error.message), tangentResult.error);
+        }
       }
       const matAsset = toMaterialAsset(mat, {
         textureHandles: maps.textureHandles,

package/src/image-color-space.ts

@@ -3,10 +3,11 @@
 //
 // glTF 2.0 spec section 6.2 ("Material → Texture and Sampler") names which
 // texture slots are colour-encoded vs data-encoded:
-//   - sRGB    : baseColorTexture, emissiveTexture
-//   - linear  : metallicRoughnessTexture, normalTexture, occlusionTexture
-// MaterialIr carries baseColor / metallicRoughness / normal / emissive;
-// occlusion remains outside this Tier-C subset.
+//   - sRGB    : baseColorTexture, emissiveTexture, sheenColorTexture,
+//               specularColorTexture
+//   - linear  : metallicRoughnessTexture, normalTexture, occlusionTexture,
+//               transmission/volume/clearcoat/anisotropy/sheen-roughness/
+//               iridescence/specular-weight data textures
 // We pre-scan the doc so the gltfImporter knows each `images[]` row's
 // colorSpace before decoding (TextureAsset.colorSpace + .format derive
 // from this).
@@ -36,6 +37,18 @@ export interface MaterialColorSpaceInput {
   readonly normalTexture?: TextureBinding;
   readonly emissiveTexture?: TextureBinding;
   readonly occlusionTexture?: TextureBinding;
+  readonly transmissionTexture?: TextureBinding;
+  readonly thicknessTexture?: TextureBinding;
+  readonly clearcoatTexture?: TextureBinding;
+  readonly clearcoatRoughnessTexture?: TextureBinding;
+  readonly clearcoatNormalTexture?: TextureBinding;
+  readonly anisotropyTexture?: TextureBinding;
+  readonly sheenColorTexture?: TextureBinding;
+  readonly sheenRoughnessTexture?: TextureBinding;
+  readonly iridescenceTexture?: TextureBinding;
+  readonly iridescenceThicknessTexture?: TextureBinding;
+  readonly specularTexture?: TextureBinding;
+  readonly specularColorTexture?: TextureBinding;
 }
 
 /** Slim view of a parsed `textures[]` row. */
@@ -89,9 +102,21 @@ export function deriveTextureColorSpace(
   for (const mat of input.materials) {
     record(imageOfTexture(mat.baseColorTexture), 'srgb');
     record(imageOfTexture(mat.emissiveTexture), 'srgb');
+    record(imageOfTexture(mat.sheenColorTexture), 'srgb');
+    record(imageOfTexture(mat.specularColorTexture), 'srgb');
     record(imageOfTexture(mat.metallicRoughnessTexture), 'linear');
     record(imageOfTexture(mat.normalTexture), 'linear');
     record(imageOfTexture(mat.occlusionTexture), 'linear');
+    record(imageOfTexture(mat.transmissionTexture), 'linear');
+    record(imageOfTexture(mat.thicknessTexture), 'linear');
+    record(imageOfTexture(mat.clearcoatTexture), 'linear');
+    record(imageOfTexture(mat.clearcoatRoughnessTexture), 'linear');
+    record(imageOfTexture(mat.clearcoatNormalTexture), 'linear');
+    record(imageOfTexture(mat.anisotropyTexture), 'linear');
+    record(imageOfTexture(mat.sheenRoughnessTexture), 'linear');
+    record(imageOfTexture(mat.iridescenceTexture), 'linear');
+    record(imageOfTexture(mat.iridescenceThicknessTexture), 'linear');
+    record(imageOfTexture(mat.specularTexture), 'linear');
   }
 
   for (let i = 0; i < input.imageCount; i++) {

package/src/index.ts

@@ -47,7 +47,13 @@ export type { GltfBridgeContext, MaterialBridgeContext } from './bridge.js';
 // hello-gltf + hello-gltf-instancing, feat-20260518 M3 w9; M3 Tier-C material
 // bridge; meshIrToMeshAsset excised from the hello-gltf demo in
 // feat-20260603-asset-import-loader-injection M2 w19).
-export { gltfDocToSceneAsset, meshIrToMeshAsset, toMaterialAsset } from './bridge.js';
+export {
+  gltfDocToSceneAsset,
+  meshIrToMeshAsset,
+  toMaterialAsset,
+  validateMaterialTangentInputs,
+  validateMaterialUvSets,
+} from './bridge.js';
 export type { ExtensionsCheckResult, GltfExtensionsJson } from './check-extensions.js';
 // KHR extensions gate (w14).
 export { checkExtensions, EXTENSION_ALLOWLIST } from './check-extensions.js';
@@ -65,6 +71,7 @@ export type {
   GltfImageMimeUnsupportedDetail,
   GltfInstancingCountMismatchDetail,
   GltfMalformedHeaderDetail,
+  GltfMaterialPhysicalInvalidDetail,
   GltfMaterialTransmissionInvalidDetail,
   GltfMetaMissingDetail,
   GltfMorphInvalidDetail,

package/src/material/parse-material.ts

@@ -93,6 +93,38 @@ export interface GltfMaterialJson {
       readonly attenuationColor?: readonly number[];
       readonly attenuationDistance?: number;
     };
+    readonly KHR_materials_clearcoat?: {
+      readonly clearcoatFactor?: number;
+      readonly clearcoatTexture?: TextureInfoJson;
+      readonly clearcoatRoughnessFactor?: number;
+      readonly clearcoatRoughnessTexture?: TextureInfoJson;
+      readonly clearcoatNormalTexture?: NormalTextureInfoJson;
+    };
+    readonly KHR_materials_anisotropy?: {
+      readonly anisotropyStrength?: number;
+      readonly anisotropyRotation?: number;
+      readonly anisotropyTexture?: TextureInfoJson;
+    };
+    readonly KHR_materials_sheen?: {
+      readonly sheenColorFactor?: readonly number[];
+      readonly sheenColorTexture?: TextureInfoJson;
+      readonly sheenRoughnessFactor?: number;
+      readonly sheenRoughnessTexture?: TextureInfoJson;
+    };
+    readonly KHR_materials_iridescence?: {
+      readonly iridescenceFactor?: number;
+      readonly iridescenceIor?: number;
+      readonly iridescenceThicknessMinimum?: number;
+      readonly iridescenceThicknessMaximum?: number;
+      readonly iridescenceTexture?: TextureInfoJson;
+      readonly iridescenceThicknessTexture?: TextureInfoJson;
+    };
+    readonly KHR_materials_specular?: {
+      readonly specularFactor?: number;
+      readonly specularTexture?: TextureInfoJson;
+      readonly specularColorFactor?: readonly number[];
+      readonly specularColorTexture?: TextureInfoJson;
+    };
   };
 }
 
@@ -119,6 +151,40 @@ export interface GltfMaterialIr {
   readonly thicknessChannel?: number;
   readonly attenuationColor?: readonly [number, number, number];
   readonly attenuationDistance?: number;
+  readonly clearcoatFactor?: number;
+  readonly clearcoatChannel?: number;
+  readonly clearcoatTexture?: GltfTextureInfoIr | number;
+  readonly clearcoatRoughnessFactor?: number;
+  readonly clearcoatRoughnessChannel?: number;
+  readonly clearcoatRoughnessTexture?: GltfTextureInfoIr | number;
+  readonly clearcoatNormalTexture?: GltfNormalTextureInfoIr | number;
+  readonly clearcoatNormalChannel?: readonly [number, number];
+  readonly anisotropyStrength?: number;
+  readonly anisotropyRotation?: number;
+  readonly anisotropyTexture?: GltfTextureInfoIr | number;
+  /** KHR_materials_anisotropy uses RG direction and B strength. */
+  readonly anisotropyChannel?: readonly [number, number, number];
+  readonly sheenColorFactor?: readonly [number, number, number];
+  readonly sheenColorTexture?: GltfTextureInfoIr | number;
+  readonly sheenColorChannel?: readonly [number, number, number];
+  readonly sheenRoughnessFactor?: number;
+  readonly sheenRoughnessTexture?: GltfTextureInfoIr | number;
+  readonly sheenRoughnessChannel?: number;
+  readonly iridescenceFactor?: number;
+  readonly iridescenceIor?: number;
+  readonly iridescenceThicknessMinimum?: number;
+  readonly iridescenceThicknessMaximum?: number;
+  readonly iridescenceTexture?: GltfTextureInfoIr | number;
+  readonly iridescenceChannel?: number;
+  readonly iridescenceThicknessTexture?: GltfTextureInfoIr | number;
+  readonly iridescenceThicknessChannel?: number;
+  readonly specularFactor?: number;
+  readonly specularTexture?: GltfTextureInfoIr | number;
+  /** KHR_materials_specular specularTexture uses the alpha channel. */
+  readonly specularChannel?: number;
+  readonly specularColorFactor?: readonly [number, number, number];
+  readonly specularColorTexture?: GltfTextureInfoIr | number;
+  readonly specularColorChannel?: readonly [number, number, number];
   readonly alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
   readonly alphaCutoff?: number;
   readonly doubleSided?: boolean;
@@ -186,6 +252,11 @@ export function parseMaterial(
   const transmission = matJson.extensions?.KHR_materials_transmission;
   const ior = matJson.extensions?.KHR_materials_ior;
   const volume = matJson.extensions?.KHR_materials_volume;
+  const clearcoat = matJson.extensions?.KHR_materials_clearcoat;
+  const anisotropy = matJson.extensions?.KHR_materials_anisotropy;
+  const sheen = matJson.extensions?.KHR_materials_sheen;
+  const iridescence = matJson.extensions?.KHR_materials_iridescence;
+  const specular = matJson.extensions?.KHR_materials_specular;
   const attenuationColor = tuple3(volume?.attenuationColor);
   const invalid = (
     extension: 'KHR_materials_transmission' | 'KHR_materials_ior' | 'KHR_materials_volume',
@@ -201,6 +272,25 @@ export function parseMaterial(
         ...(actual === undefined ? {} : { actual }),
       }),
     );
+  const physicalInvalid = (
+    extension:
+      | 'KHR_materials_clearcoat'
+      | 'KHR_materials_anisotropy'
+      | 'KHR_materials_sheen'
+      | 'KHR_materials_iridescence'
+      | 'KHR_materials_specular',
+    field: string,
+    reason: 'type' | 'range' | 'non-finite',
+    actual?: unknown,
+  ): Result<GltfMaterialIr, GltfError> =>
+    err(
+      gltfErr('gltf-material-physical-invalid', {
+        extension,
+        field,
+        reason,
+        ...(actual === undefined ? {} : { actual }),
+      }),
+    );
   if (
     transmission?.transmissionFactor !== undefined &&
     (typeof transmission.transmissionFactor !== 'number' ||
@@ -270,6 +360,132 @@ export function parseMaterial(
   if (alphaMode === 'BLEND' && (transmission?.transmissionFactor ?? 0) > 0) {
     return invalid('KHR_materials_transmission', 'alphaMode', 'blend', alphaMode);
   }
+  if (
+    clearcoat?.clearcoatFactor !== undefined &&
+    (typeof clearcoat.clearcoatFactor !== 'number' || !Number.isFinite(clearcoat.clearcoatFactor))
+  ) {
+    return physicalInvalid(
+      'KHR_materials_clearcoat',
+      'clearcoatFactor',
+      'non-finite',
+      clearcoat.clearcoatFactor,
+    );
+  }
+  if (
+    clearcoat?.clearcoatFactor !== undefined &&
+    (clearcoat.clearcoatFactor < 0 || clearcoat.clearcoatFactor > 1)
+  ) {
+    return physicalInvalid(
+      'KHR_materials_clearcoat',
+      'clearcoatFactor',
+      'range',
+      clearcoat.clearcoatFactor,
+    );
+  }
+  if (
+    clearcoat?.clearcoatRoughnessFactor !== undefined &&
+    (typeof clearcoat.clearcoatRoughnessFactor !== 'number' ||
+      !Number.isFinite(clearcoat.clearcoatRoughnessFactor))
+  ) {
+    return physicalInvalid(
+      'KHR_materials_clearcoat',
+      'clearcoatRoughnessFactor',
+      'non-finite',
+      clearcoat.clearcoatRoughnessFactor,
+    );
+  }
+  if (
+    clearcoat?.clearcoatRoughnessFactor !== undefined &&
+    (clearcoat.clearcoatRoughnessFactor < 0 || clearcoat.clearcoatRoughnessFactor > 1)
+  ) {
+    return physicalInvalid(
+      'KHR_materials_clearcoat',
+      'clearcoatRoughnessFactor',
+      'range',
+      clearcoat.clearcoatRoughnessFactor,
+    );
+  }
+  if (
+    clearcoat?.clearcoatNormalTexture?.scale !== undefined &&
+    (typeof clearcoat.clearcoatNormalTexture.scale !== 'number' ||
+      !Number.isFinite(clearcoat.clearcoatNormalTexture.scale) ||
+      clearcoat.clearcoatNormalTexture.scale < 0)
+  ) {
+    return physicalInvalid(
+      'KHR_materials_clearcoat',
+      'clearcoatNormalTexture.scale',
+      'range',
+      clearcoat.clearcoatNormalTexture.scale,
+    );
+  }
+  const validateUnit = (
+    extension: Parameters<typeof physicalInvalid>[0],
+    field: string,
+    value: number | undefined,
+  ) => {
+    if (value === undefined) return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value))
+      return physicalInvalid(extension, field, 'non-finite', value);
+    if (value < 0 || value > 1) return physicalInvalid(extension, field, 'range', value);
+    return undefined;
+  };
+  const validateFinite = (
+    extension: Parameters<typeof physicalInvalid>[0],
+    field: string,
+    value: number | undefined,
+    minimum?: number,
+  ) => {
+    if (value === undefined) return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value))
+      return physicalInvalid(extension, field, 'non-finite', value);
+    if (minimum !== undefined && value < minimum)
+      return physicalInvalid(extension, field, 'range', value);
+    return undefined;
+  };
+  const validateColor = (
+    extension: Parameters<typeof physicalInvalid>[0],
+    field: string,
+    value: readonly number[] | undefined,
+  ) => {
+    if (value === undefined) return undefined;
+    if (
+      value.length < 3 ||
+      value.slice(0, 3).some((channel) => typeof channel !== 'number' || !Number.isFinite(channel))
+    ) {
+      return physicalInvalid(extension, field, 'type', value);
+    }
+    if (value.slice(0, 3).some((channel) => channel < 0 || channel > 1)) {
+      return physicalInvalid(extension, field, 'range', value);
+    }
+    return undefined;
+  };
+  const physicalChecks = [
+    validateUnit('KHR_materials_anisotropy', 'anisotropyStrength', anisotropy?.anisotropyStrength),
+    validateFinite(
+      'KHR_materials_anisotropy',
+      'anisotropyRotation',
+      anisotropy?.anisotropyRotation,
+    ),
+    validateUnit('KHR_materials_sheen', 'sheenRoughnessFactor', sheen?.sheenRoughnessFactor),
+    validateColor('KHR_materials_sheen', 'sheenColorFactor', sheen?.sheenColorFactor),
+    validateUnit('KHR_materials_iridescence', 'iridescenceFactor', iridescence?.iridescenceFactor),
+    validateFinite('KHR_materials_iridescence', 'iridescenceIor', iridescence?.iridescenceIor, 1),
+    validateFinite(
+      'KHR_materials_iridescence',
+      'iridescenceThicknessMinimum',
+      iridescence?.iridescenceThicknessMinimum,
+      0,
+    ),
+    validateFinite(
+      'KHR_materials_iridescence',
+      'iridescenceThicknessMaximum',
+      iridescence?.iridescenceThicknessMaximum,
+      0,
+    ),
+    validateUnit('KHR_materials_specular', 'specularFactor', specular?.specularFactor),
+    validateColor('KHR_materials_specular', 'specularColorFactor', specular?.specularColorFactor),
+  ];
+  for (const check of physicalChecks) if (check !== undefined) return check;
   return ok({
     ...(matJson.name === undefined ? {} : { name: matJson.name }),
     baseColorFactor: baseColor4,
@@ -330,6 +546,97 @@ export function parseMaterial(
             ? {}
             : { attenuationDistance: volume.attenuationDistance }),
         }),
+    ...(clearcoat === undefined
+      ? {}
+      : {
+          clearcoatFactor: clearcoat.clearcoatFactor ?? 0,
+          clearcoatChannel: 0,
+          clearcoatRoughnessFactor: clearcoat.clearcoatRoughnessFactor ?? 0,
+          clearcoatRoughnessChannel: 1,
+          clearcoatNormalChannel: [0, 1] as const,
+          ...(clearcoat.clearcoatTexture === undefined
+            ? {}
+            : { clearcoatTexture: parseTextureInfo(clearcoat.clearcoatTexture, textures) }),
+          ...(clearcoat.clearcoatRoughnessTexture === undefined
+            ? {}
+            : {
+                clearcoatRoughnessTexture: parseTextureInfo(
+                  clearcoat.clearcoatRoughnessTexture,
+                  textures,
+                ),
+              }),
+          ...(clearcoat.clearcoatNormalTexture === undefined
+            ? {}
+            : {
+                clearcoatNormalTexture: {
+                  ...parseTextureInfo(clearcoat.clearcoatNormalTexture, textures),
+                  ...(clearcoat.clearcoatNormalTexture.scale === undefined
+                    ? {}
+                    : { scale: clearcoat.clearcoatNormalTexture.scale }),
+                },
+              }),
+        }),
+    ...(anisotropy === undefined
+      ? {}
+      : {
+          anisotropyStrength: anisotropy.anisotropyStrength ?? 0,
+          anisotropyRotation: anisotropy.anisotropyRotation ?? 0,
+          anisotropyChannel: [0, 1, 2] as const,
+          ...(anisotropy.anisotropyTexture === undefined
+            ? {}
+            : { anisotropyTexture: parseTextureInfo(anisotropy.anisotropyTexture, textures) }),
+        }),
+    ...(sheen === undefined
+      ? {}
+      : {
+          sheenColorFactor: tuple3(sheen.sheenColorFactor) ?? [0, 0, 0],
+          sheenColorChannel: [0, 1, 2] as const,
+          sheenRoughnessFactor: sheen.sheenRoughnessFactor ?? 0,
+          sheenRoughnessChannel: 3,
+          ...(sheen.sheenColorTexture === undefined
+            ? {}
+            : { sheenColorTexture: parseTextureInfo(sheen.sheenColorTexture, textures) }),
+          ...(sheen.sheenRoughnessTexture === undefined
+            ? {}
+            : { sheenRoughnessTexture: parseTextureInfo(sheen.sheenRoughnessTexture, textures) }),
+        }),
+    ...(iridescence === undefined
+      ? {}
+      : {
+          iridescenceFactor: iridescence.iridescenceFactor ?? 0,
+          iridescenceIor: iridescence.iridescenceIor ?? 1.3,
+          iridescenceThicknessMinimum: iridescence.iridescenceThicknessMinimum ?? 100,
+          iridescenceThicknessMaximum: iridescence.iridescenceThicknessMaximum ?? 400,
+          iridescenceChannel: 0,
+          iridescenceThicknessChannel: 1,
+          ...(iridescence.iridescenceTexture === undefined
+            ? {}
+            : { iridescenceTexture: parseTextureInfo(iridescence.iridescenceTexture, textures) }),
+          ...(iridescence.iridescenceThicknessTexture === undefined
+            ? {}
+            : {
+                iridescenceThicknessTexture: parseTextureInfo(
+                  iridescence.iridescenceThicknessTexture,
+                  textures,
+                ),
+              }),
+        }),
+    ...(specular === undefined
+      ? {}
+      : {
+          specularFactor: specular.specularFactor ?? 1,
+          specularChannel: 3,
+          specularColorFactor: tuple3(specular.specularColorFactor) ?? [1, 1, 1],
+          specularColorChannel: [0, 1, 2] as const,
+          ...(specular.specularTexture === undefined
+            ? {}
+            : { specularTexture: parseTextureInfo(specular.specularTexture, textures) }),
+          ...(specular.specularColorTexture === undefined
+            ? {}
+            : {
+                specularColorTexture: parseTextureInfo(specular.specularColorTexture, textures),
+              }),
+        }),
     ...(alphaMode === undefined ? {} : { alphaMode }),
     ...(alphaCutoff === undefined ? {} : { alphaCutoff }),
     ...(matJson.doubleSided === true ? { doubleSided: true } : {}),