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

package/src/gltf/animations/interpolate.ts

@@ -1,15 +1,36 @@
-import {GLTFNodePostprocessed} from '@loaders.gl/gltf';
 import {log} from '@luma.gl/core';
 import {Quaternion} from '@math.gl/core';
-import {GLTFAnimationChannel, GLTFAnimationSampler} from './animations';
+import {GLTFAnimationPath, GLTFAnimationSampler} from './animations';
+import {GroupNode} from '@luma.gl/engine';
 
-const scratchQuaternion = new Quaternion();
+/** Applies an evaluated animation value to a scenegraph node. */
+function updateTargetPath(
+  target: GroupNode,
+  path: GLTFAnimationPath,
+  newValue: number[]
+): GroupNode | null {
+  switch (path) {
+    case 'translation':
+      return target.setPosition(newValue).updateMatrix();
 
+    case 'rotation':
+      return target.setRotation(newValue).updateMatrix();
+
+    case 'scale':
+      return target.setScale(newValue).updateMatrix();
+
+    default:
+      log.warn(`Bad animation path ${path}`)();
+      return null;
+  }
+}
+
+/** Evaluates a glTF animation sampler at the supplied time and applies the result to a node. */
 export function interpolate(
   time: number,
   {input, interpolation, output}: GLTFAnimationSampler,
-  target: GLTFNodePostprocessed,
-  path: GLTFAnimationChannel['path']
+  target: GroupNode,
+  path: GLTFAnimationPath
 ) {
   const maxTime = input[input.length - 1];
   const animationTime = time % maxTime;
@@ -17,44 +38,18 @@ export function interpolate(
   const nextIndex = input.findIndex(t => t >= animationTime);
   const previousIndex = Math.max(0, nextIndex - 1);
 
-  if (!Array.isArray(target[path])) {
-    switch (path) {
-      case 'translation':
-        target[path] = [0, 0, 0];
-        break;
-
-      case 'rotation':
-        target[path] = [0, 0, 0, 1];
-        break;
-
-      case 'scale':
-        target[path] = [1, 1, 1];
-        break;
-
-      default:
-        log.warn(`Bad animation path ${path}`)();
-    }
-  }
-
-  // assert(target[path].length === output[previousIndex].length);
   const previousTime = input[previousIndex];
   const nextTime = input[nextIndex];
 
   switch (interpolation) {
     case 'STEP':
-      stepInterpolate(target, path, output[previousIndex] as number[]);
+      stepInterpolate(target, path, output[previousIndex]);
       break;
 
     case 'LINEAR':
       if (nextTime > previousTime) {
         const ratio = (animationTime - previousTime) / (nextTime - previousTime);
-        linearInterpolate(
-          target,
-          path,
-          output[previousIndex] as number[],
-          output[nextIndex] as number[],
-          ratio
-        );
+        linearInterpolate(target, path, output[previousIndex], output[nextIndex], ratio);
       }
       break;
 
@@ -63,10 +58,10 @@ export function interpolate(
         const ratio = (animationTime - previousTime) / (nextTime - previousTime);
         const tDiff = nextTime - previousTime;
 
-        const p0 = output[3 * previousIndex + 1] as number[];
-        const outTangent0 = output[3 * previousIndex + 2] as number[];
-        const inTangent1 = output[3 * nextIndex + 0] as number[];
-        const p1 = output[3 * nextIndex + 1] as number[];
+        const p0 = output[3 * previousIndex + 1];
+        const outTangent0 = output[3 * previousIndex + 2];
+        const inTangent1 = output[3 * nextIndex + 0];
+        const p1 = output[3 * nextIndex + 1];
 
         cubicsplineInterpolate(target, path, {p0, outTangent0, inTangent1, p1, tDiff, ratio});
       }
@@ -78,34 +73,31 @@ export function interpolate(
   }
 }
 
+/** Applies linear interpolation between two keyframes. */
 function linearInterpolate(
-  target: GLTFNodePostprocessed,
-  path: GLTFAnimationChannel['path'],
+  target: GroupNode,
+  path: GLTFAnimationPath,
   start: number[],
   stop: number[],
   ratio: number
 ) {
-  if (!target[path]) {
-    throw new Error();
-  }
-
   if (path === 'rotation') {
     // SLERP when path is rotation
-    scratchQuaternion.slerp({start, target: stop, ratio});
-    for (let i = 0; i < scratchQuaternion.length; i++) {
-      target[path][i] = scratchQuaternion[i];
-    }
+    updateTargetPath(target, path, new Quaternion().slerp({start, target: stop, ratio}));
   } else {
     // regular interpolation
+    const newVal = [];
     for (let i = 0; i < start.length; i++) {
-      target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
+      newVal[i] = ratio * stop[i] + (1 - ratio) * start[i];
     }
+    updateTargetPath(target, path, newVal);
   }
 }
 
+/** Applies glTF cubic spline interpolation between two keyframes. */
 function cubicsplineInterpolate(
-  target: GLTFNodePostprocessed,
-  path: GLTFAnimationChannel['path'],
+  target: GroupNode,
+  path: GLTFAnimationPath,
   {
     p0,
     outTangent0,
@@ -122,32 +114,21 @@ function cubicsplineInterpolate(
     ratio: number;
   }
 ) {
-  if (!target[path]) {
-    throw new Error();
-  }
-
   // TODO: Quaternion might need normalization
-  for (let i = 0; i < target[path].length; i++) {
+  const newVal = [];
+  for (let i = 0; i < p0.length; i++) {
     const m0 = outTangent0[i] * tDiff;
     const m1 = inTangent1[i] * tDiff;
-    target[path][i] =
+    newVal[i] =
       (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] +
       (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 +
       (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] +
       (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
   }
+  updateTargetPath(target, path, newVal);
 }
 
-function stepInterpolate(
-  target: GLTFNodePostprocessed,
-  path: GLTFAnimationChannel['path'],
-  value: number[]
-) {
-  if (!target[path]) {
-    throw new Error();
-  }
-
-  for (let i = 0; i < value.length; i++) {
-    target[path][i] = value[i];
-  }
+/** Applies step interpolation by copying the current keyframe value. */
+function stepInterpolate(target: GroupNode, path: GLTFAnimationPath, value: number[]) {
+  updateTargetPath(target, path, value);
 }

package/src/gltf/create-gltf-model.ts

@@ -2,56 +2,111 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Device, type RenderPipelineParameters, log} from '@luma.gl/core';
-import {pbrMaterial, ShaderModule} from '@luma.gl/shadertools';
-import {Geometry, Model, ModelNode, type ModelProps} from '@luma.gl/engine';
+import {
+  Buffer,
+  Device,
+  Sampler,
+  Texture,
+  TextureView,
+  type Binding,
+  type RenderPipelineParameters,
+  log
+} from '@luma.gl/core';
+import {DynamicTexture} from '@luma.gl/engine';
+import {pbrMaterial, skin} from '@luma.gl/shadertools';
+import {
+  Geometry,
+  Material,
+  MaterialFactory,
+  Model,
+  ModelNode,
+  type ModelProps
+} from '@luma.gl/engine';
 import {type ParsedPBRMaterial} from '../pbr/pbr-material';
 
 const SHADER = /* WGSL */ `
-layout(0) positions: vec4; // in vec4 POSITION;
-
-  #ifdef HAS_NORMALS
-    in vec4 normals; // in vec4 NORMAL;
-  #endif
-
-  #ifdef HAS_TANGENTS
-    in vec4 TANGENT;
-  #endif
+struct VertexInputs {
+  @location(0) positions: vec3f,
+#ifdef HAS_NORMALS
+  @location(1) normals: vec3f,
+#endif
+#ifdef HAS_TANGENTS
+  @location(2) TANGENT: vec4f,
+#endif
+#ifdef HAS_UV
+  @location(3) texCoords: vec2f,
+#endif
+#ifdef HAS_SKIN
+  @location(4) JOINTS_0: vec4u,
+  @location(5) WEIGHTS_0: vec4f,
+#endif
+};
 
-  #ifdef HAS_UV
-    // in vec2 TEXCOORD_0;
-    in vec2 texCoords;
-  #endif
+struct FragmentInputs {
+  @builtin(position) position: vec4f,
+  @location(0) pbrPosition: vec3f,
+  @location(1) pbrUV: vec2f,
+  @location(2) pbrNormal: vec3f,
+#ifdef HAS_TANGENTS
+  @location(3) pbrTangent: vec4f,
+#endif
+};
 
 @vertex
-  void main(void) {
-    vec4 _NORMAL = vec4(0.);
-    vec4 _TANGENT = vec4(0.);
-    vec2 _TEXCOORD_0 = vec2(0.);
-
-    #ifdef HAS_NORMALS
-      _NORMAL = normals;
-    #endif
-
-    #ifdef HAS_TANGENTS
-      _TANGENT = TANGENT;
-    #endif
-
-    #ifdef HAS_UV
-      _TEXCOORD_0 = texCoords;
-    #endif
-
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = u_MVPMatrix * positions;
-  }
+fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
+  var outputs: FragmentInputs;
+  var position = vec4f(inputs.positions, 1.0);
+  var normal = vec3f(0.0, 0.0, 1.0);
+  var tangent = vec4f(1.0, 0.0, 0.0, 1.0);
+  var uv = vec2f(0.0, 0.0);
+
+#ifdef HAS_NORMALS
+  normal = inputs.normals;
+#endif
+#ifdef HAS_UV
+  uv = inputs.texCoords;
+#endif
+#ifdef HAS_TANGENTS
+  tangent = inputs.TANGENT;
+#endif
+#ifdef HAS_SKIN
+  let skinMatrix = getSkinMatrix(inputs.WEIGHTS_0, inputs.JOINTS_0);
+  position = skinMatrix * position;
+  normal = normalize((skinMatrix * vec4f(normal, 0.0)).xyz);
+#ifdef HAS_TANGENTS
+  tangent = vec4f(normalize((skinMatrix * vec4f(tangent.xyz, 0.0)).xyz), tangent.w);
+#endif
+#endif
+
+  let worldPosition = pbrProjection.modelMatrix * position;
+
+#ifdef HAS_NORMALS
+  normal = normalize((pbrProjection.normalMatrix * vec4f(normal, 0.0)).xyz);
+#endif
+#ifdef HAS_TANGENTS
+  let worldTangent = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
+  outputs.pbrTangent = vec4f(worldTangent, tangent.w);
+#endif
+
+  outputs.position = pbrProjection.modelViewProjectionMatrix * position;
+  outputs.pbrPosition = worldPosition.xyz / worldPosition.w;
+  outputs.pbrUV = uv;
+  outputs.pbrNormal = normal;
+  return outputs;
+}
 
 @fragment
-  out vec4 fragmentColor;
-
-  void main(void) {
-    vec3 pos = pbr_vPosition;
-    fragmentColor = pbr_filterColor(vec4(1.0));
-  }
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
+  fragmentInputs.pbr_vPosition = inputs.pbrPosition;
+  fragmentInputs.pbr_vUV = inputs.pbrUV;
+  fragmentInputs.pbr_vNormal = inputs.pbrNormal;
+#ifdef HAS_TANGENTS
+  let tangent = normalize(inputs.pbrTangent.xyz);
+  let bitangent = normalize(cross(inputs.pbrNormal, tangent)) * inputs.pbrTangent.w;
+  fragmentInputs.pbr_vTBN = mat3x3f(tangent, bitangent, inputs.pbrNormal);
+#endif
+  return pbr_filterColor(vec4f(1.0));
+}
 `;
 
 // TODO rename attributes to POSITION/NORMAL etc
@@ -76,6 +131,11 @@ const vs = /* glsl */ `\
     in vec2 texCoords;
   #endif
 
+  #ifdef HAS_SKIN
+    in uvec4 JOINTS_0;
+    in vec4 WEIGHTS_0;
+  #endif
+
   void main(void) {
     vec4 _NORMAL = vec4(0.);
     vec4 _TANGENT = vec4(0.);
@@ -93,8 +153,17 @@ const vs = /* glsl */ `\
       _TEXCOORD_0 = texCoords;
     #endif
 
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
+    vec4 pos = positions;
+
+    #ifdef HAS_SKIN
+      mat4 skinMat = getSkinMatrix(WEIGHTS_0, JOINTS_0);
+      pos = skinMat * pos;
+      _NORMAL = skinMat * _NORMAL;
+      _TANGENT = vec4((skinMat * vec4(_TANGENT.xyz, 0.)).xyz, _TANGENT.w);
+    #endif
+
+    pbr_setPositionNormalTangentUV(pos, _NORMAL, _TANGENT, _TEXCOORD_0);
+    gl_Position = pbrProjection.modelViewProjectionMatrix * pos;
   }
 `;
 
@@ -108,14 +177,52 @@ const fs = /* glsl */ `\
   }
 `;
 
+/** Options used to instantiate a `ModelNode` for one glTF primitive. */
 export type CreateGLTFModelOptions = {
+  /** Optional id assigned to the generated model. */
   id?: string;
+  /** Vertex count override for non-indexed primitives. */
   vertexCount?: number;
+  /** Geometry converted from the glTF primitive. */
   geometry: Geometry;
+  /** Parsed PBR material state for the primitive. */
   parsedPPBRMaterial: ParsedPBRMaterial;
+  /** Pre-created material aligned with the source glTF material entry, when available. */
+  material?: Material | null;
+  /** Additional model props merged into the generated model. */
   modelOptions?: Partial<ModelProps>;
 };
 
+export type CreateGLTFMaterialOptions = {
+  id?: string;
+  parsedPPBRMaterial: ParsedPBRMaterial;
+  materialFactory?: MaterialFactory;
+};
+
+export function createGLTFMaterial(device: Device, options: CreateGLTFMaterialOptions): Material {
+  const materialFactory =
+    options.materialFactory || new MaterialFactory(device, {modules: [pbrMaterial]});
+
+  const pbrMaterialProps = {...options.parsedPPBRMaterial.uniforms};
+  delete pbrMaterialProps.camera;
+  const materialBindings = Object.fromEntries(
+    Object.entries({
+      ...pbrMaterialProps,
+      ...options.parsedPPBRMaterial.bindings
+    }).filter(
+      ([name, value]) => materialFactory.ownsBinding(name) && isMaterialBindingResource(value)
+    )
+  ) as Record<string, Binding | DynamicTexture>;
+
+  const material = materialFactory.createMaterial({
+    id: options.id,
+    bindings: materialBindings
+  });
+  material.setProps({pbrMaterial: pbrMaterialProps});
+
+  return material;
+}
+
 /** Creates a luma.gl Model from GLTF data*/
 export function createGLTFModel(device: Device, options: CreateGLTFModelOptions): ModelNode {
   const {id, geometry, parsedPPBRMaterial, vertexCount, modelOptions = {}} = options;
@@ -144,22 +251,81 @@ export function createGLTFModel(device: Device, options: CreateGLTFModelOptions)
     geometry,
     topology: geometry.topology,
     vertexCount,
-    modules: [pbrMaterial as unknown as ShaderModule],
+    modules: [pbrMaterial, skin],
     ...modelOptions,
 
     defines: {...parsedPPBRMaterial.defines, ...modelOptions.defines},
     parameters: {...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters}
   };
 
+  const material =
+    options.material ||
+    createGLTFMaterial(device, {
+      id: id ? `${id}-material` : undefined,
+      parsedPPBRMaterial
+    });
+  modelProps.material = material;
+
   const model = new Model(device, modelProps);
 
-  const {camera, ...pbrMaterialProps} = {
+  const sceneShaderInputValues = {
     ...parsedPPBRMaterial.uniforms,
     ...modelOptions.uniforms,
     ...parsedPPBRMaterial.bindings,
     ...modelOptions.bindings
   };
-
-  model.shaderInputs.setProps({pbrMaterial: pbrMaterialProps, pbrProjection: {camera}});
+  const sceneShaderInputProps = getSceneShaderInputProps(
+    model.shaderInputs.getModules(),
+    material,
+    sceneShaderInputValues
+  );
+  model.shaderInputs.setProps(sceneShaderInputProps);
   return new ModelNode({managedResources, model});
 }
+
+function isMaterialBindingResource(value: unknown): boolean {
+  return (
+    value instanceof Buffer ||
+    value instanceof DynamicTexture ||
+    value instanceof Sampler ||
+    value instanceof Texture ||
+    value instanceof TextureView
+  );
+}
+
+function getSceneShaderInputProps(
+  modules: Array<{
+    name: string;
+    uniformTypes?: Readonly<Record<string, unknown>>;
+    bindingLayout?: ReadonlyArray<{name: string}>;
+  }>,
+  material: Material,
+  shaderInputValues: Record<string, unknown>
+): Record<string, Record<string, unknown>> {
+  const propertyToModuleNameMap = new Map<string, string>();
+  for (const module of modules) {
+    for (const uniformName of Object.keys(module.uniformTypes || {})) {
+      propertyToModuleNameMap.set(uniformName, module.name);
+    }
+    for (const binding of module.bindingLayout || []) {
+      propertyToModuleNameMap.set(binding.name, module.name);
+    }
+  }
+
+  const sceneShaderInputProps: Record<string, Record<string, unknown>> = {};
+  for (const [propertyName, value] of Object.entries(shaderInputValues)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    const moduleName = propertyToModuleNameMap.get(propertyName);
+    if (!moduleName || material.ownsModule(moduleName)) {
+      continue;
+    }
+
+    sceneShaderInputProps[moduleName] ||= {};
+    sceneShaderInputProps[moduleName][propertyName] = value;
+  }
+
+  return sceneShaderInputProps;
+}

package/src/gltf/create-scenegraph-from-gltf.ts

@@ -3,25 +3,148 @@
 // Copyright (c) vis.gl contributors
 
 import {Device} from '@luma.gl/core';
-import {GroupNode} from '@luma.gl/engine';
+import {GroupNode, Material} from '@luma.gl/engine';
 import {GLTFPostprocessed} from '@loaders.gl/gltf';
+import {Light} from '@luma.gl/shadertools';
 import {parseGLTF, type ParseGLTFOptions} from '../parsers/parse-gltf';
+import {parseGLTFLights} from '../parsers/parse-gltf-lights';
 import {GLTFAnimator} from './gltf-animator';
 import {parseGLTFAnimations} from '../parsers/parse-gltf-animations';
-import {deepCopy} from '../utils/deep-copy';
+import {getGLTFExtensionSupport, type GLTFExtensionSupport} from './gltf-extension-support';
 
+export type GLTFScenegraphBounds = {
+  /** World-space axis-aligned bounds for the scene or model. */
+  bounds: [[number, number, number], [number, number, number]] | null;
+  /** World-space center of the bounds. */
+  center: [number, number, number];
+  /** World-space bounds size on each axis. */
+  size: [number, number, number];
+  /** Half of the world-space bounds diagonal, clamped to a small practical minimum. */
+  radius: number;
+  /** Suggested orbit distance for a 60-degree field of view camera. */
+  recommendedOrbitDistance: number;
+};
+
+/** Scenegraph bundle returned from a parsed glTF asset. */
+export type GLTFScenegraphs = {
+  /** Scene roots produced from the glTF scenes array. */
+  scenes: GroupNode[];
+  /** Materials aligned with the source glTF `materials` array. */
+  materials: Material[];
+  /** Animation controller for glTF animations. */
+  animator: GLTFAnimator;
+  /** Parsed punctual lights from the asset. */
+  lights: Light[];
+  /** Extensions reported by the asset and whether luma.gl supports them. */
+  extensionSupport: Map<string, GLTFExtensionSupport>;
+  /** Camera-friendly bounds for each scene in `scenes`, in matching order. */
+  sceneBounds: GLTFScenegraphBounds[];
+  /** Combined camera-friendly bounds for the entire loaded asset. */
+  modelBounds: GLTFScenegraphBounds;
+
+  /** Map from glTF mesh ids to generated mesh group nodes. */
+  gltfMeshIdToNodeMap: Map<string, GroupNode>;
+  /** Map from glTF node indices to generated scenegraph nodes. */
+  gltfNodeIndexToNodeMap: Map<number, GroupNode>;
+  /** Map from glTF node ids to generated scenegraph nodes. */
+  gltfNodeIdToNodeMap: Map<string, GroupNode>;
+
+  /** Original post-processed glTF document. */
+  gltf: GLTFPostprocessed;
+};
+
+/** Converts a post-processed glTF asset into luma.gl scenegraph nodes and animation helpers. */
 export function createScenegraphsFromGLTF(
   device: Device,
   gltf: GLTFPostprocessed,
   options?: ParseGLTFOptions
-): {
-  scenes: GroupNode[];
-  animator: GLTFAnimator;
-} {
-  gltf = deepCopy(gltf);
-  const scenes = parseGLTF(device, gltf, options);
-  // Note: There is a nasty dependency on injected nodes in the glTF
+): GLTFScenegraphs {
+  const {scenes, materials, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap} =
+    parseGLTF(device, gltf, options);
+
   const animations = parseGLTFAnimations(gltf);
-  const animator = new GLTFAnimator({animations});
-  return {scenes, animator};
+  const animator = new GLTFAnimator({animations, gltfNodeIdToNodeMap});
+  const lights = parseGLTFLights(gltf);
+  const extensionSupport = getGLTFExtensionSupport(gltf);
+  const sceneBounds = scenes.map(scene => getScenegraphBounds(scene.getBounds()));
+  const modelBounds = getCombinedScenegraphBounds(sceneBounds);
+
+  return {
+    scenes,
+    materials,
+    animator,
+    lights,
+    extensionSupport,
+    sceneBounds,
+    modelBounds,
+    gltfMeshIdToNodeMap,
+    gltfNodeIdToNodeMap,
+    gltfNodeIndexToNodeMap,
+    gltf
+  };
+}
+
+function getScenegraphBounds(bounds: [number[], number[]] | null): GLTFScenegraphBounds {
+  if (!bounds) {
+    return {
+      bounds: null,
+      center: [0, 0, 0],
+      size: [0, 0, 0],
+      radius: 0.5,
+      recommendedOrbitDistance: 1
+    };
+  }
+
+  const normalizedBounds: [[number, number, number], [number, number, number]] = [
+    [bounds[0][0], bounds[0][1], bounds[0][2]],
+    [bounds[1][0], bounds[1][1], bounds[1][2]]
+  ];
+  const size: [number, number, number] = [
+    normalizedBounds[1][0] - normalizedBounds[0][0],
+    normalizedBounds[1][1] - normalizedBounds[0][1],
+    normalizedBounds[1][2] - normalizedBounds[0][2]
+  ];
+  const center: [number, number, number] = [
+    normalizedBounds[0][0] + size[0] * 0.5,
+    normalizedBounds[0][1] + size[1] * 0.5,
+    normalizedBounds[0][2] + size[2] * 0.5
+  ];
+  const maxHalfExtent = Math.max(size[0], size[1], size[2]) * 0.5;
+  const radius = Math.max(0.5 * Math.hypot(size[0], size[1], size[2]), 0.001);
+
+  return {
+    bounds: normalizedBounds,
+    center,
+    size,
+    radius,
+    recommendedOrbitDistance: Math.max(
+      (Math.max(maxHalfExtent, 0.001) / Math.tan(Math.PI / 6)) * 1.15,
+      radius * 1.1
+    )
+  };
+}
+
+function getCombinedScenegraphBounds(sceneBounds: GLTFScenegraphBounds[]): GLTFScenegraphBounds {
+  let combinedBounds: [[number, number, number], [number, number, number]] | null = null;
+
+  for (const sceneBoundInfo of sceneBounds) {
+    if (!sceneBoundInfo.bounds) {
+      continue;
+    }
+
+    if (!combinedBounds) {
+      combinedBounds = [
+        [...sceneBoundInfo.bounds[0]] as [number, number, number],
+        [...sceneBoundInfo.bounds[1]] as [number, number, number]
+      ];
+      continue;
+    }
+
+    for (let axis = 0; axis < 3; axis++) {
+      combinedBounds[0][axis] = Math.min(combinedBounds[0][axis], sceneBoundInfo.bounds[0][axis]);
+      combinedBounds[1][axis] = Math.max(combinedBounds[1][axis], sceneBoundInfo.bounds[1][axis]);
+    }
+  }
+
+  return getScenegraphBounds(combinedBounds);
 }