@npm9912/v-map 0.1.0

package/dist/cjs/scenegraph-layer-DwNoxQdi.js

@@ -0,0 +1,2530 @@
+'use strict';
+
+var gltf = require('@loaders.gl/gltf');
+var deckProvider = require('./deck-provider-Ctq3Q8a1.js');
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Attribution:
+// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors
+// This fragment shader defines a reference implementation for Physically Based Shading of
+// a microfacet surface material defined by a glTF model.
+// TODO - better do the checks outside of shader
+const vs$2 = /* glsl */ `\
+out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
+
+#ifdef HAS_NORMALS
+# ifdef HAS_TANGENTS
+out mat3 pbr_vTBN;
+# else
+out vec3 pbr_vNormal;
+# endif
+#endif
+
+void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+{
+  vec4 pos = pbrProjection.modelMatrix * position;
+  pbr_vPosition = vec3(pos.xyz) / pos.w;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
+  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+#else // HAS_TANGENTS != 1
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+#endif
+#endif
+
+#ifdef HAS_UV
+  pbr_vUV = uv;
+#else
+  pbr_vUV = vec2(0.,0.);
+#endif
+}
+`;
+const fs$2 = /* glsl */ `\
+precision highp float;
+
+uniform pbrMaterialUniforms {
+  // Material is unlit
+  bool unlit;
+
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
+
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
+
+  bool emissiveMapEnabled;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+
+  vec2 metallicRoughnessValues;
+  bool metallicRoughnessMapEnabled;
+
+  bool occlusionMapEnabled;
+  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
+  
+  bool alphaCutoffEnabled;
+  float alphaCutoff; // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  bool IBLenabled;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  vec4 scaleDiffBaseMR;
+  vec4 scaleFGDSpec;
+  // #endif
+} pbrMaterial;
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D pbr_normalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D pbr_emissiveSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D pbr_metallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D pbr_occlusionSampler;
+#endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+
+// Inputs from vertex shader
+
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+in mat3 pbr_vTBN;
+#else
+in vec3 pbr_vNormal;
+#endif
+#endif
+
+// Encapsulate the various inputs used by the various functions in the shading equation
+// We store values in this struct to simplify the integration of alternative implementations
+// of the shading terms, outlined in the Readme.MD Appendix.
+struct PBRInfo {
+  float NdotL;                  // cos angle between normal and light direction
+  float NdotV;                  // cos angle between normal and view direction
+  float NdotH;                  // cos angle between normal and half vector
+  float LdotH;                  // cos angle between light direction and half vector
+  float VdotH;                  // cos angle between view direction and half vector
+  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
+  float metalness;              // metallic value at the surface
+  vec3 reflectance0;            // full reflectance color (normal incidence angle)
+  vec3 reflectance90;           // reflectance color at grazing angle
+  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  vec3 diffuseColor;            // color contribution from diffuse lighting
+  vec3 specularColor;           // color contribution from specular lighting
+  vec3 n;                       // normal at surface point
+  vec3 v;                       // vector from surface point to camera
+};
+
+const float M_PI = 3.141592653589793;
+const float c_MinRoughness = 0.04;
+
+vec4 SRGBtoLINEAR(vec4 srgbIn)
+{
+#ifdef MANUAL_SRGB
+#ifdef SRGB_FAST_APPROXIMATION
+  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
+  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+vec3 getNormal()
+{
+  // Retrieve the tangent space matrix
+#ifndef HAS_TANGENTS
+  vec3 pos_dx = dFdx(pbr_vPosition);
+  vec3 pos_dy = dFdy(pbr_vPosition);
+  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
+  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
+  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+
+#ifdef HAS_NORMALS
+  vec3 ng = normalize(pbr_vNormal);
+#else
+  vec3 ng = cross(pos_dx, pos_dy);
+#endif
+
+  t = normalize(t - ng * dot(ng, t));
+  vec3 b = normalize(cross(ng, t));
+  mat3 tbn = mat3(t, b, ng);
+#else // HAS_TANGENTS
+  mat3 tbn = pbr_vTBN;
+#endif
+
+#ifdef HAS_NORMALMAP
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+#else
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
+#endif
+
+  return n;
+}
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
+{
+  float mipCount = 9.0; // resolution of 512x512
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
+
+#ifdef USE_TEX_LOD
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
+#else
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+#endif
+
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
+
+  return diffuse + specular;
+}
+#endif
+
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
+vec3 diffuse(PBRInfo pbrInfo)
+{
+  return pbrInfo.diffuseColor / M_PI;
+}
+
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
+vec3 specularReflection(PBRInfo pbrInfo)
+{
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+}
+
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
+float geometricOcclusion(PBRInfo pbrInfo)
+{
+  float NdotL = pbrInfo.NdotL;
+  float NdotV = pbrInfo.NdotV;
+  float r = pbrInfo.alphaRoughness;
+
+  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
+}
+
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
+float microfacetDistribution(PBRInfo pbrInfo)
+{
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (M_PI * f * f);
+}
+
+void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
+}
+
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 h = normalize(l+v);                        // Half vector between both l and v
+
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+}
+
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
+  // Calculate the shading terms for the microfacet specular shading model
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+}
+
+vec4 pbr_filterColor(vec4 colorUnused)
+{
+  // The albedo may be defined from a base texture or a flat color
+#ifdef HAS_BASECOLORMAP
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+#else
+  vec4 baseColor = pbrMaterial.baseColorFactor;
+#endif
+
+#ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+#endif
+
+  vec3 color = vec3(0, 0, 0);
+
+  if(pbrMaterial.unlit){
+    color.rgb = baseColor.rgb;
+  }
+  else{
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
+#ifdef HAS_METALROUGHNESSMAP
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+#endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    vec3 f0 = vec3(0.04);
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+    diffuseColor *= 1.0 - metallic;
+    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+    // Compute reflectance.
+    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflecance to 0%.
+    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    vec3 specularEnvironmentR0 = specularColor.rgb;
+    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+
+    vec3 n = getNormal();                          // normal at surface point
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+
+    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    vec3 reflection = -normalize(reflect(v, n));
+
+    PBRInfo pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v
+    );
+
+
+#ifdef USE_LIGHTS
+    // Apply ambient light
+    PBRInfo_setAmbientLight(pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+    // Apply directional light
+    for(int i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+      }
+    }
+
+    // Apply point light
+    for(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+      }
+    }
+#endif
+
+    // Calculate lighting contribution from image based lighting source (IBL)
+#ifdef USE_IBL
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
+#endif
+
+ // Apply optional PBR terms for additional (optional) shading
+#ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+#endif
+
+#ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
+#endif
+
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
+#ifdef PBR_DEBUG
+    // TODO: Figure out how to debug multiple lights
+
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
+
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+  }
+
+  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+}
+`;
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Attribution:
+// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors
+// This fragment shader defines a reference implementation for Physically Based Shading of
+// a microfacet surface material defined by a glTF model.
+// TODO - better do the checks outside of shader
+const source = /* wgsl */ `\
+struct PBRFragmentInputs {
+  pbr_vPosition: vec3f,
+  pbr_vUV: vec2f,
+  pbr_vTBN: mat3f,
+  pbr_vNormal: vec3f
+};
+
+var fragmentInputs: PBRFragmentInputs;
+
+fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
+{
+  var pos: vec4f = pbrProjection.modelMatrix * position;
+  pbr_vPosition = vec3(pos.xyz) / pos.w;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
+  fragmentInputs,pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+#else // HAS_TANGENTS != 1
+  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+#endif
+#endif
+
+#ifdef HAS_UV
+  pbr_vUV = uv;
+#else
+  pbr_vUV = vec2(0.,0.);
+#endif
+}
+
+struct pbrMaterialUniforms {
+  // Material is unlit
+  unlit: uint32,
+
+  // Base color map
+  baseColorMapEnabled: uint32,
+  baseColorFactor: vec4f,
+
+  normalMapEnabled : uint32,
+  normalScale: f32,  // #ifdef HAS_NORMALMAP
+
+  emissiveMapEnabled: uint32,
+  emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
+
+  metallicRoughnessValues: vec2f,
+  metallicRoughnessMapEnabled: uint32,
+
+  occlusionMapEnabled: i32,
+  occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
+  
+  alphaCutoffEnabled: i32,
+  alphaCutoff: f32, // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  IBLenabled: i32,
+  scaleIBLAmbient: vec2f, // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR: vec4f,
+  scaleFGDSpec: vec4f
+  // #endif
+} 
+  
+@binding(2) @group(0) var<uniform> material : pbrMaterialUniforms;
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D pbr_normalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D pbr_emissiveSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D pbr_metallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D pbr_occlusionSampler;
+#endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+
+// Encapsulate the various inputs used by the various functions in the shading equation
+// We store values in this struct to simplify the integration of alternative implementations
+// of the shading terms, outlined in the Readme.MD Appendix.
+struct PBRInfo {
+  NdotL: f32,                  // cos angle between normal and light direction
+  NdotV: f32,                  // cos angle between normal and view direction
+  NdotH: f32,                  // cos angle between normal and half vector
+  LdotH: f32,                  // cos angle between light direction and half vector
+  VdotH: f32,                  // cos angle between view direction and half vector
+  perceptualRoughness: f32,    // roughness value, as authored by the model creator (input to shader)
+  metalness: f32,              // metallic value at the surface
+  reflectance0: vec3f,            // full reflectance color (normal incidence angle)
+  reflectance90: vec3f,           // reflectance color at grazing angle
+  alphaRoughness: f32,         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  diffuseColor: vec3f,            // color contribution from diffuse lighting
+  specularColor: vec3f,           // color contribution from specular lighting
+  n: vec3f,                       // normal at surface point
+  v: vec3f,                       // vector from surface point to camera
+};
+
+const M_PI = 3.141592653589793;
+const c_MinRoughness = 0.04;
+
+fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
+{
+#ifdef MANUAL_SRGB
+#ifdef SRGB_FAST_APPROXIMATION
+  var linOut: vec3f = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  var bLess: vec3f = step(vec3(0.04045),srgbIn.xyz);
+  var linOut: vec3f = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4f(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+fn getNormal() -> vec3f
+{
+  // Retrieve the tangent space matrix
+#ifndef HAS_TANGENTS
+  var pos_dx: vec3f = dFdx(pbr_vPosition);
+  var pos_dy: vec3f = dFdy(pbr_vPosition);
+  var tex_dx: vec3f = dFdx(vec3(pbr_vUV, 0.0));
+  var tex_dy: vec3f = dFdy(vec3(pbr_vUV, 0.0));
+  var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+
+#ifdef HAS_NORMALS
+  var ng: vec3f = normalize(pbr_vNormal);
+#else
+  var ng: vec3f = cross(pos_dx, pos_dy);
+#endif
+
+  t = normalize(t - ng * dot(ng, t));
+  var b: vec3f = normalize(cross(ng, t));
+  var tbn: mat3f = mat3f(t, b, ng);
+#else // HAS_TANGENTS
+  var tbn: mat3f = pbr_vTBN;
+#endif
+
+#ifdef HAS_NORMALMAP
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+#else
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
+#endif
+
+  return n;
+}
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
+{
+  float mipCount = 9.0; // resolution of 512x512
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
+
+#ifdef USE_TEX_LOD
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
+#else
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+#endif
+
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
+
+  return diffuse + specular;
+}
+#endif
+
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
+fn diffuse(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.diffuseColor / PI;
+}
+
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
+fn specularReflection(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+}
+
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
+fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
+  let NdotL: f32 = pbrInfo.NdotL;
+  let NdotV: f32 = pbrInfo.NdotV;
+  let r: f32 = pbrInfo.alphaRoughness;
+
+  let attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  let attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
+}
+
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
+fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
+  let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (PI * f * f);
+}
+
+fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
+  (*pbrInfo).NdotL = 1.0;
+  (*pbrInfo).NdotH = 0.0;
+  (*pbrInfo).LdotH = 0.0;
+  (*pbrInfo).VdotH = 1.0;
+}
+
+fn PBRInfo_setDirectionalLight(pbrInfo: ptr<function, PBRInfo>, lightDirection: vec3<f32>) {
+  let n = (*pbrInfo).n;
+  let v = (*pbrInfo).v;
+  let l = normalize(lightDirection);             // Vector from surface point to light
+  let h = normalize(l + v);                      // Half vector between both l and v
+
+  (*pbrInfo).NdotL = clamp(dot(n, l), 0.001, 1.0);
+  (*pbrInfo).NdotH = clamp(dot(n, h), 0.0, 1.0);
+  (*pbrInfo).LdotH = clamp(dot(l, h), 0.0, 1.0);
+  (*pbrInfo).VdotH = clamp(dot(v, h), 0.0, 1.0);
+}
+
+fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight) {
+  let light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
+  // Calculate the shading terms for the microfacet specular shading model
+  let F = specularReflection(pbrInfo);
+  let G = geometricOcclusion(pbrInfo);
+  let D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  let diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  let specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+}
+
+fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
+  // The albedo may be defined from a base texture or a flat color
+  var baseColor: vec4<f32>;
+  #ifdef HAS_BASECOLORMAP
+  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  #else
+  baseColor = pbrMaterial.baseColorFactor;
+  #endif
+
+  #ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+  #endif
+
+  var color = vec3<f32>(0.0, 0.0, 0.0);
+
+  if (pbrMaterial.unlit) {
+    color = baseColor.rgb;
+  } else {
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    var perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    var metallic = pbrMaterial.metallicRoughnessValues.x;
+    #ifdef HAS_METALROUGHNESSMAP
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, pbr_vUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+    #endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    let alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    let f0 = vec3<f32>(0.04);
+    var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
+    diffuseColor *= 1.0 - metallic;
+    let specularColor = mix(f0, baseColor.rgb, metallic);
+
+    // Compute reflectance.
+    let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflectance to 0%.
+    let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    let specularEnvironmentR0 = specularColor;
+    let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
+
+    let n = getNormal();                          // normal at surface point
+    let v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+
+    let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    let reflection = -normalize(reflect(v, n));
+
+    var pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v
+    );
+
+    #ifdef USE_LIGHTS
+    // Apply ambient light
+    PBRInfo_setAmbientLight(&pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+    // Apply directional light
+    for (var i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+      }
+    }
+
+    // Apply point light
+    for (var i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
+        let attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+      }
+    }
+    #endif
+
+    // Calculate lighting contribution from image based lighting source (IBL)
+    #ifdef USE_IBL
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
+    #endif
+
+    // Apply optional PBR terms for additional (optional) shading
+    #ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled) {
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+    #endif
+
+    #ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
+    #endif
+
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
+    #ifdef PBR_DEBUG
+    // TODO: Figure out how to debug multiple lights
+
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
+
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+    #endif
+  }
+
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+}
+`;
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock$1 = /* glsl */ `\
+uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`;
+const pbrProjection = {
+    name: 'pbrProjection',
+    vs: uniformBlock$1,
+    fs: uniformBlock$1,
+    // TODO why is this needed?
+    getUniforms: props => props,
+    uniformTypes: {
+        modelViewProjectionMatrix: 'mat4x4<f32>',
+        modelMatrix: 'mat4x4<f32>',
+        normalMatrix: 'mat4x4<f32>',
+        camera: 'vec3<i32>'
+    }
+};
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * An implementation of PBR (Physically-Based Rendering).
+ * Physically Based Shading of a microfacet surface defined by a glTF material.
+ */
+const pbrMaterial = {
+    props: {},
+    uniforms: {},
+    name: 'pbrMaterial',
+    dependencies: [deckProvider.lighting, pbrProjection],
+    source,
+    vs: vs$2,
+    fs: fs$2,
+    defines: {
+        LIGHTING_FRAGMENT: true,
+        HAS_NORMALMAP: false,
+        HAS_EMISSIVEMAP: false,
+        HAS_OCCLUSIONMAP: false,
+        HAS_BASECOLORMAP: false,
+        HAS_METALROUGHNESSMAP: false,
+        ALPHA_CUTOFF: false,
+        USE_IBL: false,
+        PBR_DEBUG: false
+    },
+    getUniforms: props => props,
+    uniformTypes: {
+        // Material is unlit
+        unlit: 'i32',
+        // Base color map
+        baseColorMapEnabled: 'i32',
+        baseColorFactor: 'vec4<f32>',
+        normalMapEnabled: 'i32',
+        normalScale: 'f32', // #ifdef HAS_NORMALMAP
+        emissiveMapEnabled: 'i32',
+        emissiveFactor: 'vec3<f32>', // #ifdef HAS_EMISSIVEMAP
+        metallicRoughnessValues: 'vec2<f32>',
+        metallicRoughnessMapEnabled: 'i32',
+        occlusionMapEnabled: 'i32',
+        occlusionStrength: 'f32', // #ifdef HAS_OCCLUSIONMAP
+        alphaCutoffEnabled: 'i32',
+        alphaCutoff: 'f32', // #ifdef ALPHA_CUTOFF
+        // IBL
+        IBLenabled: 'i32',
+        scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL
+        // debugging flags used for shader output of intermediate PBR variables
+        // #ifdef PBR_DEBUG
+        scaleDiffBaseMR: 'vec4<f32>',
+        scaleFGDSpec: 'vec4<f32>'
+    }
+};
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class ScenegraphNode {
+    id;
+    matrix = new deckProvider.Matrix4();
+    display = true;
+    position = new deckProvider.Vector3();
+    rotation = new deckProvider.Vector3();
+    scale = new deckProvider.Vector3(1, 1, 1);
+    userData = {};
+    props = {};
+    constructor(props = {}) {
+        const { id } = props;
+        this.id = id || deckProvider.uid(this.constructor.name);
+        this._setScenegraphNodeProps(props);
+    }
+    getBounds() {
+        return null;
+    }
+    destroy() { }
+    /** @deprecated use .destroy() */
+    delete() {
+        this.destroy();
+    }
+    setProps(props) {
+        this._setScenegraphNodeProps(props);
+        return this;
+    }
+    toString() {
+        return `{type: ScenegraphNode, id: ${this.id})}`;
+    }
+    setPosition(position) {
+        // assert(position.length === 3, 'setPosition requires vector argument');
+        this.position = position;
+        return this;
+    }
+    setRotation(rotation) {
+        // assert(rotation.length === 3, 'setRotation requires vector argument');
+        this.rotation = rotation;
+        return this;
+    }
+    setScale(scale) {
+        // assert(scale.length === 3, 'setScale requires vector argument');
+        this.scale = scale;
+        return this;
+    }
+    setMatrix(matrix, copyMatrix = true) {
+        if (copyMatrix) {
+            this.matrix.copy(matrix);
+        }
+        else {
+            this.matrix = matrix;
+        }
+    }
+    setMatrixComponents(components) {
+        const { position, rotation, scale, update = true } = components;
+        if (position) {
+            this.setPosition(position);
+        }
+        if (rotation) {
+            this.setRotation(rotation);
+        }
+        if (scale) {
+            this.setScale(scale);
+        }
+        if (update) {
+            this.updateMatrix();
+        }
+        return this;
+    }
+    updateMatrix() {
+        const pos = this.position;
+        const rot = this.rotation;
+        const scale = this.scale;
+        this.matrix.identity();
+        this.matrix.translate(pos);
+        this.matrix.rotateXYZ(rot);
+        this.matrix.scale(scale);
+        return this;
+    }
+    update(options = {}) {
+        const { position, rotation, scale } = options;
+        if (position) {
+            this.setPosition(position);
+        }
+        if (rotation) {
+            this.setRotation(rotation);
+        }
+        if (scale) {
+            this.setScale(scale);
+        }
+        this.updateMatrix();
+        return this;
+    }
+    getCoordinateUniforms(viewMatrix, modelMatrix) {
+        // TODO - solve multiple class problem
+        // assert(viewMatrix instanceof Matrix4);
+        // assert(viewMatrix);
+        modelMatrix = modelMatrix || this.matrix;
+        const worldMatrix = new deckProvider.Matrix4(viewMatrix).multiplyRight(modelMatrix);
+        const worldInverse = worldMatrix.invert();
+        const worldInverseTranspose = worldInverse.transpose();
+        return {
+            viewMatrix,
+            modelMatrix,
+            objectMatrix: modelMatrix,
+            worldMatrix,
+            worldInverseMatrix: worldInverse,
+            worldInverseTransposeMatrix: worldInverseTranspose
+        };
+    }
+    // TODO - copied code, not yet vetted
+    /*
+    transform() {
+      if (!this.parent) {
+        this.endPosition.set(this.position);
+        this.endRotation.set(this.rotation);
+        this.endScale.set(this.scale);
+      } else {
+        const parent = this.parent;
+        this.endPosition.set(this.position.add(parent.endPosition));
+        this.endRotation.set(this.rotation.add(parent.endRotation));
+        this.endScale.set(this.scale.add(parent.endScale));
+      }
+  
+      const ch = this.children;
+      for (let i = 0; i < ch.length; ++i) {
+        ch[i].transform();
+      }
+  
+      return this;
+    }
+    */
+    _setScenegraphNodeProps(props) {
+        // if ('display' in props) {
+        //   this.display = props.display;
+        // }
+        if ('position' in props) {
+            this.setPosition(props.position);
+        }
+        if ('rotation' in props) {
+            this.setRotation(props.rotation);
+        }
+        if ('scale' in props) {
+            this.setScale(props.scale);
+        }
+        // Matrix overwrites other props
+        if ('matrix' in props) {
+            this.setMatrix(props.matrix);
+        }
+        Object.assign(this.props, props);
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class GroupNode extends ScenegraphNode {
+    children;
+    constructor(props = {}) {
+        props = Array.isArray(props) ? { children: props } : props;
+        const { children = [] } = props;
+        deckProvider.log.assert(children.every(child => child instanceof ScenegraphNode), 'every child must an instance of ScenegraphNode');
+        super(props);
+        this.children = children;
+    }
+    getBounds() {
+        const result = [
+            [Infinity, Infinity, Infinity],
+            [-Infinity, -Infinity, -Infinity]
+        ];
+        this.traverse((node, { worldMatrix }) => {
+            const bounds = node.getBounds();
+            if (!bounds) {
+                return;
+            }
+            const [min, max] = bounds;
+            const center = new deckProvider.Vector3(min).add(max).divide([2, 2, 2]);
+            worldMatrix.transformAsPoint(center, center);
+            const halfSize = new deckProvider.Vector3(max).subtract(min).divide([2, 2, 2]);
+            worldMatrix.transformAsVector(halfSize, halfSize);
+            for (let v = 0; v < 8; v++) {
+                // Test all 8 corners of the box
+                const position = new deckProvider.Vector3(v & 0b001 ? -1 : 1, v & 0b010 ? -1 : 1, v & 0b100 ? -1 : 1)
+                    .multiply(halfSize)
+                    .add(center);
+                for (let i = 0; i < 3; i++) {
+                    result[0][i] = Math.min(result[0][i], position[i]);
+                    result[1][i] = Math.max(result[1][i], position[i]);
+                }
+            }
+        });
+        if (!Number.isFinite(result[0][0])) {
+            return null;
+        }
+        return result;
+    }
+    destroy() {
+        this.children.forEach(child => child.destroy());
+        this.removeAll();
+        super.destroy();
+    }
+    // Unpacks arrays and nested arrays of children
+    add(...children) {
+        for (const child of children) {
+            if (Array.isArray(child)) {
+                this.add(...child);
+            }
+            else {
+                this.children.push(child);
+            }
+        }
+        return this;
+    }
+    remove(child) {
+        const children = this.children;
+        const indexOf = children.indexOf(child);
+        if (indexOf > -1) {
+            children.splice(indexOf, 1);
+        }
+        return this;
+    }
+    removeAll() {
+        this.children = [];
+        return this;
+    }
+    traverse(visitor, { worldMatrix = new deckProvider.Matrix4() } = {}) {
+        const modelMatrix = new deckProvider.Matrix4(worldMatrix).multiplyRight(this.matrix);
+        for (const child of this.children) {
+            if (child instanceof GroupNode) {
+                child.traverse(visitor, { worldMatrix: modelMatrix });
+            }
+            else {
+                visitor(child, { worldMatrix: modelMatrix });
+            }
+        }
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class ModelNode extends ScenegraphNode {
+    model;
+    bounds = null;
+    managedResources;
+    // TODO - is this used? override callbacks to make sure we call them with this
+    // onBeforeRender = null;
+    // onAfterRender = null;
+    // AfterRender = null;
+    constructor(props) {
+        super(props);
+        // Create new Model or used supplied Model
+        this.model = props.model;
+        this.managedResources = props.managedResources || [];
+        this.bounds = props.bounds || null;
+        this.setProps(props);
+    }
+    destroy() {
+        if (this.model) {
+            this.model.destroy();
+            // @ts-expect-error
+            this.model = null;
+        }
+        this.managedResources.forEach(resource => resource.destroy());
+        this.managedResources = [];
+    }
+    getBounds() {
+        return this.bounds;
+    }
+    // Expose model methods
+    draw(renderPass) {
+        // Return value indicates if something was actually drawn
+        return this.model.draw(renderPass);
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function convertSampler(gltfSampler) {
+    return {
+        addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
+        addressModeV: convertSamplerWrapMode(gltfSampler.wrapT),
+        magFilter: convertSamplerMagFilter(gltfSampler.magFilter),
+        ...convertSamplerMinFilter(gltfSampler.minFilter)
+    };
+}
+function convertSamplerWrapMode(mode) {
+    switch (mode) {
+        case 33071:
+            return 'clamp-to-edge';
+        case 10497:
+            return 'repeat';
+        case 33648:
+            return 'mirror-repeat';
+        default:
+            return undefined;
+    }
+}
+function convertSamplerMagFilter(mode) {
+    switch (mode) {
+        case 9728:
+            return 'nearest';
+        case 9729:
+            return 'linear';
+        default:
+            return undefined;
+    }
+}
+function convertSamplerMinFilter(mode) {
+    switch (mode) {
+        case 9728:
+            return { minFilter: 'nearest' };
+        case 9729:
+            return { minFilter: 'linear' };
+        case 9984:
+            return { minFilter: 'nearest', mipmapFilter: 'nearest' };
+        case 9985:
+            return { minFilter: 'linear', mipmapFilter: 'nearest' };
+        case 9986:
+            return { minFilter: 'nearest', mipmapFilter: 'linear' };
+        case 9987:
+            return { minFilter: 'linear', mipmapFilter: 'linear' };
+        default:
+            return {};
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Parses a GLTF material definition into uniforms and parameters for the PBR shader module
+ */
+function parsePBRMaterial(device, material, attributes, options) {
+    const parsedMaterial = {
+        defines: {
+            // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
+            MANUAL_SRGB: true,
+            SRGB_FAST_APPROXIMATION: true
+        },
+        bindings: {},
+        uniforms: {
+            // TODO: find better values?
+            camera: [0, 0, 0], // Model should override
+            metallicRoughnessValues: [1, 1] // Default is 1 and 1
+        },
+        parameters: {},
+        glParameters: {},
+        generatedTextures: []
+    };
+    // TODO - always available
+    parsedMaterial.defines['USE_TEX_LOD'] = true;
+    const { imageBasedLightingEnvironment } = options;
+    if (imageBasedLightingEnvironment) {
+        parsedMaterial.bindings.pbr_diffuseEnvSampler =
+            imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+        parsedMaterial.bindings.pbr_specularEnvSampler =
+            imageBasedLightingEnvironment.specularEnvSampler.texture;
+        parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+        parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
+    }
+    if (options?.pbrDebug) {
+        parsedMaterial.defines['PBR_DEBUG'] = true;
+        // Override final color for reference app visualization of various parameters in the lighting equation.
+        parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+        parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
+    }
+    if (attributes['NORMAL'])
+        parsedMaterial.defines['HAS_NORMALS'] = true;
+    if (attributes['TANGENT'] && options?.useTangents)
+        parsedMaterial.defines['HAS_TANGENTS'] = true;
+    if (attributes['TEXCOORD_0'])
+        parsedMaterial.defines['HAS_UV'] = true;
+    if (options?.imageBasedLightingEnvironment)
+        parsedMaterial.defines['USE_IBL'] = true;
+    if (options?.lights)
+        parsedMaterial.defines['USE_LIGHTS'] = true;
+    if (material) {
+        parseMaterial(device, material, parsedMaterial);
+    }
+    return parsedMaterial;
+}
+/** Parse GLTF material record */
+function parseMaterial(device, material, parsedMaterial) {
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+    if (material.pbrMetallicRoughness) {
+        parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+    }
+    if (material.normalTexture) {
+        addTexture(device, material.normalTexture, 'pbr_normalSampler', 'HAS_NORMALMAP', parsedMaterial);
+        const { scale = 1 } = material.normalTexture;
+        parsedMaterial.uniforms.normalScale = scale;
+    }
+    if (material.occlusionTexture) {
+        addTexture(device, material.occlusionTexture, 'pbr_occlusionSampler', 'HAS_OCCLUSIONMAP', parsedMaterial);
+        const { strength = 1 } = material.occlusionTexture;
+        parsedMaterial.uniforms.occlusionStrength = strength;
+    }
+    if (material.emissiveTexture) {
+        addTexture(device, material.emissiveTexture, 'pbr_emissiveSampler', 'HAS_EMISSIVEMAP', parsedMaterial);
+        parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+    }
+    switch (material.alphaMode || 'MASK') {
+        case 'MASK':
+            const { alphaCutoff = 0.5 } = material;
+            parsedMaterial.defines['ALPHA_CUTOFF'] = true;
+            parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
+            break;
+        case 'BLEND':
+            deckProvider.log.warn('glTF BLEND alphaMode might not work well because it requires mesh sorting')();
+            // WebGPU style parameters
+            parsedMaterial.parameters.blend = true;
+            parsedMaterial.parameters.blendColorOperation = 'add';
+            parsedMaterial.parameters.blendColorSrcFactor = 'src-alpha';
+            parsedMaterial.parameters.blendColorDstFactor = 'one-minus-src-alpha';
+            parsedMaterial.parameters.blendAlphaOperation = 'add';
+            parsedMaterial.parameters.blendAlphaSrcFactor = 'one';
+            parsedMaterial.parameters.blendAlphaDstFactor = 'one-minus-src-alpha';
+            // GL parameters
+            // TODO - remove in favor of parameters
+            parsedMaterial.glParameters['blend'] = true;
+            parsedMaterial.glParameters['blendEquation'] = 32774;
+            parsedMaterial.glParameters['blendFunc'] = [
+                770,
+                771,
+                1,
+                771
+            ];
+            break;
+    }
+}
+/** Parse GLTF material sub record */
+function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+    if (pbrMetallicRoughness.baseColorTexture) {
+        addTexture(device, pbrMetallicRoughness.baseColorTexture, 'pbr_baseColorSampler', 'HAS_BASECOLORMAP', parsedMaterial);
+    }
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    if (pbrMetallicRoughness.metallicRoughnessTexture) {
+        addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, 'pbr_metallicRoughnessSampler', 'HAS_METALROUGHNESSMAP', parsedMaterial);
+    }
+    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+}
+/** Create a texture from a glTF texture/sampler/image combo and add it to bindings */
+function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
+    const image = gltfTexture.texture.source.image;
+    let textureOptions;
+    if (image.compressed) {
+        textureOptions = image;
+    }
+    else {
+        // Texture2D accepts a promise that returns an image as data (Async Textures)
+        textureOptions = { data: image };
+    }
+    const gltfSampler = {
+        wrapS: 10497, // default REPEAT S (U) wrapping mode.
+        wrapT: 10497, // default REPEAT T (V) wrapping mode.
+        ...gltfTexture?.texture?.sampler
+    };
+    const texture = device.createTexture({
+        id: gltfTexture.uniformName || gltfTexture.id,
+        sampler: convertSampler(gltfSampler),
+        ...textureOptions
+    });
+    parsedMaterial.bindings[uniformName] = texture;
+    if (define)
+        parsedMaterial.defines[define] = true;
+    parsedMaterial.generatedTextures.push(texture);
+}
+/*
+/**
+ * Parses a GLTF material definition into uniforms and parameters for the PBR shader module
+ *
+export class PBRMaterialParser {
+  readonly device: Device;
+
+  readonly defines: Record<string, boolean>;
+  readonly bindings: Record<string, Binding>;
+  readonly uniforms: Record<string, any>;
+  readonly parameters: Record<string, any>;
+
+  /** Hold on to generated textures, we destroy them in the destroy method *
+  readonly generatedTextures: Texture[];
+
+  constructor(device: Device, props: PBRMaterialParserProps) {
+    const {attributes, material, pbrDebug, imageBasedLightingEnvironment, lights, useTangents} =
+      props;
+    this.device = device;
+
+    this.defines = {
+      // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
+      MANUAL_SRGB: true,
+      SRGB_FAST_APPROXIMATION: true
+    };
+
+    if (this.device.features.has('glsl-texture-lod')) {
+      this.defines.USE_TEX_LOD = true;
+    }
+
+    this.uniforms = {
+      // TODO: find better values?
+      camera: [0, 0, 0], // Model should override
+
+      metallicRoughnessValues: [1, 1] // Default is 1 and 1
+    };
+
+    this.bindings = {};
+
+    this.parameters = {};
+    this.generatedTextures = [];
+
+    if (imageBasedLightingEnvironment) {
+      this.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.getDiffuseEnvSampler();
+      this.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.getSpecularEnvSampler();
+      this.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.getBrdfTexture();
+      this.uniforms.scaleIBLAmbient = [1, 1];
+    }
+
+    if (pbrDebug) {
+      // Override final color for reference app visualization
+      // of various parameters in the lighting equation.
+      this.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      this.uniforms.scaleFGDSpec = [0, 0, 0, 0];
+    }
+
+    this.defineIfPresent(attributes.NORMAL, 'HAS_NORMALS');
+    this.defineIfPresent(attributes.TANGENT && useTangents, 'HAS_TANGENTS');
+    this.defineIfPresent(attributes.TEXCOORD_0, 'HAS_UV');
+
+    this.defineIfPresent(imageBasedLightingEnvironment, 'USE_IBL');
+    this.defineIfPresent(lights, 'USE_LIGHTS');
+    this.defineIfPresent(pbrDebug, 'PBR_DEBUG');
+
+    if (material) {
+      this.parseMaterial(material);
+    }
+  }
+
+  /**
+   * Destroy all generated resources to release memory.
+   *
+  destroy(): void {
+    this.generatedTextures.forEach(texture => texture.destroy());
+  }
+
+  /** Add a define if the the value is non-nullish *
+  defineIfPresent(value: unknown, name: string): void {
+    if (value) {
+      this.defines[name] = 1;
+    }
+  }
+
+  /** Parse GLTF material record *
+  parseMaterial(material) {
+    this.uniforms.unlit = Boolean(material.unlit);
+
+    if (material.pbrMetallicRoughness) {
+      this.parsePbrMetallicRoughness(material.pbrMetallicRoughness);
+    }
+    if (material.normalTexture) {
+      this.addTexture(material.normalTexture, 'pbr_normalSampler', 'HAS_NORMALMAP');
+
+      const {scale = 1} = material.normalTexture;
+      this.uniforms.normalScale = scale;
+    }
+    if (material.occlusionTexture) {
+      this.addTexture(material.occlusionTexture, 'pbr_occlusionSampler', 'HAS_OCCLUSIONMAP');
+
+      const {strength = 1} = material.occlusionTexture;
+      this.uniforms.occlusionStrength = strength;
+    }
+    if (material.emissiveTexture) {
+      this.addTexture(material.emissiveTexture, 'pbr_emissiveSampler', 'HAS_EMISSIVEMAP');
+      this.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+    }
+    if (material.alphaMode === 'MASK') {
+      const {alphaCutoff = 0.5} = material;
+      this.defines.ALPHA_CUTOFF = true;
+      this.uniforms.u_AlphaCutoff = alphaCutoff;
+    } else if (material.alphaMode === 'BLEND') {
+      log.warn('BLEND alphaMode might not work well because it requires mesh sorting')();
+      Object.assign(this.parameters, {
+        blend: true,
+        blendEquation: GL.FUNC_ADD,
+        blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA]
+      });
+    }
+  }
+
+  /** Parse GLTF material sub record *
+  parsePbrMetallicRoughness(pbrMetallicRoughness) {
+    if (pbrMetallicRoughness.baseColorTexture) {
+      this.addTexture(
+        pbrMetallicRoughness.baseColorTexture,
+        'pbr_baseColorSampler',
+        'HAS_BASECOLORMAP'
+      );
+    }
+    this.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+
+    if (pbrMetallicRoughness.metallicRoughnessTexture) {
+      this.addTexture(
+        pbrMetallicRoughness.metallicRoughnessTexture,
+        'pbr_metallicRoughnessSampler',
+        'HAS_METALROUGHNESSMAP'
+      );
+    }
+    const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;
+    this.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+  }
+
+  /** Create a texture from a glTF texture/sampler/image combo and add it to bindings *
+  addTexture(gltfTexture, name, define = null) {
+    const parameters = gltfTexture?.texture?.sampler?.parameters || {};
+
+    const image = gltfTexture.texture.source.image;
+    let textureOptions;
+    let specialTextureParameters = {};
+    if (image.compressed) {
+      textureOptions = image;
+      specialTextureParameters = {
+        [GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR
+      };
+    } else {
+      // Texture2D accepts a promise that returns an image as data (Async Textures)
+      textureOptions = {data: image};
+    }
+
+    const texture: Texture = this.device.createTexture({
+      id: gltfTexture.name || gltfTexture.id,
+      parameters: {
+        ...parameters,
+        ...specialTextureParameters
+      },
+      pixelStore: {
+        [GL.UNPACK_FLIP_Y_WEBGL]: false
+      },
+      ...textureOptions
+    });
+    this.bindings[name] = texture;
+    this.defineIfPresent(define, define);
+    this.generatedTextures.push(texture);
+  }
+}
+*/
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// 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
+var GLEnum;
+(function (GLEnum) {
+    GLEnum[GLEnum["POINTS"] = 0] = "POINTS";
+    GLEnum[GLEnum["LINES"] = 1] = "LINES";
+    GLEnum[GLEnum["LINE_LOOP"] = 2] = "LINE_LOOP";
+    GLEnum[GLEnum["LINE_STRIP"] = 3] = "LINE_STRIP";
+    GLEnum[GLEnum["TRIANGLES"] = 4] = "TRIANGLES";
+    GLEnum[GLEnum["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    GLEnum[GLEnum["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+})(GLEnum || (GLEnum = {}));
+function convertGLDrawModeToTopology(drawMode) {
+    // prettier-ignore
+    switch (drawMode) {
+        case GLEnum.POINTS: return 'point-list';
+        case GLEnum.LINES: return 'line-list';
+        case GLEnum.LINE_STRIP: return 'line-strip';
+        case GLEnum.TRIANGLES: return 'triangle-list';
+        case GLEnum.TRIANGLE_STRIP: return 'triangle-strip';
+        default: throw new Error(String(drawMode));
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+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
+
+  #ifdef HAS_UV
+    // in vec2 TEXCOORD_0;
+    in vec2 texCoords;
+  #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;
+  }
+
+@fragment
+  out vec4 fragmentColor;
+
+  void main(void) {
+    vec3 pos = pbr_vPosition;
+    fragmentColor = pbr_filterColor(vec4(1.0));
+  }
+`;
+// TODO rename attributes to POSITION/NORMAL etc
+// See gpu-geometry.ts: getAttributeBuffersFromGeometry()
+const vs$1 = /* glsl */ `\
+#version 300 es
+
+  // in vec4 POSITION;
+  in vec4 positions;
+
+  #ifdef HAS_NORMALS
+    // in vec4 NORMAL;
+    in vec4 normals;
+  #endif
+
+  #ifdef HAS_TANGENTS
+    in vec4 TANGENT;
+  #endif
+
+  #ifdef HAS_UV
+    // in vec2 TEXCOORD_0;
+    in vec2 texCoords;
+  #endif
+
+  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 = pbrProjection.modelViewProjectionMatrix * positions;
+  }
+`;
+const fs$1 = /* glsl */ `\
+#version 300 es
+  out vec4 fragmentColor;
+
+  void main(void) {
+    vec3 pos = pbr_vPosition;
+    fragmentColor = pbr_filterColor(vec4(1.0));
+  }
+`;
+/** Creates a luma.gl Model from GLTF data*/
+function createGLTFModel(device, options) {
+    const { id, geometry, parsedPPBRMaterial, vertexCount, modelOptions = {} } = options;
+    deckProvider.log.info(4, 'createGLTFModel defines: ', parsedPPBRMaterial.defines)();
+    // Calculate managedResources
+    // TODO: Implement resource management logic that will
+    // not deallocate resources/textures/buffers that are shared
+    const managedResources = [];
+    // managedResources.push(...parsedMaterial.generatedTextures);
+    // managedResources.push(...Object.values(attributes).map((attribute) => attribute.buffer));
+    const parameters = {
+        depthWriteEnabled: true,
+        depthCompare: 'less',
+        depthFormat: 'depth24plus',
+        cullMode: 'back'
+    };
+    const modelProps = {
+        id,
+        source: SHADER,
+        vs: vs$1,
+        fs: fs$1,
+        geometry,
+        topology: geometry.topology,
+        vertexCount,
+        modules: [pbrMaterial],
+        ...modelOptions,
+        defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
+        parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
+    };
+    const model = new deckProvider.Model(device, modelProps);
+    const { camera, ...pbrMaterialProps } = {
+        ...parsedPPBRMaterial.uniforms,
+        ...modelOptions.uniforms,
+        ...parsedPPBRMaterial.bindings,
+        ...modelOptions.bindings
+    };
+    model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
+    return new ModelNode({ managedResources, model });
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const defaultOptions = {
+    modelOptions: {},
+    pbrDebug: false,
+    imageBasedLightingEnvironment: undefined,
+    lights: true,
+    useTangents: false
+};
+/**
+ * GLTF instantiator for luma.gl
+ * Walks the parsed and resolved glTF structure and builds a luma.gl scenegraph
+ */
+function parseGLTF(device, gltf, options_ = {}) {
+    const options = { ...defaultOptions, ...options_ };
+    const sceneNodes = gltf.scenes.map(gltfScene => createScene(device, gltfScene, gltf.nodes, options));
+    return sceneNodes;
+}
+function createScene(device, gltfScene, gltfNodes, options) {
+    const gltfSceneNodes = gltfScene.nodes || [];
+    const nodes = gltfSceneNodes.map(node => createNode(device, node, gltfNodes, options));
+    const sceneNode = new GroupNode({
+        id: gltfScene.name || gltfScene.id,
+        children: nodes
+    });
+    return sceneNode;
+}
+function createNode(device, gltfNode, gltfNodes, options) {
+    if (!gltfNode._node) {
+        const gltfChildren = gltfNode.children || [];
+        const children = gltfChildren.map(child => createNode(device, child, gltfNodes, options));
+        // Node can have children nodes and meshes at the same time
+        if (gltfNode.mesh) {
+            children.push(createMesh(device, gltfNode.mesh, options));
+        }
+        const node = new GroupNode({
+            id: gltfNode.name || gltfNode.id,
+            children
+        });
+        if (gltfNode.matrix) {
+            node.setMatrix(gltfNode.matrix);
+        }
+        else {
+            node.matrix.identity();
+            if (gltfNode.translation) {
+                node.matrix.translate(gltfNode.translation);
+            }
+            if (gltfNode.rotation) {
+                const rotationMatrix = new deckProvider.Matrix4().fromQuaternion(gltfNode.rotation);
+                node.matrix.multiplyRight(rotationMatrix);
+            }
+            if (gltfNode.scale) {
+                node.matrix.scale(gltfNode.scale);
+            }
+        }
+        gltfNode._node = node;
+    }
+    // Copy _node so that gltf-animator can access
+    const topLevelNode = gltfNodes.find(node => node.id === gltfNode.id);
+    topLevelNode._node = gltfNode._node;
+    return gltfNode._node;
+}
+function createMesh(device, gltfMesh, options) {
+    // TODO: avoid changing the gltf
+    if (!gltfMesh._mesh) {
+        const gltfPrimitives = gltfMesh.primitives || [];
+        const primitives = gltfPrimitives.map((gltfPrimitive, i) => createPrimitive(device, gltfPrimitive, i, gltfMesh, options));
+        const mesh = new GroupNode({
+            id: gltfMesh.name || gltfMesh.id,
+            children: primitives
+        });
+        gltfMesh._mesh = mesh;
+    }
+    return gltfMesh._mesh;
+}
+function createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
+    const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
+    const topology = convertGLDrawModeToTopology(gltfPrimitive.mode || 4);
+    const vertexCount = gltfPrimitive.indices
+        ? gltfPrimitive.indices.count
+        : getVertexCount();
+    const geometry = createGeometry(id, gltfPrimitive, topology);
+    const parsedPPBRMaterial = parsePBRMaterial(device, gltfPrimitive.material, geometry.attributes, options);
+    const modelNode = createGLTFModel(device, {
+        id,
+        geometry: createGeometry(id, gltfPrimitive, topology),
+        parsedPPBRMaterial,
+        modelOptions: options.modelOptions,
+        vertexCount
+    });
+    modelNode.bounds = [gltfPrimitive.attributes.POSITION.min, gltfPrimitive.attributes.POSITION.max];
+    // TODO this holds on to all the CPU side texture and attribute data
+    // modelNode.material =  gltfPrimitive.material;
+    return modelNode;
+}
+function getVertexCount(attributes) {
+    throw new Error('getVertexCount not implemented');
+}
+function createGeometry(id, gltfPrimitive, topology) {
+    const attributes = {};
+    for (const [attributeName, attribute] of Object.entries(gltfPrimitive.attributes)) {
+        const { components, size, value } = attribute;
+        attributes[attributeName] = { size: size ?? components, value };
+    }
+    return new deckProvider.Geometry({
+        id,
+        topology,
+        indices: gltfPrimitive.indices.value,
+        attributes
+    });
+}
+
+const scratchQuaternion = new deckProvider.Quaternion();
+function interpolate(time, { input, interpolation, output }, target, path) {
+    const maxTime = input[input.length - 1];
+    const animationTime = time % maxTime;
+    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:
+                deckProvider.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]);
+            break;
+        case 'LINEAR':
+            if (nextTime > previousTime) {
+                const ratio = (animationTime - previousTime) / (nextTime - previousTime);
+                linearInterpolate(target, path, output[previousIndex], output[nextIndex], ratio);
+            }
+            break;
+        case 'CUBICSPLINE':
+            if (nextTime > previousTime) {
+                const ratio = (animationTime - previousTime) / (nextTime - previousTime);
+                const tDiff = nextTime - previousTime;
+                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 });
+            }
+            break;
+        default:
+            deckProvider.log.warn(`Interpolation ${interpolation} not supported`)();
+            break;
+    }
+}
+function linearInterpolate(target, path, start, stop, ratio) {
+    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];
+        }
+    }
+    else {
+        // regular interpolation
+        for (let i = 0; i < start.length; i++) {
+            target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
+        }
+    }
+}
+function cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
+    if (!target[path]) {
+        throw new Error();
+    }
+    // TODO: Quaternion might need normalization
+    for (let i = 0; i < target[path].length; i++) {
+        const m0 = outTangent0[i] * tDiff;
+        const m1 = inTangent1[i] * tDiff;
+        target[path][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;
+    }
+}
+function stepInterpolate(target, path, value) {
+    if (!target[path]) {
+        throw new Error();
+    }
+    for (let i = 0; i < value.length; i++) {
+        target[path][i] = value[i];
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class GLTFSingleAnimator {
+    animation;
+    startTime = 0;
+    playing = true;
+    speed = 1;
+    constructor(props) {
+        this.animation = props.animation;
+        this.animation.name ||= 'unnamed';
+        Object.assign(this, props);
+    }
+    setTime(timeMs) {
+        if (!this.playing) {
+            return;
+        }
+        const absTime = timeMs / 1000;
+        const time = (absTime - this.startTime) * this.speed;
+        this.animation.channels.forEach(({ sampler, target, path }) => {
+            interpolate(time, sampler, target, path);
+            applyTranslationRotationScale(target, target._node);
+        });
+    }
+}
+class GLTFAnimator {
+    animations;
+    constructor(props) {
+        this.animations = props.animations.map((animation, index) => {
+            const name = animation.name || `Animation-${index}`;
+            return new GLTFSingleAnimator({
+                animation: { name, channels: animation.channels }
+            });
+        });
+    }
+    /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
+    animate(time) {
+        deckProvider.log.warn('GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead')();
+        this.setTime(time);
+    }
+    setTime(time) {
+        this.animations.forEach(animation => animation.setTime(time));
+    }
+    getAnimations() {
+        return this.animations;
+    }
+}
+// TODO: share with GLTFInstantiator
+const scratchMatrix = new deckProvider.Matrix4();
+function applyTranslationRotationScale(gltfNode, node) {
+    node.matrix.identity();
+    if (gltfNode.translation) {
+        node.matrix.translate(gltfNode.translation);
+    }
+    if (gltfNode.rotation) {
+        const rotationMatrix = scratchMatrix.fromQuaternion(gltfNode.rotation);
+        node.matrix.multiplyRight(rotationMatrix);
+    }
+    if (gltfNode.scale) {
+        node.matrix.scale(gltfNode.scale);
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
+};
+function accessorToTypedArray(accessor) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const length = components * accessor.count;
+    const { buffer, byteOffset = 0 } = accessor.bufferView?.data ?? {};
+    const typedArray = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length);
+    return { typedArray, components };
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function parseGLTFAnimations(gltf) {
+    const gltfAnimations = gltf.animations || [];
+    return gltfAnimations.map((animation, index) => {
+        const name = animation.name || `Animation-${index}`;
+        const samplers = animation.samplers.map(({ input, interpolation = 'LINEAR', output }) => ({
+            input: accessorToJsArray(gltf.accessors[input]),
+            interpolation,
+            output: accessorToJsArray(gltf.accessors[output])
+        }));
+        const channels = animation.channels.map(({ sampler, target }) => ({
+            sampler: samplers[sampler],
+            target: gltf.nodes[target.node ?? 0],
+            path: target.path
+        }));
+        return { name, channels };
+    });
+}
+//
+function accessorToJsArray(accessor) {
+    if (!accessor._animation) {
+        const { typedArray: array, components } = accessorToTypedArray(accessor);
+        if (components === 1) {
+            accessor._animation = Array.from(array);
+        }
+        else {
+            // Slice array
+            const slicedArray = [];
+            for (let i = 0; i < array.length; i += components) {
+                slicedArray.push(Array.from(array.slice(i, i + components)));
+            }
+            accessor._animation = slicedArray;
+        }
+    }
+    return accessor._animation;
+}
+
+/** Deeply copies a JS data structure */
+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;
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function createScenegraphsFromGLTF(device, gltf, options) {
+    gltf = deepCopy(gltf);
+    const scenes = parseGLTF(device, gltf, options);
+    // Note: There is a nasty dependency on injected nodes in the glTF
+    const animations = parseGLTFAnimations(gltf);
+    const animator = new GLTFAnimator({ animations });
+    return { scenes, animator };
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+async function waitForGLTFAssets(gltfObjects) {
+    const remaining = [];
+    gltfObjects.scenes.forEach(scene => {
+        scene.traverse((modelNode) => {
+            // Not really clear how we can access the uniforms?
+            // TODO v9 getUnforms() was removed, hack it with props.uniforms
+            // Object.values((modelNode as ModelNode).model.uniforms).forEach((uniform: any) => {
+            //   if (uniform.loaded === false) {
+            //     remaining.push(uniform);
+            //   }
+            // });
+        });
+    });
+    return await waitWhileCondition(() => remaining.some(uniform => !uniform.loaded));
+}
+async function waitWhileCondition(condition) {
+    while (condition()) {
+        await new Promise(resolve => requestAnimationFrame(resolve));
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = `\
+uniform scenegraphUniforms {
+  float sizeScale;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  mat4 sceneModelMatrix;
+  bool composeModelMatrix;
+} scenegraph;
+`;
+const scenegraphUniforms = {
+    name: 'scenegraph',
+    vs: uniformBlock,
+    fs: uniformBlock,
+    uniformTypes: {
+        sizeScale: 'f32',
+        sizeMinPixels: 'f32',
+        sizeMaxPixels: 'f32',
+        sceneModelMatrix: 'mat4x4<f32>',
+        composeModelMatrix: 'f32'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var vs = `\
+#version 300 es
+#define SHADER_NAME scenegraph-layer-vertex-shader
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in vec4 instanceColors;
+in vec3 instancePickingColors;
+in vec3 instanceModelMatrixCol0;
+in vec3 instanceModelMatrixCol1;
+in vec3 instanceModelMatrixCol2;
+in vec3 instanceTranslation;
+in vec3 positions;
+#ifdef HAS_UV
+in vec2 texCoords;
+#endif
+#ifdef LIGHTING_PBR
+#ifdef HAS_NORMALS
+in vec3 normals;
+#endif
+#endif
+out vec4 vColor;
+#ifndef LIGHTING_PBR
+#ifdef HAS_UV
+out vec2 vTEXCOORD_0;
+#endif
+#endif
+void main(void) {
+#if defined(HAS_UV) && !defined(LIGHTING_PBR)
+vTEXCOORD_0 = texCoords;
+geometry.uv = texCoords;
+#endif
+geometry.worldPosition = instancePositions;
+geometry.pickingColor = instancePickingColors;
+mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
+vec3 normal = vec3(0.0, 0.0, 1.0);
+#ifdef LIGHTING_PBR
+#ifdef HAS_NORMALS
+normal = instanceModelMatrix * (scenegraph.sceneModelMatrix * vec4(normals, 0.0)).xyz;
+#endif
+#endif
+float originalSize = project_size_to_pixel(scenegraph.sizeScale);
+float clampedSize = clamp(originalSize, scenegraph.sizeMinPixels, scenegraph.sizeMaxPixels);
+vec3 pos = (instanceModelMatrix * (scenegraph.sceneModelMatrix * vec4(positions, 1.0)).xyz) * scenegraph.sizeScale * (clampedSize / originalSize) + instanceTranslation;
+if(scenegraph.composeModelMatrix) {
+DECKGL_FILTER_SIZE(pos, geometry);
+geometry.normal = project_normal(normal);
+geometry.worldPosition += pos;
+gl_Position = project_position_to_clipspace(pos + instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+}
+else {
+pos = project_size(pos);
+DECKGL_FILTER_SIZE(pos, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, pos, geometry.position);
+geometry.normal = project_normal(normal);
+}
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+#ifdef LIGHTING_PBR
+pbr_vPosition = geometry.position.xyz;
+#ifdef HAS_NORMALS
+pbr_vNormal = geometry.normal;
+#endif
+#ifdef HAS_UV
+pbr_vUV = texCoords;
+#else
+pbr_vUV = vec2(0., 0.);
+#endif
+geometry.uv = pbr_vUV;
+#endif
+vColor = instanceColors;
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var fs = `\
+#version 300 es
+#define SHADER_NAME scenegraph-layer-fragment-shader
+in vec4 vColor;
+out vec4 fragColor;
+#ifndef LIGHTING_PBR
+#if defined(HAS_UV) && defined(HAS_BASECOLORMAP)
+in vec2 vTEXCOORD_0;
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#endif
+void main(void) {
+#ifdef LIGHTING_PBR
+fragColor = vColor * pbr_filterColor(vec4(0));
+geometry.uv = pbr_vUV;
+#else
+#if defined(HAS_UV) && defined(HAS_BASECOLORMAP)
+fragColor = vColor * texture(pbr_baseColorSampler, vTEXCOORD_0);
+geometry.uv = vTEXCOORD_0;
+#else
+fragColor = vColor;
+#endif
+#endif
+fragColor.a *= layer.opacity;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_COLOR = [255, 255, 255, 255];
+const defaultProps = {
+    scenegraph: { type: 'object', value: null, async: true },
+    getScene: gltf => {
+        if (gltf && gltf.scenes) {
+            // gltf post processor replaces `gltf.scene` number with the scene `object`
+            return typeof gltf.scene === 'object' ? gltf.scene : gltf.scenes[gltf.scene || 0];
+        }
+        return gltf;
+    },
+    getAnimator: scenegraph => scenegraph && scenegraph.animator,
+    _animations: null,
+    sizeScale: { type: 'number', value: 1, min: 0 },
+    sizeMinPixels: { type: 'number', min: 0, value: 0 },
+    sizeMaxPixels: { type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER },
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    getColor: { type: 'accessor', value: DEFAULT_COLOR },
+    // flat or pbr
+    _lighting: 'flat',
+    // _lighting must be pbr for this to work
+    _imageBasedLightingEnvironment: undefined,
+    // yaw, pitch and roll are in degrees
+    // https://en.wikipedia.org/wiki/Euler_angles
+    // [pitch, yaw, roll]
+    getOrientation: { type: 'accessor', value: [0, 0, 0] },
+    getScale: { type: 'accessor', value: [1, 1, 1] },
+    getTranslation: { type: 'accessor', value: [0, 0, 0] },
+    // 4x4 matrix
+    getTransformMatrix: { type: 'accessor', value: [] },
+    loaders: [gltf.GLTFLoader]
+};
+/** Render a number of instances of a complete glTF scenegraph. */
+class ScenegraphLayer extends deckProvider.Layer {
+    getShaders() {
+        const defines = {};
+        let pbr;
+        if (this.props._lighting === 'pbr') {
+            pbr = pbrMaterial;
+            defines.LIGHTING_PBR = 1;
+        }
+        else {
+            // Dummy shader module needed to handle
+            // pbrMaterial.pbr_baseColorSampler binding
+            pbr = { name: 'pbrMaterial' };
+        }
+        const modules = [deckProvider.project32, deckProvider.picking, scenegraphUniforms, pbr];
+        return super.getShaders({ defines, vs, fs, modules });
+    }
+    initializeState() {
+        const attributeManager = this.getAttributeManager();
+        // attributeManager is always defined for primitive layers
+        attributeManager.addInstanced({
+            instancePositions: {
+                size: 3,
+                type: 'float64',
+                fp64: this.use64bitPositions(),
+                accessor: 'getPosition',
+                transition: true
+            },
+            instanceColors: {
+                type: 'unorm8',
+                size: this.props.colorFormat.length,
+                accessor: 'getColor',
+                defaultValue: DEFAULT_COLOR,
+                transition: true
+            },
+            instanceModelMatrix: deckProvider.MATRIX_ATTRIBUTES
+        });
+    }
+    updateState(params) {
+        super.updateState(params);
+        const { props, oldProps } = params;
+        if (props.scenegraph !== oldProps.scenegraph) {
+            this._updateScenegraph();
+        }
+        else if (props._animations !== oldProps._animations) {
+            this._applyAnimationsProp(this.state.animator, props._animations);
+        }
+    }
+    finalizeState(context) {
+        super.finalizeState(context);
+        this.state.scenegraph?.destroy();
+    }
+    get isLoaded() {
+        return Boolean(this.state?.scenegraph && super.isLoaded);
+    }
+    _updateScenegraph() {
+        const props = this.props;
+        const { device } = this.context;
+        let scenegraphData = null;
+        if (props.scenegraph instanceof ScenegraphNode) {
+            // Signature 1: props.scenegraph is a proper luma.gl Scenegraph
+            scenegraphData = { scenes: [props.scenegraph] };
+        }
+        else if (props.scenegraph && typeof props.scenegraph === 'object') {
+            // Converts loaders.gl gltf to luma.gl scenegraph using the undocumented @luma.gl/experimental function
+            const gltf$1 = props.scenegraph;
+            // Tiles3DLoader already processes GLTF
+            const processedGLTF = gltf$1.json ? gltf.postProcessGLTF(gltf$1) : gltf$1;
+            const gltfObjects = createScenegraphsFromGLTF(device, processedGLTF, this._getModelOptions());
+            scenegraphData = { gltf: processedGLTF, ...gltfObjects };
+            waitForGLTFAssets(gltfObjects)
+                .then(() => {
+                this.setNeedsRedraw();
+            })
+                .catch(ex => {
+                this.raiseError(ex, 'loading glTF');
+            });
+        }
+        const options = { layer: this, device: this.context.device };
+        const scenegraph = props.getScene(scenegraphData, options);
+        const animator = props.getAnimator(scenegraphData, options);
+        if (scenegraph instanceof GroupNode) {
+            this.state.scenegraph?.destroy();
+            this._applyAnimationsProp(animator, props._animations);
+            const models = [];
+            scenegraph.traverse(node => {
+                if (node instanceof ModelNode) {
+                    models.push(node.model);
+                }
+            });
+            this.setState({ scenegraph, animator, models });
+            this.getAttributeManager().invalidateAll();
+        }
+        else if (scenegraph !== null) {
+            deckProvider.defaultLogger.warn('invalid scenegraph:', scenegraph)();
+        }
+    }
+    _applyAnimationsProp(animator, animationsProp) {
+        if (!animator || !animationsProp) {
+            return;
+        }
+        const animations = animator.getAnimations();
+        // sort() to ensure '*' comes first so that other values can override
+        Object.keys(animationsProp)
+            .sort()
+            .forEach(key => {
+            // Key can be:
+            //  - number for index number
+            //  - name for animation name
+            //  - * to affect all animations
+            const value = animationsProp[key];
+            if (key === '*') {
+                animations.forEach(animation => {
+                    Object.assign(animation, value);
+                });
+            }
+            else if (Number.isFinite(Number(key))) {
+                const number = Number(key);
+                if (number >= 0 && number < animations.length) {
+                    Object.assign(animations[number], value);
+                }
+                else {
+                    deckProvider.defaultLogger.warn(`animation ${key} not found`)();
+                }
+            }
+            else {
+                const findResult = animations.find(({ animation }) => animation.name === key);
+                if (findResult) {
+                    Object.assign(findResult, value);
+                }
+                else {
+                    deckProvider.defaultLogger.warn(`animation ${key} not found`)();
+                }
+            }
+        });
+    }
+    _getModelOptions() {
+        const { _imageBasedLightingEnvironment } = this.props;
+        let env;
+        if (_imageBasedLightingEnvironment) {
+            if (typeof _imageBasedLightingEnvironment === 'function') {
+                env = _imageBasedLightingEnvironment({ gl: this.context.gl, layer: this });
+            }
+            else {
+                env = _imageBasedLightingEnvironment;
+            }
+        }
+        return {
+            imageBasedLightingEnvironment: env,
+            modelOptions: {
+                id: this.props.id,
+                isInstanced: true,
+                bufferLayout: this.getAttributeManager().getBufferLayouts(),
+                ...this.getShaders()
+            },
+            // tangents are not supported
+            useTangents: false
+        };
+    }
+    draw({ context }) {
+        if (!this.state.scenegraph)
+            return;
+        if (this.props._animations && this.state.animator) {
+            this.state.animator.animate(context.timeline.getTime());
+            this.setNeedsRedraw();
+        }
+        const { viewport, renderPass } = this.context;
+        const { sizeScale, sizeMinPixels, sizeMaxPixels, coordinateSystem } = this.props;
+        const pbrProjectionProps = {
+            camera: viewport.cameraPosition
+        };
+        const numInstances = this.getNumInstances();
+        this.state.scenegraph.traverse((node, { worldMatrix }) => {
+            if (node instanceof ModelNode) {
+                const { model } = node;
+                model.setInstanceCount(numInstances);
+                const scenegraphProps = {
+                    sizeScale,
+                    sizeMinPixels,
+                    sizeMaxPixels,
+                    composeModelMatrix: deckProvider.shouldComposeModelMatrix(viewport, coordinateSystem),
+                    sceneModelMatrix: worldMatrix
+                };
+                model.shaderInputs.setProps({
+                    pbrProjection: pbrProjectionProps,
+                    scenegraph: scenegraphProps
+                });
+                model.draw(renderPass);
+            }
+        });
+    }
+}
+ScenegraphLayer.defaultProps = defaultProps;
+ScenegraphLayer.layerName = 'ScenegraphLayer';
+
+exports.ScenegraphLayer = ScenegraphLayer;
+exports.parsePBRMaterial = parsePBRMaterial;
+exports.pbrMaterial = pbrMaterial;