@forgeax/engine-gltf 0.1.7 → 0.1.19

package/src/material/parse-material.ts

@@ -0,0 +1,342 @@
+export interface GltfTextureIr {
+  readonly sampler?: number;
+  readonly source: number;
+  readonly name?: string;
+}
+
+export interface GltfImageIr {
+  readonly uri?: string;
+  readonly mimeType?: string;
+  readonly bufferView?: number;
+  readonly name?: string;
+}
+
+export interface GltfSamplerIr {
+  readonly magFilter?: number;
+  readonly minFilter?: number;
+  readonly wrapS: number;
+  readonly wrapT: number;
+  readonly name?: string;
+}
+
+export interface GltfTextureTransformIr {
+  readonly offset?: readonly [number, number];
+  readonly rotation?: number;
+  readonly scale?: readonly [number, number];
+}
+
+export interface GltfTextureInfoIr {
+  readonly texture: number;
+  readonly sampler?: number;
+  readonly texCoord?: number;
+  readonly transform?: GltfTextureTransformIr;
+}
+
+export interface GltfNormalTextureInfoIr extends GltfTextureInfoIr {
+  readonly scale?: number;
+}
+
+export interface GltfOcclusionTextureInfoIr extends GltfTextureInfoIr {
+  readonly strength?: number;
+}
+
+export interface TextureTransformJson {
+  readonly offset?: readonly number[];
+  readonly rotation?: number;
+  readonly scale?: readonly number[];
+  readonly texCoord?: number;
+}
+
+export interface TextureInfoJson {
+  readonly index: number;
+  readonly texCoord?: number;
+  readonly extensions?: {
+    readonly KHR_texture_transform?: TextureTransformJson;
+  };
+}
+
+export interface NormalTextureInfoJson extends TextureInfoJson {
+  readonly scale?: number;
+}
+
+export interface OcclusionTextureInfoJson extends TextureInfoJson {
+  readonly strength?: number;
+}
+
+export interface GltfMaterialJson {
+  readonly name?: string;
+  readonly pbrMetallicRoughness?: {
+    readonly baseColorFactor?: readonly number[];
+    readonly baseColorTexture?: TextureInfoJson;
+    readonly metallicFactor?: number;
+    readonly roughnessFactor?: number;
+    readonly metallicRoughnessTexture?: TextureInfoJson;
+  };
+  readonly normalTexture?: NormalTextureInfoJson;
+  readonly emissiveFactor?: readonly number[];
+  readonly emissiveTexture?: TextureInfoJson;
+  readonly occlusionTexture?: OcclusionTextureInfoJson;
+  readonly alphaMode?: string;
+  readonly alphaCutoff?: number;
+  readonly doubleSided?: boolean;
+  readonly extensions?: {
+    readonly KHR_materials_transmission?: {
+      readonly transmissionFactor?: number;
+      readonly transmissionTexture?: TextureInfoJson;
+    };
+    readonly KHR_materials_ior?: {
+      readonly ior?: number;
+    };
+    readonly KHR_materials_volume?: {
+      readonly thicknessFactor?: number;
+      readonly thicknessTexture?: TextureInfoJson;
+      readonly attenuationColor?: readonly number[];
+      readonly attenuationDistance?: number;
+    };
+  };
+}
+
+export interface GltfMaterialIr {
+  readonly name?: string;
+  readonly baseColorFactor: readonly [number, number, number, number];
+  /** glTF emissiveFactor; omitted means the glTF default [0, 0, 0]. */
+  readonly emissiveFactor?: readonly [number, number, number];
+  readonly baseColorTexture?: GltfTextureInfoIr | number;
+  readonly emissiveTexture?: GltfTextureInfoIr | number;
+  readonly metallicFactor: number;
+  readonly roughnessFactor: number;
+  readonly metallicRoughnessTexture?: GltfTextureInfoIr | number;
+  readonly normalTexture?: GltfNormalTextureInfoIr | number;
+  readonly occlusionTexture?: GltfOcclusionTextureInfoIr | number;
+  readonly transmissionFactor?: number;
+  readonly transmissionTexture?: GltfTextureInfoIr | number;
+  /** KHR_materials_transmission uses the red texture channel. */
+  readonly transmissionChannel?: number;
+  readonly ior?: number;
+  readonly thicknessFactor?: number;
+  readonly thicknessTexture?: GltfTextureInfoIr | number;
+  /** KHR_materials_volume uses the green texture channel. */
+  readonly thicknessChannel?: number;
+  readonly attenuationColor?: readonly [number, number, number];
+  readonly attenuationDistance?: number;
+  readonly alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+  readonly alphaCutoff?: number;
+  readonly doubleSided?: boolean;
+  readonly baseColorTexCoord?: number;
+}
+
+function tuple2(values: readonly number[] | undefined): readonly [number, number] | undefined {
+  if (values === undefined || values.length < 2) return undefined;
+  return [values[0] ?? 0, values[1] ?? 0];
+}
+
+function tuple3(
+  values: readonly number[] | undefined,
+): readonly [number, number, number] | undefined {
+  if (values === undefined || values.length < 3) return undefined;
+  return [values[0] ?? 0, values[1] ?? 0, values[2] ?? 0];
+}
+
+export function parseTextureInfo(
+  info: TextureInfoJson,
+  textures: readonly GltfTextureIr[],
+): GltfTextureInfoIr {
+  const transformJson = info.extensions?.KHR_texture_transform;
+  const offset = tuple2(transformJson?.offset);
+  const scale = tuple2(transformJson?.scale);
+  const transform =
+    offset === undefined && transformJson?.rotation === undefined && scale === undefined
+      ? undefined
+      : {
+          ...(offset === undefined ? {} : { offset }),
+          ...(transformJson?.rotation === undefined ? {} : { rotation: transformJson.rotation }),
+          ...(scale === undefined ? {} : { scale }),
+        };
+  const sampler = textures[info.index]?.sampler;
+  return {
+    texture: info.index,
+    ...(sampler === undefined ? {} : { sampler }),
+    ...(info.texCoord === undefined && transformJson?.texCoord === undefined
+      ? {}
+      : { texCoord: transformJson?.texCoord ?? info.texCoord }),
+    ...(transform === undefined ? {} : { transform }),
+  };
+}
+
+function finiteOrUndefined(value: number | undefined): number | undefined {
+  return value !== undefined && Number.isFinite(value) ? value : undefined;
+}
+
+export function parseMaterial(
+  matJson: GltfMaterialJson,
+  textures: readonly GltfTextureIr[],
+): Result<GltfMaterialIr, GltfError> {
+  const pbr = matJson.pbrMetallicRoughness;
+  const baseColor = pbr?.baseColorFactor ?? [1, 1, 1, 1];
+  const baseColor4: readonly [number, number, number, number] = [
+    baseColor[0] ?? 1,
+    baseColor[1] ?? 1,
+    baseColor[2] ?? 1,
+    baseColor[3] ?? 1,
+  ];
+  const alphaMode =
+    matJson.alphaMode === 'MASK' || matJson.alphaMode === 'BLEND' ? matJson.alphaMode : undefined;
+  const alphaCutoff = alphaMode === 'MASK' ? (matJson.alphaCutoff ?? 0.5) : undefined;
+  const emissiveFactor = tuple3(matJson.emissiveFactor);
+  const transmission = matJson.extensions?.KHR_materials_transmission;
+  const ior = matJson.extensions?.KHR_materials_ior;
+  const volume = matJson.extensions?.KHR_materials_volume;
+  const attenuationColor = tuple3(volume?.attenuationColor);
+  const invalid = (
+    extension: 'KHR_materials_transmission' | 'KHR_materials_ior' | 'KHR_materials_volume',
+    field: string,
+    reason: 'type' | 'range' | 'non-finite' | 'blend',
+    actual?: unknown,
+  ): Result<GltfMaterialIr, GltfError> =>
+    err(
+      gltfErr('gltf-material-transmission-invalid', {
+        extension,
+        field,
+        reason,
+        ...(actual === undefined ? {} : { actual }),
+      }),
+    );
+  if (
+    transmission?.transmissionFactor !== undefined &&
+    (typeof transmission.transmissionFactor !== 'number' ||
+      !Number.isFinite(transmission.transmissionFactor))
+  ) {
+    return invalid(
+      'KHR_materials_transmission',
+      'transmissionFactor',
+      'non-finite',
+      transmission.transmissionFactor,
+    );
+  }
+  if (
+    transmission?.transmissionFactor !== undefined &&
+    (transmission.transmissionFactor < 0 || transmission.transmissionFactor > 1)
+  ) {
+    return invalid(
+      'KHR_materials_transmission',
+      'transmissionFactor',
+      'range',
+      transmission.transmissionFactor,
+    );
+  }
+  if (ior?.ior !== undefined && (typeof ior.ior !== 'number' || !Number.isFinite(ior.ior))) {
+    return invalid('KHR_materials_ior', 'ior', 'non-finite', ior.ior);
+  }
+  if (ior?.ior !== undefined && ior.ior < 1) {
+    return invalid('KHR_materials_ior', 'ior', 'range', ior.ior);
+  }
+  if (volume?.thicknessFactor !== undefined && !Number.isFinite(volume.thicknessFactor)) {
+    return invalid('KHR_materials_volume', 'thicknessFactor', 'non-finite', volume.thicknessFactor);
+  }
+  if (volume?.thicknessFactor !== undefined && volume.thicknessFactor < 0) {
+    return invalid('KHR_materials_volume', 'thicknessFactor', 'range', volume.thicknessFactor);
+  }
+  if (
+    volume?.attenuationColor !== undefined &&
+    (attenuationColor === undefined ||
+      attenuationColor.some((value) => !Number.isFinite(value) || value < 0 || value > 1))
+  ) {
+    return invalid('KHR_materials_volume', 'attenuationColor', 'range', volume.attenuationColor);
+  }
+  if (
+    volume?.attenuationDistance !== undefined &&
+    !Number.isFinite(volume.attenuationDistance) &&
+    volume.attenuationDistance !== Number.POSITIVE_INFINITY
+  ) {
+    return invalid(
+      'KHR_materials_volume',
+      'attenuationDistance',
+      'non-finite',
+      volume.attenuationDistance,
+    );
+  }
+  if (
+    volume?.attenuationDistance !== undefined &&
+    Number.isFinite(volume.attenuationDistance) &&
+    volume.attenuationDistance <= 0
+  ) {
+    return invalid(
+      'KHR_materials_volume',
+      'attenuationDistance',
+      'range',
+      volume.attenuationDistance,
+    );
+  }
+  if (alphaMode === 'BLEND' && (transmission?.transmissionFactor ?? 0) > 0) {
+    return invalid('KHR_materials_transmission', 'alphaMode', 'blend', alphaMode);
+  }
+  return ok({
+    ...(matJson.name === undefined ? {} : { name: matJson.name }),
+    baseColorFactor: baseColor4,
+    ...(emissiveFactor === undefined ? {} : { emissiveFactor }),
+    metallicFactor: pbr?.metallicFactor ?? 1.0,
+    roughnessFactor: pbr?.roughnessFactor ?? 1.0,
+    ...(pbr?.baseColorTexture === undefined
+      ? {}
+      : { baseColorTexture: parseTextureInfo(pbr.baseColorTexture, textures) }),
+    ...(pbr?.metallicRoughnessTexture === undefined
+      ? {}
+      : { metallicRoughnessTexture: parseTextureInfo(pbr.metallicRoughnessTexture, textures) }),
+    ...(matJson.normalTexture === undefined
+      ? {}
+      : {
+          normalTexture: {
+            ...parseTextureInfo(matJson.normalTexture, textures),
+            ...(matJson.normalTexture.scale === undefined
+              ? {}
+              : { scale: matJson.normalTexture.scale }),
+          },
+        }),
+    ...(matJson.occlusionTexture === undefined
+      ? {}
+      : {
+          occlusionTexture: {
+            ...parseTextureInfo(matJson.occlusionTexture, textures),
+            ...(matJson.occlusionTexture.strength === undefined
+              ? {}
+              : { strength: matJson.occlusionTexture.strength }),
+          },
+        }),
+    ...(matJson.emissiveTexture === undefined
+      ? {}
+      : { emissiveTexture: parseTextureInfo(matJson.emissiveTexture, textures) }),
+    ...(transmission === undefined
+      ? {}
+      : {
+          transmissionFactor: transmission.transmissionFactor ?? 0,
+          transmissionChannel: 0,
+          ...(transmission.transmissionTexture === undefined
+            ? {}
+            : {
+                transmissionTexture: parseTextureInfo(transmission.transmissionTexture, textures),
+              }),
+        }),
+    ...(ior === undefined ? {} : { ior: ior.ior ?? 1.5 }),
+    ...(volume === undefined
+      ? {}
+      : {
+          thicknessFactor: volume.thicknessFactor ?? 0,
+          thicknessChannel: 1,
+          ...(volume.thicknessTexture === undefined
+            ? {}
+            : { thicknessTexture: parseTextureInfo(volume.thicknessTexture, textures) }),
+          ...(attenuationColor === undefined ? {} : { attenuationColor }),
+          ...(finiteOrUndefined(volume.attenuationDistance) === undefined
+            ? {}
+            : { attenuationDistance: volume.attenuationDistance }),
+        }),
+    ...(alphaMode === undefined ? {} : { alphaMode }),
+    ...(alphaCutoff === undefined ? {} : { alphaCutoff }),
+    ...(matJson.doubleSided === true ? { doubleSided: true } : {}),
+    ...(pbr?.baseColorTexture?.texCoord === undefined || pbr.baseColorTexture.texCoord === 0
+      ? {}
+      : { baseColorTexCoord: pbr.baseColorTexture.texCoord }),
+  });
+}
+
+import { err, type GltfError, gltfErr, ok, type Result } from '../errors.js';