@luma.gl/gltf 9.2.6 → 9.3.0-alpha.11

package/src/pbr/pbr-environment.ts

@@ -3,26 +3,39 @@
 // Copyright (c) vis.gl contributors
 
 import {Device, SamplerProps} from '@luma.gl/core';
-import {AsyncTexture} from '@luma.gl/engine';
+import {
+  DynamicTexture,
+  type Texture2DData,
+  type TextureCubeData,
+  type TextureCubeFace
+} from '@luma.gl/engine';
 import {loadImageTexture} from '@loaders.gl/textures';
 
 /** Environment textures for PBR module */
 export type PBREnvironment = {
   /** Bi-directional Reflectance Distribution Function (BRDF) lookup table */
-  brdfLutTexture: AsyncTexture;
-  diffuseEnvSampler: AsyncTexture;
-  specularEnvSampler: AsyncTexture;
+  brdfLutTexture: DynamicTexture;
+  /** Diffuse irradiance cubemap. */
+  diffuseEnvSampler: DynamicTexture;
+  /** Specular reflection cubemap with mip chain. */
+  specularEnvSampler: DynamicTexture;
 };
 
+/** Configuration used to load an image-based lighting environment. */
 export type PBREnvironmentProps = {
+  /** URL of the BRDF lookup texture. */
   brdfLutUrl: string;
+  /** Callback that returns the URL for a diffuse or specular cubemap face and mip level. */
   getTexUrl: (name: string, dir: number, level: number) => string;
+  /** Number of mip levels in the specular environment map. */
   specularMipLevels?: number;
 };
 
 /** Loads textures for PBR environment */
 export function loadPBREnvironment(device: Device, props: PBREnvironmentProps): PBREnvironment {
-  const brdfLutTexture = new AsyncTexture(device, {
+  const specularMipLevels = props.specularMipLevels ?? 1;
+
+  const brdfLutTexture = new DynamicTexture(device, {
     id: 'brdfLUT',
     sampler: {
       addressModeU: 'clamp-to-edge',
@@ -36,7 +49,10 @@ export function loadPBREnvironment(device: Device, props: PBREnvironmentProps):
 
   const diffuseEnvSampler = makeCube(device, {
     id: 'DiffuseEnvSampler',
-    getTextureForFace: dir => loadImageTexture(props.getTexUrl('diffuse', dir, 0)),
+    getTextureForFace: face =>
+      loadImageTexture(
+        props.getTexUrl('diffuse', FACES.indexOf(face), 0)
+      ) as Promise<Texture2DData>,
     sampler: {
       addressModeU: 'clamp-to-edge',
       addressModeV: 'clamp-to-edge',
@@ -47,13 +63,13 @@ export function loadPBREnvironment(device: Device, props: PBREnvironmentProps):
 
   const specularEnvSampler = makeCube(device, {
     id: 'SpecularEnvSampler',
-    getTextureForFace: (dir: number) => {
-      const imageArray: Promise<any>[] = [];
-      // @ts-ignore
-      for (let lod = 0; lod <= props.specularMipLevels - 1; lod++) {
-        imageArray.push(loadImageTexture(props.getTexUrl('specular', dir, lod)));
+    getTextureForFace: (face: TextureCubeFace) => {
+      const imageArray: Array<Promise<unknown>> = [];
+      const direction = FACES.indexOf(face);
+      for (let lod = 0; lod < specularMipLevels; lod++) {
+        imageArray.push(loadImageTexture(props.getTexUrl('specular', direction, lod)));
       }
-      return imageArray;
+      return Promise.all(imageArray) as Promise<Texture2DData>;
     },
     sampler: {
       addressModeU: 'clamp-to-edge',
@@ -71,8 +87,9 @@ export function loadPBREnvironment(device: Device, props: PBREnvironmentProps):
 }
 
 // TODO put somewhere common
-const FACES = [0, 1, 2, 3, 4, 5];
+const FACES: TextureCubeFace[] = ['+X', '-X', '+Y', '-Y', '+Z', '-Z'];
 
+/** Construction props for an asynchronously loaded cubemap. */
 function makeCube(
   device: Device,
   {
@@ -80,22 +97,28 @@ function makeCube(
     getTextureForFace,
     sampler
   }: {
+    /** Debug id assigned to the created texture. */
     id: string;
-    getTextureForFace: (dir: number) => Promise<any> | Promise<any>[];
+    /** Returns the image or mip-array promise for one cubemap face. */
+    getTextureForFace: (face: TextureCubeFace) => Promise<Texture2DData>;
+    /** Sampler configuration shared across faces. */
     sampler: SamplerProps;
   }
-): AsyncTexture {
-  const data = {};
-  FACES.forEach(face => {
-    // @ts-ignore TODO
-    data[String(face)] = getTextureForFace(face);
+): DynamicTexture {
+  const data: Promise<TextureCubeData> = Promise.all(
+    FACES.map(face => getTextureForFace(face))
+  ).then(faceDataArray => {
+    const cubeData = {} as TextureCubeData;
+    FACES.forEach((face, index) => {
+      cubeData[face] = faceDataArray[index];
+    });
+    return cubeData;
   });
-  return new AsyncTexture(device, {
+  return new DynamicTexture(device, {
     id,
     dimension: 'cube',
     mipmaps: false,
     sampler,
-    // @ts-expect-error
     data
   });
 }

package/src/pbr/pbr-material.ts

@@ -1,10 +1,25 @@
 import type {Texture, Parameters} from '@luma.gl/core';
-import {PBRMaterialBindings, PBRMaterialUniforms, PBRProjectionProps} from '@luma.gl/shadertools';
+import {
+  IBLBindings,
+  PBRMaterialBindings,
+  PBRMaterialUniforms,
+  PBRProjectionProps
+} from '@luma.gl/shadertools';
 
+type ParsedPBRMaterialUniforms = Partial<PBRProjectionProps & PBRMaterialUniforms> & {
+  clearcoatRoughnessMapEnabled?: boolean;
+  sheenRoughnessMapEnabled?: boolean;
+};
+
+/** Material state extracted from a glTF primitive for consumption by the PBR shader module. */
 export type ParsedPBRMaterial = {
+  /** Shader defines inferred from geometry and material features. */
   readonly defines: Record<string, boolean>;
-  readonly bindings: Partial<PBRMaterialBindings>;
-  readonly uniforms: Partial<PBRProjectionProps & PBRMaterialUniforms>;
+  /** Texture and sampler bindings for the PBR shader module. */
+  readonly bindings: Partial<PBRMaterialBindings & IBLBindings>;
+  /** Uniform values for the projection and PBR shader modules. */
+  readonly uniforms: ParsedPBRMaterialUniforms;
+  /** Render pipeline parameters derived from the glTF material. */
   readonly parameters: Parameters;
   /** @deprecated Use parameters */
   readonly glParameters: Record<string, any>;

package/src/pbr/texture-transform.ts

@@ -0,0 +1,263 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Matrix3} from '@math.gl/core';
+
+export type PBRTextureTransformSlot =
+  | 'baseColor'
+  | 'metallicRoughness'
+  | 'normal'
+  | 'occlusion'
+  | 'emissive'
+  | 'specularColor'
+  | 'specularIntensity'
+  | 'transmission'
+  | 'thickness'
+  | 'clearcoat'
+  | 'clearcoatRoughness'
+  | 'clearcoatNormal'
+  | 'sheenColor'
+  | 'sheenRoughness'
+  | 'iridescence'
+  | 'iridescenceThickness'
+  | 'anisotropy';
+
+export type PBRTextureTransformPath = 'offset' | 'rotation' | 'scale';
+
+export type PBRTextureTransform = {
+  offset: [number, number];
+  rotation: number;
+  scale: [number, number];
+};
+
+export type PBRTextureTransformSlotDefinition = {
+  slot: PBRTextureTransformSlot;
+  binding: string;
+  displayName: string;
+  pathSegments: string[];
+  uvSetUniform: string;
+  uvTransformUniform: string;
+};
+
+const IDENTITY_TEXTURE_TRANSFORM: PBRTextureTransform = {
+  offset: [0, 0],
+  rotation: 0,
+  scale: [1, 1]
+};
+
+const TEXTURE_TRANSFORM_SLOT_DEFINITIONS: PBRTextureTransformSlotDefinition[] = [
+  createTextureTransformSlotDefinition('baseColor', 'pbr_baseColorSampler', 'baseColorTexture', [
+    'pbrMetallicRoughness',
+    'baseColorTexture'
+  ]),
+  createTextureTransformSlotDefinition(
+    'metallicRoughness',
+    'pbr_metallicRoughnessSampler',
+    'metallicRoughnessTexture',
+    ['pbrMetallicRoughness', 'metallicRoughnessTexture']
+  ),
+  createTextureTransformSlotDefinition('normal', 'pbr_normalSampler', 'normalTexture', [
+    'normalTexture'
+  ]),
+  createTextureTransformSlotDefinition('occlusion', 'pbr_occlusionSampler', 'occlusionTexture', [
+    'occlusionTexture'
+  ]),
+  createTextureTransformSlotDefinition('emissive', 'pbr_emissiveSampler', 'emissiveTexture', [
+    'emissiveTexture'
+  ]),
+  createTextureTransformSlotDefinition(
+    'specularColor',
+    'pbr_specularColorSampler',
+    'KHR_materials_specular.specularColorTexture',
+    ['extensions', 'KHR_materials_specular', 'specularColorTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'specularIntensity',
+    'pbr_specularIntensitySampler',
+    'KHR_materials_specular.specularTexture',
+    ['extensions', 'KHR_materials_specular', 'specularTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'transmission',
+    'pbr_transmissionSampler',
+    'KHR_materials_transmission.transmissionTexture',
+    ['extensions', 'KHR_materials_transmission', 'transmissionTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'thickness',
+    'pbr_thicknessSampler',
+    'KHR_materials_volume.thicknessTexture',
+    ['extensions', 'KHR_materials_volume', 'thicknessTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'clearcoat',
+    'pbr_clearcoatSampler',
+    'KHR_materials_clearcoat.clearcoatTexture',
+    ['extensions', 'KHR_materials_clearcoat', 'clearcoatTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'clearcoatRoughness',
+    'pbr_clearcoatRoughnessSampler',
+    'KHR_materials_clearcoat.clearcoatRoughnessTexture',
+    ['extensions', 'KHR_materials_clearcoat', 'clearcoatRoughnessTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'clearcoatNormal',
+    'pbr_clearcoatNormalSampler',
+    'KHR_materials_clearcoat.clearcoatNormalTexture',
+    ['extensions', 'KHR_materials_clearcoat', 'clearcoatNormalTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'sheenColor',
+    'pbr_sheenColorSampler',
+    'KHR_materials_sheen.sheenColorTexture',
+    ['extensions', 'KHR_materials_sheen', 'sheenColorTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'sheenRoughness',
+    'pbr_sheenRoughnessSampler',
+    'KHR_materials_sheen.sheenRoughnessTexture',
+    ['extensions', 'KHR_materials_sheen', 'sheenRoughnessTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'iridescence',
+    'pbr_iridescenceSampler',
+    'KHR_materials_iridescence.iridescenceTexture',
+    ['extensions', 'KHR_materials_iridescence', 'iridescenceTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'iridescenceThickness',
+    'pbr_iridescenceThicknessSampler',
+    'KHR_materials_iridescence.iridescenceThicknessTexture',
+    ['extensions', 'KHR_materials_iridescence', 'iridescenceThicknessTexture']
+  ),
+  createTextureTransformSlotDefinition(
+    'anisotropy',
+    'pbr_anisotropySampler',
+    'KHR_materials_anisotropy.anisotropyTexture',
+    ['extensions', 'KHR_materials_anisotropy', 'anisotropyTexture']
+  )
+];
+
+const TEXTURE_TRANSFORM_SLOT_DEFINITION_MAP = new Map(
+  TEXTURE_TRANSFORM_SLOT_DEFINITIONS.map(definition => [definition.slot, definition])
+);
+
+function createTextureTransformSlotDefinition(
+  slot: PBRTextureTransformSlot,
+  binding: string,
+  displayName: string,
+  pathSegments: string[]
+): PBRTextureTransformSlotDefinition {
+  return {
+    slot,
+    binding,
+    displayName,
+    pathSegments,
+    uvSetUniform: `${slot}UVSet`,
+    uvTransformUniform: `${slot}UVTransform`
+  };
+}
+
+export function getTextureTransformSlotDefinitions(): PBRTextureTransformSlotDefinition[] {
+  return TEXTURE_TRANSFORM_SLOT_DEFINITIONS;
+}
+
+export function getTextureTransformSlotDefinition(
+  slot: PBRTextureTransformSlot
+): PBRTextureTransformSlotDefinition {
+  const definition = TEXTURE_TRANSFORM_SLOT_DEFINITION_MAP.get(slot);
+  if (!definition) {
+    throw new Error(`Unknown PBR texture transform slot ${slot}`);
+  }
+  return definition;
+}
+
+export function getDefaultTextureTransform(): PBRTextureTransform {
+  return {
+    offset: [...IDENTITY_TEXTURE_TRANSFORM.offset] as [number, number],
+    rotation: IDENTITY_TEXTURE_TRANSFORM.rotation,
+    scale: [...IDENTITY_TEXTURE_TRANSFORM.scale] as [number, number]
+  };
+}
+
+export function resolveTextureTransform(
+  textureInfo: Record<string, any> | undefined
+): PBRTextureTransform {
+  const extensionTextureTransform = textureInfo?.['extensions']?.['KHR_texture_transform'];
+  return {
+    offset: extensionTextureTransform?.offset
+      ? [extensionTextureTransform.offset[0], extensionTextureTransform.offset[1]]
+      : [0, 0],
+    rotation: extensionTextureTransform?.rotation ?? 0,
+    scale: extensionTextureTransform?.scale
+      ? [extensionTextureTransform.scale[0], extensionTextureTransform.scale[1]]
+      : [1, 1]
+  };
+}
+
+export function resolveTextureCoordinateSet(textureInfo: Record<string, any> | undefined): number {
+  const extensionTextureTransform = textureInfo?.['extensions']?.['KHR_texture_transform'];
+  return extensionTextureTransform?.['texCoord'] ?? textureInfo?.['texCoord'] ?? 0;
+}
+
+export function resolveTextureTransformSlot(
+  pointerSegments: string[]
+): PBRTextureTransformSlotDefinition | null {
+  return (
+    TEXTURE_TRANSFORM_SLOT_DEFINITIONS.find(
+      definition =>
+        definition.pathSegments.length === pointerSegments.length &&
+        definition.pathSegments.every((segment, index) => pointerSegments[index] === segment)
+    ) || null
+  );
+}
+
+export function getTextureTransformMatrix(transform: PBRTextureTransform): number[] {
+  const translationMatrix = new Matrix3().set(
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    transform.offset[0],
+    transform.offset[1],
+    1
+  );
+  const rotationMatrix = new Matrix3().set(
+    Math.cos(transform.rotation),
+    Math.sin(transform.rotation),
+    0,
+    -Math.sin(transform.rotation),
+    Math.cos(transform.rotation),
+    0,
+    0,
+    0,
+    1
+  );
+  const scaleMatrix = new Matrix3().set(
+    transform.scale[0],
+    0,
+    0,
+    0,
+    transform.scale[1],
+    0,
+    0,
+    0,
+    1
+  );
+
+  return Array.from(translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix));
+}
+
+export function getTextureTransformDeltaMatrix(
+  baseTransform: PBRTextureTransform,
+  currentTransform: PBRTextureTransform
+): number[] {
+  const baseMatrix = new Matrix3(getTextureTransformMatrix(baseTransform));
+  const currentMatrix = new Matrix3(getTextureTransformMatrix(currentTransform));
+  const inverseBaseMatrix = new Matrix3(baseMatrix).invert();
+  return Array.from(currentMatrix.multiplyRight(inverseBaseMatrix));
+}

package/src/webgl-to-webgpu/convert-webgl-attribute.ts

@@ -5,6 +5,7 @@
 // TODO: convert in loaders.gl?
 import type {TypedArray} from '@math.gl/types';
 
+/** Maps glTF accessor type strings to their component counts. */
 export const ATTRIBUTE_TYPE_TO_COMPONENTS: Record<string, number> = {
   SCALAR: 1,
   VEC2: 2,
@@ -15,6 +16,7 @@ export const ATTRIBUTE_TYPE_TO_COMPONENTS: Record<string, number> = {
   MAT4: 16
 };
 
+/** Maps glTF accessor component-type enums to typed-array constructors. */
 export const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY: Record<number, any> = {
   5120: Int8Array,
   5121: Uint8Array,
@@ -24,16 +26,25 @@ export const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY: Record<number, any> = {
   5126: Float32Array
 };
 
+/** Minimal accessor shape required to materialize a typed array. */
 type GLTFAccessor = {
+  /** Numeric component type enum. */
   componentType: number;
+  /** Accessor type string such as `VEC3` or `SCALAR`. */
   type: string;
+  /** Number of logical elements in the accessor. */
   count: number;
-  bufferView?: {data: {buffer: ArrayBuffer; byteOffset?: number}};
+  /** Buffer view carrying the raw bytes. */
+  bufferView?: {data: {buffer: ArrayBufferLike; byteOffset?: number}};
+  /** Byte offset into the buffer view. */
   byteOffset?: number;
 };
 
+/** Converts a glTF accessor into a typed array plus its component count. */
 export function accessorToTypedArray(accessor: GLTFAccessor): {
+  /** Typed array view over the accessor data. */
   typedArray: TypedArray;
+  /** Number of scalar components per element. */
   components: number;
 } {
   const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];

package/src/webgl-to-webgpu/convert-webgl-sampler.ts

@@ -5,21 +5,27 @@
 // TODO: convert in loaders.gl?
 
 import type {SamplerProps} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GLEnum} from './gltf-webgl-constants';
 
+/** Minimal glTF sampler representation used during conversion. */
 type GLTFSampler = {
-  wrapS?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
-  wrapT?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
-  magFilter?: GL.NEAREST | GL.LINEAR;
+  /** Horizontal wrap mode. */
+  wrapS?: GLEnum.CLAMP_TO_EDGE | GLEnum.REPEAT | GLEnum.MIRRORED_REPEAT;
+  /** Vertical wrap mode. */
+  wrapT?: GLEnum.CLAMP_TO_EDGE | GLEnum.REPEAT | GLEnum.MIRRORED_REPEAT;
+  /** Magnification filter. */
+  magFilter?: GLEnum.NEAREST | GLEnum.LINEAR;
+  /** Minification and mip filter combination. */
   minFilter?:
-    | GL.NEAREST
-    | GL.LINEAR
-    | GL.NEAREST_MIPMAP_NEAREST
-    | GL.LINEAR_MIPMAP_NEAREST
-    | GL.NEAREST_MIPMAP_LINEAR
-    | GL.LINEAR_MIPMAP_LINEAR;
+    | GLEnum.NEAREST
+    | GLEnum.LINEAR
+    | GLEnum.NEAREST_MIPMAP_NEAREST
+    | GLEnum.LINEAR_MIPMAP_NEAREST
+    | GLEnum.NEAREST_MIPMAP_LINEAR
+    | GLEnum.LINEAR_MIPMAP_LINEAR;
 };
 
+/** Converts a glTF sampler into luma.gl sampler props. */
 export function convertSampler(gltfSampler: GLTFSampler): SamplerProps {
   return {
     addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
@@ -29,56 +35,59 @@ export function convertSampler(gltfSampler: GLTFSampler): SamplerProps {
   };
 }
 
+/** Converts a glTF wrap enum into a luma.gl address mode. */
 function convertSamplerWrapMode(
-  mode: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT | undefined
+  mode: GLEnum.CLAMP_TO_EDGE | GLEnum.REPEAT | GLEnum.MIRRORED_REPEAT | undefined
 ): 'clamp-to-edge' | 'repeat' | 'mirror-repeat' | undefined {
   switch (mode) {
-    case GL.CLAMP_TO_EDGE:
+    case GLEnum.CLAMP_TO_EDGE:
       return 'clamp-to-edge';
-    case GL.REPEAT:
+    case GLEnum.REPEAT:
       return 'repeat';
-    case GL.MIRRORED_REPEAT:
+    case GLEnum.MIRRORED_REPEAT:
       return 'mirror-repeat';
     default:
       return undefined;
   }
 }
 
+/** Converts a glTF mag filter enum into a luma.gl mag filter. */
 function convertSamplerMagFilter(
-  mode: GL.NEAREST | GL.LINEAR | undefined
+  mode: GLEnum.NEAREST | GLEnum.LINEAR | undefined
 ): 'nearest' | 'linear' | undefined {
   switch (mode) {
-    case GL.NEAREST:
+    case GLEnum.NEAREST:
       return 'nearest';
-    case GL.LINEAR:
+    case GLEnum.LINEAR:
       return 'linear';
     default:
       return undefined;
   }
 }
 
+/** Converts a glTF min filter enum into luma.gl minification and mipmap filters. */
 function convertSamplerMinFilter(
   mode:
-    | GL.NEAREST
-    | GL.LINEAR
-    | GL.NEAREST_MIPMAP_NEAREST
-    | GL.LINEAR_MIPMAP_NEAREST
-    | GL.NEAREST_MIPMAP_LINEAR
-    | GL.LINEAR_MIPMAP_LINEAR
+    | GLEnum.NEAREST
+    | GLEnum.LINEAR
+    | GLEnum.NEAREST_MIPMAP_NEAREST
+    | GLEnum.LINEAR_MIPMAP_NEAREST
+    | GLEnum.NEAREST_MIPMAP_LINEAR
+    | GLEnum.LINEAR_MIPMAP_LINEAR
     | undefined
 ): {minFilter?: 'nearest' | 'linear'; mipmapFilter?: 'nearest' | 'linear'} {
   switch (mode) {
-    case GL.NEAREST:
+    case GLEnum.NEAREST:
       return {minFilter: 'nearest'};
-    case GL.LINEAR:
+    case GLEnum.LINEAR:
       return {minFilter: 'linear'};
-    case GL.NEAREST_MIPMAP_NEAREST:
+    case GLEnum.NEAREST_MIPMAP_NEAREST:
       return {minFilter: 'nearest', mipmapFilter: 'nearest'};
-    case GL.LINEAR_MIPMAP_NEAREST:
+    case GLEnum.LINEAR_MIPMAP_NEAREST:
       return {minFilter: 'linear', mipmapFilter: 'nearest'};
-    case GL.NEAREST_MIPMAP_LINEAR:
+    case GLEnum.NEAREST_MIPMAP_LINEAR:
       return {minFilter: 'nearest', mipmapFilter: 'linear'};
-    case GL.LINEAR_MIPMAP_LINEAR:
+    case GLEnum.LINEAR_MIPMAP_LINEAR:
       return {minFilter: 'linear', mipmapFilter: 'linear'};
     default:
       return {};

package/src/webgl-to-webgpu/convert-webgl-topology.ts

@@ -3,21 +3,9 @@
 // Copyright (c) vis.gl contributors
 
 import {PrimitiveTopology} from '@luma.gl/core';
+import {GLEnum} from './gltf-webgl-constants';
 
-// NOTE: Modules other than `@luma.gl/webgl` should not import `GL` from
-// `@luma.gl/constants`. Locally we use `GLEnum` instead of `GL` to avoid
-// conflicts with the `babel-plugin-inline-webgl-constants` plugin.
-// eslint-disable-next-line no-shadow
-export enum GLEnum {
-  POINTS = 0x0,
-  LINES = 0x1,
-  LINE_LOOP = 0x2,
-  LINE_STRIP = 0x3,
-  TRIANGLES = 0x4,
-  TRIANGLE_STRIP = 0x5,
-  TRIANGLE_FAN = 0x6
-}
-
+/** Converts a WebGL draw mode into a luma.gl primitive topology string. */
 export function convertGLDrawModeToTopology(
   drawMode:
     | GLEnum.POINTS
@@ -28,7 +16,7 @@ export function convertGLDrawModeToTopology(
     | GLEnum.TRIANGLE_STRIP
     | GLEnum.TRIANGLE_FAN
 ): PrimitiveTopology {
-  // prettier-ignore
+  // biome-ignore format: preserve layout
   switch (drawMode) {
     case GLEnum.POINTS: return 'point-list';
     case GLEnum.LINES: return 'line-list';

package/src/webgl-to-webgpu/gltf-webgl-constants.ts

@@ -0,0 +1,35 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// NOTE: `@luma.gl/gltf` intentionally keeps this as a local enum subset so it
+// does not need to depend on `@luma.gl/webgl` for a handful of stable WebGL values.
+// eslint-disable-next-line no-shadow
+export enum GLEnum {
+  POINTS = 0x0,
+  LINES = 0x1,
+  LINE_LOOP = 0x2,
+  LINE_STRIP = 0x3,
+  TRIANGLES = 0x4,
+  TRIANGLE_STRIP = 0x5,
+  TRIANGLE_FAN = 0x6,
+
+  ONE = 1,
+  SRC_ALPHA = 0x0302,
+  ONE_MINUS_SRC_ALPHA = 0x0303,
+  FUNC_ADD = 0x8006,
+
+  LINEAR = 0x2601,
+  NEAREST = 0x2600,
+  NEAREST_MIPMAP_NEAREST = 0x2700,
+  LINEAR_MIPMAP_NEAREST = 0x2701,
+  NEAREST_MIPMAP_LINEAR = 0x2702,
+  LINEAR_MIPMAP_LINEAR = 0x2703,
+  TEXTURE_MIN_FILTER = 0x2801,
+  TEXTURE_WRAP_S = 0x2802,
+  TEXTURE_WRAP_T = 0x2803,
+  REPEAT = 0x2901,
+  CLAMP_TO_EDGE = 0x812f,
+  MIRRORED_REPEAT = 0x8370,
+  UNPACK_FLIP_Y_WEBGL = 0x9240
+}

package/dist/utils/deep-copy.d.ts

@@ -1,3 +0,0 @@
-/** Deeply copies a JS data structure */
-export declare function deepCopy(object: any): any;
-//# sourceMappingURL=deep-copy.d.ts.map

package/dist/utils/deep-copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-copy.d.ts","sourceRoot":"","sources":["../../src/utils/deep-copy.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,wBAAgB,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAoBzC"}

package/dist/utils/deep-copy.js

@@ -1,21 +0,0 @@
-/** Deeply copies a JS data structure */
-export function deepCopy(object) {
-    // don't copy binary data
-    if (ArrayBuffer.isView(object) ||
-        object instanceof ArrayBuffer ||
-        object instanceof ImageBitmap) {
-        return object;
-    }
-    if (Array.isArray(object)) {
-        return object.map(deepCopy);
-    }
-    if (object && typeof object === 'object') {
-        const result = {};
-        for (const key in object) {
-            result[key] = deepCopy(object[key]);
-        }
-        return result;
-    }
-    return object;
-}
-//# sourceMappingURL=deep-copy.js.map

package/dist/utils/deep-copy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-copy.js","sourceRoot":"","sources":["../../src/utils/deep-copy.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,MAAM,UAAU,QAAQ,CAAC,MAAW;IAClC,yBAAyB;IACzB,IACE,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC;QAC1B,MAAM,YAAY,WAAW;QAC7B,MAAM,YAAY,WAAW,EAC7B,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IACD,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QACzC,MAAM,MAAM,GAAkB,EAAE,CAAC;QACjC,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}