@forgeax/engine-gltf 0.1.21 → 0.1.24

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,
@@ -81,6 +88,8 @@ export { err, GLTF_ERROR_HINTS, gltfErr, ok } from './errors.js';
 // gltfImporter: the build-time `{ key: 'gltf', import }` Importer
 // (feat-20260603-asset-import-loader-injection M2 / w19).
 export { gltfImporter } from './gltf-importer.js';
+export { type GltfLodRelation, parseGltfLodExtension } from './lod/parse-lod.js';
+export { projectGltfLodMeta } from './lod/project-meta.js';
 export type { GlbChunks } from './parse-glb-chunks.js';
 // Header / chunk parsers (w8).
 export { parseGlbChunks, parseGltfHeader } from './parse-glb-chunks.js';

package/src/lod/parse-lod.ts

@@ -0,0 +1,129 @@
+import { err, gltfErr, ok, type Result } from '../errors.js';
+
+export interface GltfLodRelation {
+  readonly rootNode: number;
+  readonly lodNodeIds: readonly number[];
+  readonly screenCoverages: readonly number[];
+  /** All node-level MSFT_lod groups, retained for multi-root scenes. */
+  readonly groups: readonly GltfLodGroup[];
+}
+
+export interface GltfLodGroup {
+  readonly rootNode: number;
+  readonly lodNodeIds: readonly number[];
+  readonly screenCoverages: readonly number[];
+}
+
+interface RawNode {
+  readonly mesh?: unknown;
+  readonly extensions?: { readonly MSFT_lod?: { readonly ids?: unknown } };
+  readonly extras?: { readonly MSFT_screencoverage?: unknown };
+}
+
+interface RawMesh {
+  readonly primitives?: unknown;
+}
+
+interface RawGltf {
+  readonly extensionsRequired?: readonly unknown[];
+  readonly meshes?: readonly RawMesh[];
+  readonly nodes?: readonly RawNode[];
+  readonly extensions?: { readonly MSFT_screencoverage?: { readonly scales?: unknown } };
+}
+
+export function parseGltfLodExtension(
+  json: unknown,
+): Result<GltfLodRelation, ReturnType<typeof gltfErr<'gltf-lod-invalid'>>> {
+  const doc = json as RawGltf;
+  const nodes = doc.nodes ?? [];
+  const rawCoverage = doc.extensions?.MSFT_screencoverage?.scales;
+  const groups: GltfLodGroup[] = [];
+  for (let rootNode = 0; rootNode < nodes.length; rootNode += 1) {
+    if (nodes[rootNode]?.extensions?.MSFT_lod === undefined) continue;
+    const idsRaw = nodes[rootNode]?.extensions?.MSFT_lod?.ids;
+    if (!Array.isArray(idsRaw)) {
+      return err(gltfErr('gltf-lod-invalid', { rootNode, ids: [], reason: 'not-integer' }));
+    }
+    const ids = idsRaw.filter((value): value is number => typeof value === 'number');
+    if (
+      ids.length !== idsRaw.length ||
+      ids.some((id) => !Number.isInteger(id) || id < 0 || id >= nodes.length)
+    ) {
+      return err(gltfErr('gltf-lod-invalid', { rootNode, ids, reason: 'missing-node' }));
+    }
+    if (new Set(ids).size !== ids.length || ids.includes(rootNode)) {
+      return err(gltfErr('gltf-lod-invalid', { rootNode, ids, reason: 'duplicate-node' }));
+    }
+    const hasMesh = (node: RawNode | undefined): boolean => {
+      if (typeof node?.mesh !== 'number' || !Number.isInteger(node.mesh) || node.mesh < 0) {
+        return false;
+      }
+      const mesh = doc.meshes?.[node.mesh];
+      // An extension relation is publishable only when its target mesh has at
+      // least one primitive. The parser normally receives the source mesh
+      // table, so an empty table/primitive list is a source-contract failure;
+      // treating it as a valid relation would let toAssetPack silently drop
+      // the LOD level later.
+      return mesh !== undefined && Array.isArray(mesh.primitives) && mesh.primitives.length > 0;
+    };
+    if (!hasMesh(nodes[rootNode]) || ids.some((id) => !hasMesh(nodes[id]))) {
+      return err(gltfErr('gltf-lod-invalid', { rootNode, ids, reason: 'missing-node' }));
+    }
+    const nodeCoverage = nodes[rootNode]?.extras?.MSFT_screencoverage;
+    const coverage = normalizeScreenCoverages(
+      nodeCoverage === undefined ? rawCoverage : nodeCoverage,
+      ids.length,
+      nodeCoverage !== undefined,
+    );
+    if (coverage === 'invalid') {
+      return err(gltfErr('gltf-lod-invalid', { rootNode, ids, reason: 'coverage' }));
+    }
+    groups.push({
+      rootNode,
+      lodNodeIds: ids,
+      screenCoverages: coverage ?? [],
+    });
+  }
+  const first = groups[0];
+  if (first === undefined) {
+    if (doc.extensionsRequired?.some((extension) => extension === 'MSFT_lod')) {
+      return err(gltfErr('gltf-lod-invalid', { rootNode: 0, ids: [], reason: 'missing-node' }));
+    }
+    return ok({ rootNode: 0, lodNodeIds: [], screenCoverages: [], groups: [] });
+  }
+  return ok({
+    rootNode: first.rootNode,
+    lodNodeIds: first.lodNodeIds,
+    screenCoverages: first.screenCoverages,
+    groups,
+  });
+}
+
+/**
+ * Normalize the official node `extras.MSFT_screencoverage` form and the
+ * historical ForgeaX document-extension adapter form. The official array
+ * includes one terminal threshold for the discard range, while MeshAsset
+ * stores only the thresholds that select lower geometry levels.
+ */
+function normalizeScreenCoverages(
+  raw: unknown,
+  lodCount: number,
+  officialNodeForm: boolean,
+): readonly number[] | undefined | 'invalid' {
+  if (raw === undefined) return undefined;
+  if (!Array.isArray(raw)) return 'invalid';
+  if (
+    raw.some(
+      (value) => typeof value !== 'number' || !Number.isFinite(value) || value <= 0 || value > 1,
+    )
+  ) {
+    return 'invalid';
+  }
+  const expectedLengths = officialNodeForm ? [lodCount + 1] : [lodCount, lodCount + 1];
+  if (!expectedLengths.includes(raw.length)) return 'invalid';
+  const values = raw.slice(0, lodCount) as number[];
+  for (let index = 1; index < values.length; index += 1) {
+    if ((values[index] as number) >= (values[index - 1] as number)) return 'invalid';
+  }
+  return values;
+}

package/src/lod/project-meta.ts

@@ -0,0 +1,48 @@
+import { deriveDefaultLodScreenCoverages, reconcileMeshLodMeta } from '@forgeax/engine-import';
+import { err, ok, type Result } from '@forgeax/engine-types';
+
+export interface GltfLodMetaLevel {
+  readonly sourceKey: string;
+  readonly guid: string;
+  readonly screenCoverage?: number;
+}
+
+export interface GltfLodMetaCandidate {
+  readonly rootSourceKey: string;
+  readonly levels: readonly GltfLodMetaLevel[];
+  readonly previous?: readonly GltfLodMetaLevel[] | undefined;
+}
+
+export interface GltfLodMetaOutput {
+  readonly sourceKey: string;
+  readonly meshGuid: string;
+  readonly screenCoverage: number;
+}
+
+export function projectGltfLodMeta(
+  input: GltfLodMetaCandidate,
+): Result<
+  { readonly lods: readonly GltfLodMetaOutput[] },
+  { readonly code: string; readonly reason: string }
+> {
+  const defaults = deriveDefaultLodScreenCoverages(input.levels.length + 1);
+  const previous = (input.previous ?? []).map((level) => ({
+    sourceKey: level.sourceKey,
+    meshGuid: level.guid,
+    ...(level.screenCoverage === undefined ? {} : { screenCoverage: level.screenCoverage }),
+  }));
+  const next = input.levels.map((level, index) => ({
+    sourceKey: level.sourceKey,
+    meshGuid: level.guid,
+    screenCoverage: level.screenCoverage ?? defaults[index] ?? 0,
+  }));
+  const reconciled = reconcileMeshLodMeta(previous, next);
+  if (!reconciled.ok) return err({ code: reconciled.error.code, reason: reconciled.error.reason });
+  return ok({
+    lods: reconciled.value.lods.map((level) => ({
+      sourceKey: level.sourceKey,
+      meshGuid: level.meshGuid,
+      screenCoverage: level.screenCoverage,
+    })),
+  });
+}

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 } : {}),