@luma.gl/gltf 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/pbr/pbr-environment.ts

@@ -3,7 +3,12 @@
 // Copyright (c) vis.gl contributors
 
 import {Device, SamplerProps} from '@luma.gl/core';
-import {DynamicTexture} 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 */
@@ -28,6 +33,8 @@ export type PBREnvironmentProps = {
 
 /** Loads textures for PBR environment */
 export function loadPBREnvironment(device: Device, props: PBREnvironmentProps): PBREnvironment {
+  const specularMipLevels = props.specularMipLevels ?? 1;
+
   const brdfLutTexture = new DynamicTexture(device, {
     id: 'brdfLUT',
     sampler: {
@@ -42,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',
@@ -53,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',
@@ -77,7 +87,7 @@ 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(
@@ -89,23 +99,26 @@ function makeCube(
   }: {
     /** Debug id assigned to the created texture. */
     id: string;
-    /** Returns the image promise or mip-array promises for one cubemap face. */
-    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;
   }
 ): DynamicTexture {
-  const data = {};
-  FACES.forEach(face => {
-    // @ts-ignore TODO
-    data[String(face)] = getTextureForFace(face);
+  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 DynamicTexture(device, {
     id,
     dimension: 'cube',
     mipmaps: false,
     sampler,
-    // @ts-expect-error
     data
   });
 }

package/src/pbr/pbr-material.ts

@@ -1,14 +1,24 @@
 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>;
   /** Texture and sampler bindings for the PBR shader module. */
-  readonly bindings: Partial<PBRMaterialBindings>;
+  readonly bindings: Partial<PBRMaterialBindings & IBLBindings>;
   /** Uniform values for the projection and PBR shader modules. */
-  readonly uniforms: Partial<PBRProjectionProps & PBRMaterialUniforms>;
+  readonly uniforms: ParsedPBRMaterialUniforms;
   /** Render pipeline parameters derived from the glTF material. */
   readonly parameters: Parameters;
   /** @deprecated Use parameters */

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

@@ -5,24 +5,24 @@
 // 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 = {
   /** Horizontal wrap mode. */
-  wrapS?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
+  wrapS?: GLEnum.CLAMP_TO_EDGE | GLEnum.REPEAT | GLEnum.MIRRORED_REPEAT;
   /** Vertical wrap mode. */
-  wrapT?: GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT;
+  wrapT?: GLEnum.CLAMP_TO_EDGE | GLEnum.REPEAT | GLEnum.MIRRORED_REPEAT;
   /** Magnification filter. */
-  magFilter?: GL.NEAREST | GL.LINEAR;
+  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. */
@@ -37,14 +37,14 @@ 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;
@@ -53,12 +53,12 @@ function convertSamplerWrapMode(
 
 /** 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;
@@ -68,26 +68,26 @@ function convertSamplerMagFilter(
 /** 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,7 @@
 // Copyright (c) vis.gl contributors
 
 import {PrimitiveTopology} from '@luma.gl/core';
-
-// 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
-/** Minimal WebGL draw-mode enum subset used by the glTF converter. */
-export enum GLEnum {
-  POINTS = 0x0,
-  LINES = 0x1,
-  LINE_LOOP = 0x2,
-  LINE_STRIP = 0x3,
-  TRIANGLES = 0x4,
-  TRIANGLE_STRIP = 0x5,
-  TRIANGLE_FAN = 0x6
-}
+import {GLEnum} from './gltf-webgl-constants';
 
 /** Converts a WebGL draw mode into a luma.gl primitive topology string. */
 export function convertGLDrawModeToTopology(

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
+}