@loaders.gl/scene 5.0.0-alpha.8 → 5.0.0-beta.1

package/src/gltf/lib/api/convert-gltf-v1-skins.ts

@@ -0,0 +1,217 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GLTF, GLTFNode, GLTFSkin} from '../types/gltf-types';
+
+/** Legacy node fields used to resolve one skin instance. */
+type LegacyNode = GLTFNode & {
+  /** Symbolic name referenced by a glTF 1 skin. */
+  jointName?: string;
+  /** Root node IDs selecting this instance's skeleton hierarchy. */
+  skeletons?: string[];
+};
+
+/** Legacy skin fields, before joint names become node indices. */
+type LegacySkin = Omit<GLTFSkin, 'joints'> & {
+  /** Ordered symbolic joint names, matching inverse-bind matrix order. */
+  jointNames?: string[];
+  /** Optional existing joint indices on a hybrid input. */
+  joints?: number[];
+  /** Matrix to bake into geometry or inverse-bind matrices; absent means identity. */
+  bindShapeMatrix?: number[];
+};
+
+/** A resolved skin binding for one mesh node, or for an unused skin. */
+type SkinInstancePlan = {
+  /** Mesh node using this binding, absent for an unused skin. */
+  nodeIndex?: number;
+  /** Ordered glTF 2 joint node indices. */
+  jointIndices: number[];
+  /** Explicit skeleton root or the inferred common ancestor. */
+  skeletonIndex: number;
+};
+
+/**
+ * Resolve glTF 1 joint names inside each instance's skeleton hierarchy.
+ * Shared skins are cloned when instances use different joint nodes. Non-identity bind shapes
+ * remain available for binary baking. Multiple explicit roots are supported when their
+ * disjoint subtrees resolve every joint uniquely and share an unambiguous common ancestor.
+ */
+export function convertGLTFV1Skins(
+  json: GLTF,
+  resolveNodeId: (nodeId: string) => number,
+  reportUnsupported: (feature: string) => void
+): void {
+  const nodes = (json.nodes || []) as LegacyNode[];
+  const skins = (json.skins || []) as LegacySkin[];
+  const originalSkinCount = skins.length;
+  let hasUnconvertedSkin = false;
+
+  for (let skinIndex = 0; skinIndex < originalSkinCount; skinIndex++) {
+    const skin = skins[skinIndex];
+    const jointNames = skin.jointNames;
+    if (
+      !Array.isArray(jointNames) ||
+      jointNames.length === 0 ||
+      jointNames.some(name => typeof name !== 'string' || !name) ||
+      new Set(jointNames).size !== jointNames.length
+    ) {
+      reportUnsupported(`skin ${skinIndex} has invalid joint names`);
+      hasUnconvertedSkin = true;
+      continue;
+    }
+
+    const instanceIndices = nodes.flatMap((node, nodeIndex) =>
+      node.skin === skinIndex ? [nodeIndex] : []
+    );
+    const plans = (instanceIndices.length ? instanceIndices : [undefined]).map(nodeIndex =>
+      resolveSkinInstance(nodes, jointNames, nodeIndex, resolveNodeId, feature =>
+        reportUnsupported(`skin ${skinIndex} ${feature}`)
+      )
+    );
+    const hasFailedPlan = plans.some(plan => !plan);
+    hasUnconvertedSkin ||= hasFailedPlan;
+    const convertedBindings = new Map<string, number>();
+
+    for (const plan of plans) {
+      if (!plan) continue;
+      const bindingKey = `${plan.skeletonIndex}:${plan.jointIndices.join(',')}`;
+      let convertedSkinIndex = convertedBindings.get(bindingKey);
+      if (convertedSkinIndex === undefined) {
+        const convertedSkin: LegacySkin = {
+          ...skin,
+          joints: plan.jointIndices,
+          skeleton: plan.skeletonIndex
+        };
+        delete convertedSkin.jointNames;
+        if (skin.bindShapeMatrix !== undefined && isIdentityBindShape(skin.bindShapeMatrix)) {
+          delete convertedSkin.bindShapeMatrix;
+        }
+        if (!hasFailedPlan && convertedBindings.size === 0) {
+          convertedSkinIndex = skinIndex;
+          skins[skinIndex] = convertedSkin;
+        } else {
+          delete convertedSkin.id;
+          convertedSkinIndex = skins.length;
+          skins.push(convertedSkin);
+        }
+        convertedBindings.set(bindingKey, convertedSkinIndex);
+      }
+      if (plan.nodeIndex !== undefined) {
+        nodes[plan.nodeIndex].skin = convertedSkinIndex;
+        delete nodes[plan.nodeIndex].skeletons;
+      }
+    }
+  }
+  // Keep symbolic names available when a best-effort result contains an unresolved legacy skin.
+  if (!hasUnconvertedSkin) {
+    for (const node of nodes) delete node.jointName;
+  }
+}
+
+/** Resolve ordered names within explicit subtrees, or uniquely across the document. */
+function resolveSkinInstance(
+  nodes: LegacyNode[],
+  jointNames: string[],
+  nodeIndex: number | undefined,
+  resolveNodeId: (nodeId: string) => number,
+  reportUnsupported: (feature: string) => void
+): SkinInstancePlan | null {
+  const skeletonIds = nodeIndex === undefined ? undefined : nodes[nodeIndex].skeletons;
+  if (
+    skeletonIds !== undefined &&
+    (!Array.isArray(skeletonIds) ||
+      skeletonIds.some(id => typeof id !== 'string' || !id) ||
+      new Set(skeletonIds).size !== skeletonIds.length)
+  ) {
+    reportUnsupported('has invalid skeleton roots');
+    return null;
+  }
+  const explicitRoots = (skeletonIds || []).map(resolveNodeId);
+  const candidates = !explicitRoots.length
+    ? nodes.map((node, candidateIndex) => candidateIndex)
+    : collectSkeletonNodes(nodes, explicitRoots);
+  if (!candidates) {
+    reportUnsupported('has invalid or overlapping skeleton subtrees');
+    return null;
+  }
+  const jointIndices: number[] = [];
+  const namedCandidates = new Map<string, number[]>();
+  for (const candidateIndex of candidates) {
+    const jointName = nodes[candidateIndex].jointName;
+    if (jointName === undefined) continue;
+    const matches = namedCandidates.get(jointName) || [];
+    matches.push(candidateIndex);
+    namedCandidates.set(jointName, matches);
+  }
+  for (const jointName of jointNames) {
+    const matches = namedCandidates.get(jointName) || [];
+    if (matches.length !== 1) {
+      reportUnsupported(`cannot uniquely resolve joint ${jointName}`);
+      return null;
+    }
+    jointIndices.push(matches[0]);
+  }
+  const commonRoot = findCommonJointRoot(nodes, [...jointIndices, ...explicitRoots]);
+  if (commonRoot === undefined) {
+    reportUnsupported('joints have no unambiguous common hierarchy root');
+    return null;
+  }
+  return {
+    nodeIndex,
+    jointIndices,
+    skeletonIndex: explicitRoots.length === 1 ? explicitRoots[0] : commonRoot
+  };
+}
+
+/** Collect disjoint subtrees, rejecting missing nodes, cycles, and overlapping paths. */
+function collectSkeletonNodes(nodes: LegacyNode[], rootIndices: number[]): number[] | null {
+  const visited = new Set<number>();
+  const pending = [...rootIndices];
+  while (pending.length) {
+    const nodeIndex = pending.pop()!;
+    if (!Number.isSafeInteger(nodeIndex) || !nodes[nodeIndex] || visited.has(nodeIndex))
+      return null;
+    visited.add(nodeIndex);
+    pending.push(...(nodes[nodeIndex].children || []));
+  }
+  return Array.from(visited);
+}
+
+/** Find the closest common ancestor, rejecting cycles and multiply-parented node graphs. */
+function findCommonJointRoot(nodes: LegacyNode[], jointIndices: number[]): number | undefined {
+  const parents = new Map<number, number>();
+  for (const [nodeIndex, node] of nodes.entries()) {
+    for (const childIndex of node.children || []) {
+      if (!Number.isSafeInteger(childIndex) || !nodes[childIndex] || parents.has(childIndex))
+        return undefined;
+      parents.set(childIndex, nodeIndex);
+    }
+  }
+  const ancestorPaths = jointIndices.map(jointIndex => {
+    const path: number[] = [];
+    const visited = new Set<number>();
+    let ancestorIndex: number | undefined = jointIndex;
+    while (ancestorIndex !== undefined) {
+      if (visited.has(ancestorIndex)) return [];
+      visited.add(ancestorIndex);
+      path.push(ancestorIndex);
+      ancestorIndex = parents.get(ancestorIndex);
+    }
+    return path;
+  });
+  const ancestorSets = ancestorPaths.map(path => new Set(path));
+  return ancestorPaths[0].find(ancestorIndex =>
+    ancestorSets.every(ancestors => ancestors.has(ancestorIndex))
+  );
+}
+
+/** Check exact identity; even small non-identity values require actual matrix baking. */
+function isIdentityBindShape(matrix: number[]): boolean {
+  return (
+    Array.isArray(matrix) &&
+    matrix.length === 16 &&
+    Array.from(matrix).every((value, index) => value === (index % 5 === 0 ? 1 : 0))
+  );
+}

package/src/gltf/lib/api/gltf-accessors.ts

@@ -0,0 +1,87 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {BigTypedArray} from '@loaders.gl/core/schema';
+import type {GLTFWithBuffers, GLTFAccessor} from '../types/gltf-types';
+import {getTypedArrayForAccessor} from '../gltf-utils/get-typed-array';
+import {getComponentTypeFromArray} from '../gltf-utils/gltf-utils';
+import {assert} from '../utils/assert';
+import {padToNBytes} from '@loaders.gl/core/loader-utils';
+
+/** Indexed or inline accessor, including optional values supplied by mesh decoders. */
+export type GLTFAccessorReference = number | (GLTFAccessor & {value?: BigTypedArray});
+
+/** Resolve an indexed or decoder-provided inline accessor without linking the scene graph. */
+export function getGLTFAccessor(
+  gltf: GLTFWithBuffers,
+  reference: GLTFAccessorReference
+): GLTFAccessor {
+  const accessor = typeof reference === 'number' ? gltf.json.accessors?.[reference] : reference;
+  assert(accessor);
+  return accessor!;
+}
+
+/**
+ * Read packed accessor values without replacing JSON indices. Packed dense values borrow storage;
+ * interleaved, unaligned, padded matrix and sparse values are materialized. Normalized integers
+ * retain their stored values. Accessors without a buffer view start at zero; decoder values are
+ * preserved. Sparse substitutions never modify input storage.
+ */
+export function getGLTFAccessorValue(
+  gltf: GLTFWithBuffers,
+  reference: GLTFAccessorReference
+): BigTypedArray {
+  return getTypedArrayForAccessor(gltf.json, gltf.buffers, reference);
+}
+
+/**
+ * Replace accessor storage with a packed value, preserving index references and other accessors.
+ * Packed storage borrows the supplied array; padded matrix columns are copied. Sparse and decoder overrides are cleared so reads,
+ * encoders and writers observe the replacement. Bounds metadata remains caller-owned.
+ */
+export function setGLTFAccessorValue(
+  gltf: GLTFWithBuffers,
+  reference: GLTFAccessorReference,
+  value: BigTypedArray
+): void {
+  const accessor = getGLTFAccessor(gltf, reference);
+  const componentType = getComponentTypeFromArray(value);
+  const components = accessor.type.startsWith('MAT')
+    ? Number(accessor.type.slice(3)) ** 2
+    : accessor.type === 'SCALAR'
+      ? 1
+      : Number(accessor.type.slice(3));
+  assert(value.length === accessor.count * components);
+  const columns = accessor.type.startsWith('MAT') ? Number(accessor.type.slice(3)) : 1;
+  const columnByteLength = columns * value.BYTES_PER_ELEMENT;
+  const columnByteStride = padToNBytes(columnByteLength, 4);
+  let storage = {
+    arrayBuffer: value.buffer as ArrayBuffer,
+    byteOffset: value.byteOffset,
+    byteLength: value.byteLength
+  };
+  if (columns > 1 && columnByteStride !== columnByteLength) {
+    const bytes = new Uint8Array(accessor.count * columns * columnByteStride);
+    const source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    for (let columnIndex = 0; columnIndex < accessor.count * columns; columnIndex++) {
+      bytes.set(
+        source.subarray(columnIndex * columnByteLength, (columnIndex + 1) * columnByteLength),
+        columnIndex * columnByteStride
+      );
+    }
+    storage = {arrayBuffer: bytes.buffer, byteOffset: 0, byteLength: bytes.byteLength};
+  }
+  const bufferIndex = Math.max(gltf.buffers.length, gltf.json.buffers?.length || 0);
+  gltf.json.buffers ||= [];
+  gltf.json.buffers[bufferIndex] = {byteLength: storage.byteLength};
+  gltf.buffers[bufferIndex] = storage;
+  gltf.json.bufferViews ||= [];
+  const bufferViews = gltf.json.bufferViews;
+  accessor.bufferView = bufferViews.length;
+  bufferViews.push({buffer: bufferIndex, byteOffset: 0, byteLength: storage.byteLength});
+  accessor.byteOffset = 0;
+  accessor.componentType = componentType;
+  delete accessor.sparse;
+  delete (accessor as GLTFAccessor & {value?: BigTypedArray}).value;
+}

package/src/gltf/lib/api/gltf-culling.ts

@@ -0,0 +1,80 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  BoxShape,
+  CapsuleShape,
+  CylinderShape,
+  PlaneShape,
+  SphereShape
+} from '@math.gl/geometry/culling';
+import type {ImplicitShape} from '@math.gl/geometry/culling';
+import type {GLTFBoundingVolume, GLTFShape} from '../types/gltf-shape-schema';
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import {Matrix4} from '@math.gl/core';
+
+/** Options for resolving a glTF 2.1 shape. */
+export type GLTFCullingShapeOptions = {
+  /** Optional transform applied after the shape's own local transform. */
+  matrix?: readonly number[];
+};
+
+/** Resolve a draft glTF 2.1 shape into the corresponding math.gl analytic shape. */
+export function getGLTFCullingShape(
+  gltf: GLTFWithBuffers,
+  shapeIndex: number,
+  options: GLTFCullingShapeOptions = {}
+): ImplicitShape | undefined {
+  const shape = gltf.json.shapes?.[shapeIndex] as GLTFShape | undefined;
+  if (!shape) throw new Error(`Invalid glTF shape reference: /shapes/${shapeIndex}`);
+
+  switch (shape.type) {
+    case 'box':
+      return new BoxShape({size: shape.box?.size, matrix: options.matrix});
+    case 'capsule':
+      return new CapsuleShape({...shape.capsule, matrix: options.matrix});
+    case 'cylinder':
+      return new CylinderShape({...shape.cylinder, matrix: options.matrix});
+    case 'plane':
+      return new PlaneShape({...shape.plane, matrix: options.matrix});
+    case 'sphere':
+      return new SphereShape({...shape.sphere, matrix: options.matrix});
+    default:
+      return undefined;
+  }
+}
+
+/** Resolve a node's draft glTF 2.1 bounding volume, including its local matrix. */
+export function getGLTFNodeCullingShape(
+  gltf: GLTFWithBuffers,
+  nodeIndex: number,
+  options: GLTFCullingShapeOptions = {}
+): ImplicitShape | undefined {
+  const node = gltf.json.nodes?.[nodeIndex];
+  if (!node) throw new Error(`Invalid glTF node reference: /nodes/${nodeIndex}`);
+  const boundingVolume = node.boundingVolume as GLTFBoundingVolume | undefined;
+  if (!boundingVolume) return undefined;
+  const shape = getGLTFCullingShape(gltf, boundingVolume.shape, {
+    matrix: getBoundingVolumeMatrix(boundingVolume)
+  });
+  if (shape && options.matrix) shape.transform(options.matrix);
+  return shape;
+}
+
+/** Compose a bounding-volume matrix from its matrix or TRS representation. */
+function getBoundingVolumeMatrix(
+  boundingVolume: GLTFBoundingVolume
+): readonly number[] | undefined {
+  if (boundingVolume.matrix) {
+    return boundingVolume.matrix;
+  }
+  if (!boundingVolume.translation && !boundingVolume.rotation && !boundingVolume.scale) {
+    return undefined;
+  }
+  const rotationMatrix = new Matrix4().fromQuaternion(boundingVolume.rotation || [0, 0, 0, 1]);
+  return new Matrix4()
+    .translate(boundingVolume.translation || [0, 0, 0])
+    .multiplyRight(rotationMatrix)
+    .scale(boundingVolume.scale || [1, 1, 1]);
+}

package/src/gltf/lib/api/gltf-extension-data.ts

@@ -0,0 +1,125 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+import type {GLTF, GLTFMaterial, GLTFAccessor} from '../types/gltf-json-schema';
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import type {
+  GLTFMaterialVariant,
+  GLTFMaterialVariantMapping,
+  GLTFXMPPacket,
+  GLTF_KHR_xmp_json_ld_reference
+} from '../types/gltf-additional-extension-schemas';
+
+/** Material variant mapping resolved against the original document. */
+export type GLTFMaterialVariantData = {
+  /** Mesh containing the primitive. */
+  meshIndex: number;
+  /** Primitive within the mesh. */
+  primitiveIndex: number;
+  /** Original mapping with its serialized references. */
+  mapping: GLTFMaterialVariantMapping;
+  /** Material selected by this mapping. */
+  material: GLTFMaterial;
+  /** Named variants associated with this material. */
+  variants: GLTFMaterialVariant[];
+};
+
+/** Lazy GPU instance attributes attached to a mesh node. */
+export type GLTFMeshInstanceData = {
+  /** Node containing the instanced mesh. */
+  nodeIndex: number;
+  /** Referenced mesh index. */
+  meshIndex: number;
+  /** Number of instances shared by all attributes. */
+  count: number;
+  /** Original accessor indices, including custom attributes. */
+  attributes: Readonly<Record<string, number>>;
+  /** Accessor declarations without materializing instance arrays. */
+  accessors: Readonly<Record<string, GLTFAccessor>>;
+};
+
+/** Returns material variant mappings with material and named variant references resolved. */
+export function getMaterialVariantMappings(
+  gltf: GLTF | GLTFWithBuffers
+): GLTFMaterialVariantData[] {
+  const json = getDocument(gltf);
+  const variants = json.extensions?.KHR_materials_variants?.variants || [];
+  const descriptors: GLTFMaterialVariantData[] = [];
+  for (const [meshIndex, mesh] of (json.meshes || []).entries()) {
+    for (const [primitiveIndex, primitive] of mesh.primitives.entries()) {
+      const mappings = primitive.extensions?.KHR_materials_variants?.mappings || [];
+      for (const mapping of mappings) {
+        descriptors.push({
+          meshIndex,
+          primitiveIndex,
+          mapping,
+          material: getReference(json.materials || [], mapping.material, 'material'),
+          variants: mapping.variants.map(index => getReference(variants, index, 'variant'))
+        });
+      }
+    }
+  }
+  return descriptors;
+}
+
+/** Returns lazy GPU instance descriptors, checking mesh references and equal attribute counts. */
+export function getMeshInstances(gltf: GLTF | GLTFWithBuffers): GLTFMeshInstanceData[] {
+  const json = getDocument(gltf);
+  const descriptors: GLTFMeshInstanceData[] = [];
+  for (const [nodeIndex, node] of (json.nodes || []).entries()) {
+    const extension = node.extensions?.EXT_mesh_gpu_instancing;
+    if (!extension) continue;
+    const meshIndex = node.mesh;
+    getReference(json.meshes || [], meshIndex, 'instanced mesh');
+    const accessors: Record<string, GLTFAccessor> = {};
+    let count: number | undefined;
+    for (const [attribute, accessorIndex] of Object.entries(extension.attributes)) {
+      const accessor = getReference(json.accessors || [], accessorIndex, 'instance accessor');
+      if (count !== undefined && count !== accessor.count) {
+        throw new Error('EXT_mesh_gpu_instancing: instance accessor counts must match.');
+      }
+      count = accessor.count;
+      accessors[attribute] = accessor;
+    }
+    if (count === undefined)
+      throw new Error('EXT_mesh_gpu_instancing: requires instance attributes.');
+    descriptors.push({
+      nodeIndex,
+      meshIndex: meshIndex!,
+      count,
+      attributes: {...extension.attributes},
+      accessors
+    });
+  }
+  return descriptors;
+}
+
+/** Resolves an object's XMP packet without interpreting JSON-LD or fetching namespace URLs. */
+export function getXMPMetadata(
+  gltf: GLTF | GLTFWithBuffers,
+  object: {extensions?: Record<string, unknown>}
+): GLTFXMPPacket | undefined {
+  const reference = object.extensions?.KHR_xmp_json_ld as
+    | GLTF_KHR_xmp_json_ld_reference
+    | undefined;
+  if (!reference) return undefined;
+  return getReference(
+    getDocument(gltf).extensions?.KHR_xmp_json_ld?.packets || [],
+    reference.packet,
+    'XMP packet'
+  );
+}
+
+/** Gets source JSON from either a raw document or a loader result. */
+function getDocument(gltf: GLTF | GLTFWithBuffers): GLTF {
+  return ('asset' in gltf ? gltf : gltf.json) as GLTF;
+}
+
+/** Resolves an extension index and reports broken references without mutating the document. */
+function getReference<Value>(values: Value[], index: number | undefined, kind: string): Value {
+  if (index === undefined || !Number.isInteger(index) || index < 0 || !values[index]) {
+    throw new Error(`glTF: invalid ${kind} index ${index}.`);
+  }
+  return values[index];
+}

package/src/gltf/lib/api/gltf-extensions.ts

@@ -0,0 +1,133 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+import type {GLTF} from '../types/gltf-json-schema';
+import type {GLTFWithBuffers} from '../types/gltf-types';
+import type {GLTFLoaderOptions} from '../../gltf-loader-types';
+import {GLTFWriterOptions} from '../../gltf-writer';
+
+// GLTF 1.0 extensions (decode only)
+// import * as KHR_binary_gltf from './KHR_draco_mesh_compression';
+
+// GLTF 2.0 Vendor extensions
+import * as EXT_mesh_features from '../extensions/EXT_mesh_features';
+import * as EXT_structural_metadata from '../extensions/EXT_structural_metadata';
+import * as KHR_gaussian_splatting from '../extensions/KHR_gaussian_splatting';
+import * as EXT_primitive_voxels from '../extensions/EXT_primitive_voxels';
+import * as EXT_mesh_polygon from '../extensions/EXT_mesh_polygon';
+import * as MPEG_audio_spatial from '../extensions/MPEG_audio_spatial';
+import * as KHR_audio_emitter from '../extensions/KHR_audio_emitter';
+
+// GLTF 2.0 Khronos extensions (decode/encode)
+import * as EXT_meshopt_compression from '../extensions/EXT_meshopt_compression';
+import * as KHR_meshopt_compression from '../extensions/KHR_meshopt_compression';
+import * as EXT_texture_webp from '../extensions/EXT_texture_webp';
+import * as EXT_texture_avif from '../extensions/EXT_texture_avif';
+import * as KHR_texture_basisu from '../extensions/KHR_texture_basisu';
+import * as KHR_draco_mesh_compression from '../extensions/KHR_draco_mesh_compression';
+import * as KHR_texture_transform from '../extensions/KHR_texture_transform';
+import * as KHR_mesh_primitive_restart from '../extensions/KHR_mesh_primitive_restart';
+
+// Deprecated. These should be handled by rendering library (e.g. luma.gl), not the loader.
+import * as KHR_lights_punctual from '../extensions/deprecated/KHR_lights_punctual';
+import * as KHR_materials_unlit from '../extensions/deprecated/KHR_materials_unlit';
+import * as KHR_techniques_webgl from '../extensions/deprecated/KHR_techniques_webgl';
+import * as EXT_feature_metadata from '../extensions/deprecated/EXT_feature_metadata';
+
+type GLTFExtensionPlugin = {
+  name: string;
+  preprocess?: (
+    gltfData: GLTFWithBuffers,
+    options: GLTFLoaderOptions,
+    context
+  ) => void | Promise<void>;
+  decode?: (
+    gltfData: {
+      json: GLTF;
+      buffers: {arrayBuffer: ArrayBuffer; byteOffset: number; byteLength: number}[];
+    },
+    options: GLTFLoaderOptions,
+    context
+  ) => Promise<void>;
+  encode?: (gltfData: {json: GLTF}, options: GLTFWriterOptions) => void;
+};
+
+/**
+ * List of extensions processed by the GLTFLoader
+ * Note that may extensions can only be handled on the rendering stage and are left out here
+ * These are just extensions that can be handled fully or partially during loading.
+ */
+export const EXTENSIONS: GLTFExtensionPlugin[] = [
+  // 1.0
+  // KHR_binary_gltf is handled separately - must be processed before other parsing starts
+  // KHR_binary_gltf,
+
+  // 2.0
+  // Decode compression before metadata and feature extensions: meshopt populates buffer
+  // views, while Draco replaces compressed attribute references with decoded accessors
+  // consumed by EXT_mesh_features.
+  KHR_meshopt_compression,
+  EXT_meshopt_compression,
+  KHR_draco_mesh_compression,
+  EXT_structural_metadata,
+  EXT_mesh_features,
+  KHR_gaussian_splatting,
+  EXT_primitive_voxels,
+  KHR_mesh_primitive_restart,
+  EXT_mesh_polygon,
+  MPEG_audio_spatial,
+  KHR_audio_emitter,
+  EXT_texture_avif,
+  EXT_texture_webp,
+  // Basisu should come after webp, we want basisu to be preferred if both are provided
+  KHR_texture_basisu,
+  KHR_lights_punctual,
+  KHR_materials_unlit,
+  KHR_techniques_webgl,
+  KHR_texture_transform,
+  EXT_feature_metadata
+];
+
+/**
+ * List of extensions processed by the GLTFWriter
+ */
+const EXTENSIONS_ENCODING: GLTFExtensionPlugin[] = [
+  KHR_materials_unlit,
+  EXT_structural_metadata,
+  EXT_mesh_features
+];
+
+/** Call before any resource loading starts */
+export async function preprocessExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {
+  const extensions = EXTENSIONS.filter(extension => useExtension(extension.name, options));
+  for (const extension of extensions) {
+    await extension.preprocess?.(gltf, options, context);
+  }
+}
+
+/** Call after resource loading */
+export async function decodeExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {
+  const extensions = EXTENSIONS.filter(extension => useExtension(extension.name, options));
+  for (const extension of extensions) {
+    // Await each decoder in EXTENSIONS order: later extensions consume buffers and
+    // accessors populated by earlier decoders.
+    await extension.decode?.(gltf, options, context);
+  }
+}
+
+/** Call before resource writing */
+export function encodeExtensions(gltf, options: GLTFWriterOptions = {}) {
+  for (const extension of EXTENSIONS_ENCODING) {
+    gltf = extension.encode?.(gltf, options) ?? gltf;
+  }
+  return gltf;
+}
+
+function useExtension(extensionName: string, options: GLTFLoaderOptions) {
+  const excludes = options?.gltf?.excludeExtensions || {};
+  if (Array.isArray(excludes)) return !excludes.includes(extensionName);
+  const exclude = extensionName in excludes && !excludes[extensionName];
+  return !exclude;
+}