@deck.gl/arcgis 9.0.0-beta.8 → 9.0.0

package/dist/dist.dev.js

@@ -71,7 +71,7 @@ var __exports__ = (() => {
         var utils = {
           Promise: isBrowser2 ? window["Promise"] : void 0
         };
-        var DEFAULT_VERSION = "4.21";
+        var DEFAULT_VERSION = "4.25";
         var NEXT = "next";
         function parseVersion(version) {
           if (version.toLowerCase() === NEXT) {
@@ -87,7 +87,7 @@ var __exports__ = (() => {
           if (version === void 0) {
             version = DEFAULT_VERSION;
           }
-          return "https://js.arcgis.com/" + version + "/";
+          return "https://js.arcgis.com/".concat(version, "/");
         }
         function getCdnCssUrl(version) {
           if (version === void 0) {
@@ -97,9 +97,9 @@ var __exports__ = (() => {
           var parsedVersion = parseVersion(version);
           if (parsedVersion !== NEXT && parsedVersion.major === 3) {
             var path = parsedVersion.minor <= 10 ? "js/" : "";
-            return "" + baseUrl + path + "esri/css/esri.css";
+            return "".concat(baseUrl).concat(path, "esri/css/esri.css");
           } else {
-            return baseUrl + "esri/themes/light/main.css";
+            return "".concat(baseUrl, "esri/themes/light/main.css");
           }
         }
         function createStylesheetLink(href) {
@@ -117,7 +117,7 @@ var __exports__ = (() => {
           }
         }
         function getCss(url) {
-          return document.querySelector('link[href*="' + url + '"]');
+          return document.querySelector('link[href*="'.concat(url, '"]'));
         }
         function getCssUrl(urlOrVersion) {
           return !urlOrVersion || parseVersion(urlOrVersion) ? getCdnCssUrl(urlOrVersion) : urlOrVersion;
@@ -155,7 +155,7 @@ var __exports__ = (() => {
         }
         function handleScriptError(script, callback) {
           var onScriptError = function(e) {
-            callback(e.error || new Error("There was an error attempting to load " + script.src));
+            callback(e.error || new Error("There was an error attempting to load ".concat(script.src)));
             script.removeEventListener("error", onScriptError, false);
           };
           script.addEventListener("error", onScriptError, false);
@@ -193,7 +193,7 @@ var __exports__ = (() => {
             if (script) {
               var src = script.getAttribute("src");
               if (src !== url) {
-                reject(new Error("The ArcGIS API for JavaScript is already loaded (" + src + ")."));
+                reject(new Error("The ArcGIS API for JavaScript is already loaded (".concat(src, ").")));
               } else {
                 if (isLoaded()) {
                   resolve(script);
@@ -279,7 +279,7 @@ var __exports__ = (() => {
   // bundle.ts
   __reExport(bundle_exports, peer_dependency_exports);
 
-  // src/deck-props.js
+  // dist/deck-props.js
   var properties = {
     layers: {},
     layerFilter: {},
@@ -333,7 +333,7 @@ var __exports__ = (() => {
     return DeckProps;
   }
 
-  // src/deck-layer.js
+  // dist/deck-layer.js
   function createDeckLayer(DeckProps, Layer2, DeckLayerView2D) {
     return Layer2.createSubclass({
       properties: {
@@ -351,9 +351,7 @@ var __exports__ = (() => {
             layer: this
           });
         }
-        console.error(
-          "DeckLayer does not support SceneView at the moment. Use DeckRenderer instead."
-        );
+        console.error("DeckLayer does not support SceneView at the moment. Use DeckRenderer instead.");
         return null;
       }
     });
@@ -1506,6 +1504,9 @@ var __exports__ = (() => {
     }
     return state;
   }
+  function resetGLParameters(gl) {
+    setGLParameters(gl, GL_PARAMETER_DEFAULTS);
+  }
   function isObjectEmpty(object) {
     for (const key in object) {
       return false;
@@ -2196,12 +2197,8 @@ var __exports__ = (() => {
       getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
     }
     *[Symbol.iterator]() {
-      for (const feature of Object.keys(WEBGL_FEATURES)) {
-        if (this.has(feature)) {
-          yield feature;
-        }
-      }
-      for (const feature of Object.keys(TEXTURE_FEATURES)) {
+      const features = this.getFeatures();
+      for (const feature of features) {
         if (this.has(feature)) {
           yield feature;
         }
@@ -2224,9 +2221,14 @@ var __exports__ = (() => {
       return this.features.has(feature);
     }
     initializeFeatures() {
-      for (const feature of this) {
+      const features = this.getFeatures().filter((feature) => feature !== "polygon-mode-webgl");
+      for (const feature of features) {
+        this.has(feature);
       }
     }
+    getFeatures() {
+      return [...Object.keys(WEBGL_FEATURES), ...Object.keys(TEXTURE_FEATURES)];
+    }
     getWebGLFeature(feature) {
       const featureInfo = WEBGL_FEATURES[feature];
       const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo);
@@ -2429,9 +2431,9 @@ var __exports__ = (() => {
       const extensions = webglDevice.getExtension("WEBGL_polygon_mode");
       const ext = extensions.WEBGL_polygon_mode;
       if (parameters.polygonMode) {
-        const mode = map("polygonMode", parameters.provokingVertex, {
+        const mode = map("polygonMode", parameters.polygonMode, {
           fill: 6914,
-          lint: 6913
+          line: 6913
         });
         ext?.polygonModeWEBGL(1028, mode);
         ext?.polygonModeWEBGL(1029, mode);
@@ -2551,7 +2553,12 @@ var __exports__ = (() => {
       "src-alpha": 770,
       "one-minus-src-alpha": 771,
       "dst-alpha": 772,
-      "one-minus-dst-alpha": 773
+      "one-minus-dst-alpha": 773,
+      "src-alpha-saturated": 776,
+      "constant-color": 32769,
+      "one-minus-constant-color": 32770,
+      "constant-alpha": 32771,
+      "one-minus-constant-alpha": 32772
     });
   }
   function message(parameter, value) {
@@ -3338,7 +3345,7 @@ var __exports__ = (() => {
       if (!isDefaultFramebuffer) {
         device.setSpectorMetadata(this.handle, { id: this.props.id, props: this.props });
         this.autoCreateAttachmentTextures();
-        this.gl.bindFramebuffer(36160, this.handle);
+        const prevHandle = this.gl.bindFramebuffer(36160, this.handle);
         for (let i = 0; i < this.colorAttachments.length; ++i) {
           const attachment = this.colorAttachments[i];
           const attachmentPoint = 36064 + i;
@@ -3355,7 +3362,7 @@ var __exports__ = (() => {
             throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
           }
         }
-        this.gl.bindFramebuffer(36160, null);
+        this.gl.bindFramebuffer(36160, prevHandle);
       }
     }
     destroy() {
@@ -3790,10 +3797,10 @@ ${source2}`;
       }
       if (!this.device.features.has("compilation-status-async-webgl")) {
         this._getCompilationStatus();
+        this.debugShader();
         if (this.compilationStatus === "error") {
           throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
         }
-        this.debugShader();
         return;
       }
       import_core15.log.once(1, "Shader compilation is asynchronous")();
@@ -3829,6 +3836,7 @@ ${source2}`;
   var GL_STENCIL_BUFFER_BIT = 1024;
   var GL_COLOR_BUFFER_BIT = 16384;
   var GL_COLOR = 6144;
+  var COLOR_CHANNELS = [1, 2, 4, 8];
   var WEBGLRenderPass = class extends import_core16.RenderPass {
     device;
     glParameters;
@@ -3869,8 +3877,8 @@ ${source2}`;
           glParameters.viewport = parameters.viewport;
         }
       }
-      glParameters.scissorTest = Boolean(parameters.scissorRect);
       if (parameters.scissorRect) {
+        glParameters.scissorTest = true;
         glParameters.scissor = parameters.scissorRect;
       }
       if (parameters.blendConstant) {
@@ -3880,6 +3888,9 @@ ${source2}`;
         console.warn("RenderPassParameters.stencilReference not yet implemented in WebGL");
         parameters[2967] = parameters.stencilReference;
       }
+      if (parameters.colorMask) {
+        glParameters.colorMask = COLOR_CHANNELS.map((channel) => Boolean(channel & parameters.colorMask));
+      }
       this.glParameters = glParameters;
       setGLParameters(this.device.gl, glParameters);
     }
@@ -4532,9 +4543,9 @@ ${source2}`;
         this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
       }
       this._linkShaders();
-      import_core18.log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      import_core18.log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-      import_core18.log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+      import_core18.log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
       this.shaderLayout = (0, import_core19.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
       switch (this.props.topology) {
         case "triangle-fan-webgl":
@@ -4550,12 +4561,14 @@ ${source2}`;
         this.destroyed = true;
       }
     }
-    setBindings(bindings) {
+    setBindings(bindings, options) {
       for (const [name, value] of Object.entries(bindings)) {
         const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name}Uniforms`);
         if (!binding) {
           const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
-          import_core18.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+          if (options?.disableWarnings) {
+            import_core18.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+          }
           continue;
         }
         if (!value) {
@@ -4584,13 +4597,15 @@ ${source2}`;
     draw(options) {
       const {
         renderPass,
+        parameters = this.props.parameters,
+        topology = this.props.topology,
         vertexArray,
         vertexCount,
         instanceCount,
         firstVertex = 0,
         transformFeedback
       } = options;
-      const glDrawMode = getGLDrawMode(this.props.topology);
+      const glDrawMode = getGLDrawMode(topology);
       const isIndexed = Boolean(vertexArray.indexBuffer);
       const glIndexType = vertexArray.indexBuffer?.glIndexType;
       const isInstanced = Number(instanceCount) > 0;
@@ -4614,7 +4629,7 @@ ${source2}`;
       this._applyBindings();
       this._applyUniforms();
       const webglRenderPass = renderPass;
-      withDeviceAndGLParameters(this.device, this.props.parameters, webglRenderPass.glParameters, () => {
+      withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => {
         if (isIndexed && isInstanced) {
           this.device.gl.drawElementsInstanced(
             glDrawMode,
@@ -4861,6 +4876,7 @@ ${source2}`;
       throw new Error("not implemented");
     }
     const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+    let prevHandle;
     try {
       const webglBuffer = destination;
       const sourceWidth = width || framebuffer.width;
@@ -4869,11 +4885,13 @@ ${source2}`;
       const sourceFormat = sourceParams.dataFormat;
       const sourceType = sourceParams.type;
       device.gl.bindBuffer(35051, webglBuffer.handle);
-      device.gl.bindFramebuffer(36160, framebuffer.handle);
+      prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
       device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
     } finally {
       device.gl.bindBuffer(35051, null);
-      device.gl.bindFramebuffer(36160, null);
+      if (prevHandle !== void 0) {
+        device.gl.bindFramebuffer(36160, prevHandle);
+      }
       if (destroyFramebuffer) {
         framebuffer.destroy();
       }
@@ -4882,19 +4900,19 @@ ${source2}`;
   function _copyTextureToTexture(device, options) {
     const {
       source,
+      destinationMipLevel = 0,
       origin = [0, 0],
+      destinationOrigin = [0, 0],
       destination
     } = options;
     let {
       width = options.destination.width,
-      height = options.destination.width
+      height = options.destination.height
     } = options;
-    const destinationMipmaplevel = 0;
-    const destinationInternalFormat = 6408;
     const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
     const [sourceX, sourceY] = origin;
-    const isSubCopy = false;
-    device.gl.bindFramebuffer(36160, framebuffer.handle);
+    const [destinationX, destinationY, destinationZ] = destinationOrigin;
+    const prevHandle = device.gl.bindFramebuffer(36160, framebuffer.handle);
     let texture = null;
     let textureTarget;
     if (destination instanceof WEBGLTexture) {
@@ -4902,21 +4920,28 @@ ${source2}`;
       width = Number.isFinite(width) ? width : texture.width;
       height = Number.isFinite(height) ? height : texture.height;
       texture.bind(0);
-      textureTarget = texture.destination;
+      textureTarget = texture.target;
     } else {
-      throw new Error("whoops");
+      throw new Error("invalid destination");
     }
-    if (!isSubCopy) {
-      device.gl.copyTexImage2D(textureTarget, destinationMipmaplevel, destinationInternalFormat, sourceX, sourceY, width, height, 0);
-    } else {
+    switch (textureTarget) {
+      case 3553:
+      case 34067:
+        device.gl.copyTexSubImage2D(textureTarget, destinationMipLevel, destinationX, destinationY, sourceX, sourceY, width, height);
+        break;
+      case 35866:
+      case 32879:
+        device.gl.copyTexSubImage3D(textureTarget, destinationMipLevel, destinationX, destinationY, destinationZ, sourceX, sourceY, width, height);
+        break;
+      default:
     }
     if (texture) {
       texture.unbind();
     }
+    device.gl.bindFramebuffer(36160, prevHandle);
     if (destroyFramebuffer) {
       framebuffer.destroy();
     }
-    return texture;
   }
   function getFramebuffer(source) {
     if (source instanceof import_core20.Texture) {
@@ -5004,6 +5029,7 @@ ${source2}`;
       this.device.gl.bindVertexArray(this.handle);
       this.device.gl.bindBuffer(34963, buffer ? buffer.handle : null);
       this.indexBuffer = buffer;
+      this.device.gl.bindVertexArray(null);
     }
     setBuffer(location, attributeBuffer) {
       const buffer = attributeBuffer;
@@ -5021,19 +5047,14 @@ ${source2}`;
       this.device.gl.enableVertexAttribArray(location);
       this.device.gl.vertexAttribDivisor(location, divisor || 0);
       this.attributes[location] = buffer;
+      this.device.gl.bindVertexArray(null);
     }
     setConstantWebGL(location, value) {
       this._enable(location, false);
       this.attributes[location] = value;
     }
-    init = false;
     bindBeforeRender() {
       this.device.gl.bindVertexArray(this.handle);
-      if (!this.init) {
-        const webglBuffer = this.indexBuffer;
-        this.device.gl.bindBuffer(34963, webglBuffer?.handle || null);
-        this.init = true;
-      }
       this._applyConstantAttributes();
     }
     unbindAfterRender() {
@@ -5708,11 +5729,15 @@ ${source2}`;
       return getGLParameters(this.gl, parameters);
     }
     withParametersWebGL(parameters, func) {
-      withGLParameters(this.gl, parameters, func);
+      return withGLParameters(this.gl, parameters, func);
     }
     clearWebGL(options) {
       clear(this, options);
     }
+    resetWebGL() {
+      import_core28.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+      resetGLParameters(this.gl);
+    }
     gl;
     debug = false;
     _canvasSizeInfo = { clientWidth: 0, clientHeight: 0, devicePixelRatio: 1 };
@@ -5824,11 +5849,11 @@ ${source2}`;
     return true;
   }
 
-  // src/commons.ts
+  // dist/commons.js
   var import_engine = __toESM(require_engine(), 1);
   var import_core29 = __toESM(require_core(), 1);
   function initializeResources(device) {
-    const deckglTexture = device.createTexture({
+    const texture = device.createTexture({
       format: "rgba8unorm",
       width: 1,
       height: 1,
@@ -5839,15 +5864,13 @@ ${source2}`;
         addressModeV: "clamp-to-edge"
       }
     });
-    this.deckglTexture = deckglTexture;
-    this.buffer = device.createBuffer(new Int8Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1]));
-    this.model = new import_engine.Model(device, {
+    const model = new import_engine.Model(device, {
       vs: `#version 300 es
-in vec2 a_pos;
+in vec2 pos;
 out vec2 v_texcoord;
 void main(void) {
-    gl_Position = vec4(a_pos, 0.0, 1.0);
-    v_texcoord = (a_pos + 1.0) / 2.0;
+    gl_Position = vec4(pos, 0.0, 1.0);
+    v_texcoord = (pos + 1.0) / 2.0;
 }
     `,
       fs: `#version 300 es
@@ -5862,124 +5885,115 @@ void main(void) {
     fragColor = imageColor;
 }
     `,
-      bufferLayout: [{ name: "a_pos", format: "sint8x2" }],
       bindings: {
-        deckglTexture
+        deckglTexture: texture
       },
       parameters: {
         depthWriteEnabled: true,
         depthCompare: "less-equal"
       },
-      attributes: {
-        a_pos: this.buffer
-      },
-      vertexCount: 6,
-      topology: "triangle-strip"
+      geometry: new import_engine.Geometry({
+        topology: "triangle-strip",
+        attributes: {
+          pos: { size: 2, value: new Int8Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1]) }
+        }
+      }),
+      vertexCount: 6
     });
-    this.deckFbo = device.createFramebuffer({
+    const fbo = device.createFramebuffer({
       id: "deckfbo",
       width: 1,
       height: 1,
-      colorAttachments: [deckglTexture]
+      colorAttachments: [texture]
     });
-    this.deckInstance = new import_core29.Deck({
+    const deckInstance = new import_core29.Deck({
       viewState: {},
       controller: false,
-      gl: device.gl,
+      device,
       parameters: {
         depthTest: true
       },
-      _framebuffer: this.deckFbo,
+      _framebuffer: fbo,
       width: null,
       height: null,
       _customRender: (redrawReason) => {
         if (redrawReason === "arcgis") {
-          this.deckInstance._drawLayers(redrawReason);
+          deckInstance._drawLayers(redrawReason);
         } else {
           this.redraw();
         }
       }
     });
+    return { deck: deckInstance, texture, fbo, model };
   }
-  function render({ gl, width, height, viewState }) {
-    const screenFbo = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+  function render(resources, viewport) {
+    const { model, deck, fbo } = resources;
+    const device = model.device;
+    const screenFbo = device.getParametersWebGL(36006);
+    const { width, height, ...viewState } = viewport;
     const dpr = window.devicePixelRatio;
-    width = Math.round(width * dpr);
-    height = Math.round(height * dpr);
-    this.deckFbo.resize({ width, height });
-    this.deckInstance.setProps({ viewState });
-    this.deckInstance.redraw("arcgis");
-    const device = this.deckInstance.device;
+    const pixelWidth = Math.round(width * dpr);
+    const pixelHeight = Math.round(height * dpr);
+    fbo.resize({ width: pixelWidth, height: pixelHeight });
+    deck.setProps({ viewState });
+    deck.redraw("arcgis");
     const textureToScreenPass = device.beginRenderPass({
       framebuffer: screenFbo,
-      parameters: { viewport: [0, 0, width, height] },
+      parameters: { viewport: [0, 0, pixelWidth, pixelHeight] },
       clearColor: [0, 0, 0, 0],
       clearDepth: 1
     });
-    device.withParametersWebGL(
-      {
-        blend: true,
-        blendFunc: [gl.ONE, gl.ONE_MINUS_SRC_ALPHA]
-      },
-      () => {
-        this.model.setBindings({
-          deckglTexture: this.deckFbo.colorAttachments[0]
-        });
-        this.model.draw(textureToScreenPass);
-      }
-    );
+    device.withParametersWebGL({
+      blend: true,
+      blendFunc: [1, 771]
+    }, () => {
+      model.draw(textureToScreenPass);
+    });
   }
-  function finalizeResources() {
-    this.deckInstance?.finalize();
-    this.deckInstance = null;
-    this.model?.delete();
-    this.buffer?.delete();
-    this.deckFbo?.delete();
-    this.deckglTexture?.delete();
+  function finalizeResources(resources) {
+    resources.deck.finalize();
+    resources.model.destroy();
+    resources.fbo.destroy();
+    resources.texture.destroy();
   }
 
-  // src/deck-layer-view-2d.js
+  // dist/deck-layer-view-2d.js
   function createDeckLayerView2D(BaseLayerViewGL2D) {
     return BaseLayerViewGL2D.createSubclass({
       properties: {
-        deckgl: {},
-        deckFbo: {},
-        model: {},
-        buffer: {}
+        resources: null
       },
       attach() {
         const gl = this.context;
         const device = WebGLDevice.attach(gl);
-        initializeResources.call(this, device);
-        this.layer.deck.on("change", (props) => this.deckInstance.setProps(props));
-        this.deckInstance.setProps(this.layer.deck.toJSON());
+        this.resources = initializeResources.call(this, device);
+        this.layer.deck.on("change", (props) => this.resources.deck.setProps(props));
+        this.resources.deck.setProps(this.layer.deck.toJSON());
       },
       redraw() {
         this.requestRender();
       },
       detach() {
-        finalizeResources.call(this);
+        finalizeResources(this.resources);
+        this.resources = null;
       },
       render(renderParameters) {
         const [width, height] = this.view.state.size;
         const state = renderParameters.state;
-        render.call(this, {
-          gl: renderParameters.context,
+        render(this.resources, {
           width,
           height,
-          viewState: {
-            latitude: this.view.center.latitude,
-            longitude: this.view.center.longitude,
-            zoom: this.view.featuresTilingScheme.scaleToLevel(state.scale),
-            bearing: -state.rotation,
-            pitch: 0
-          }
+          latitude: this.view.center.latitude,
+          longitude: this.view.center.longitude,
+          zoom: this.view.featuresTilingScheme.scaleToLevel(state.scale),
+          bearing: -state.rotation,
+          pitch: 0
         });
       }
     });
   }
 
-  // src/deck-renderer.js
+  // dist/deck-renderer.js
   function arcgisFOVToDeckAltitude(fov, aspectRatio) {
     const D = Math.sqrt(1 + aspectRatio ** 2);
     const halfFOV = fov / 2 / 180 * Math.PI;
@@ -5988,44 +6002,46 @@ void main(void) {
   function createDeckRenderer(DeckProps, externalRenderers) {
     class DeckRenderer {
       constructor(view, props) {
+        this.resources = null;
         this.view = view;
         this.deck = new DeckProps(props);
       }
       setup(context) {
         const gl = context.gl;
-        initializeResources.call(this, gl);
-        this.deck.on("change", (props) => this.deckInstance.setProps(props));
-        this.deckInstance.setProps(this.deck.toJSON());
+        const device = WebGLDevice.attach(gl);
+        const resources = initializeResources.call(this, device);
+        this.deck.on("change", (props) => resources.deck.setProps(props));
+        resources.deck.setProps(this.deck.toJSON());
+        this.resources = resources;
       }
       dispose() {
-        finalizeResources.call(this);
+        if (this.resources) {
+          finalizeResources(this.resources);
+        }
       }
       redraw() {
         externalRenderers.requestRender(this.view);
       }
-      render(context) {
+      render() {
         const [width, height] = this.view.size;
-        render.call(this, {
-          gl: context.gl,
+        render(this.resources, {
           width,
           height,
-          viewState: {
-            latitude: this.view.center.latitude,
-            longitude: this.view.center.longitude,
-            altitude: arcgisFOVToDeckAltitude(this.view.camera.fov, width / height),
-            zoom: this.view.zoom,
-            bearing: this.view.camera.heading,
-            pitch: this.view.camera.tilt
-          }
+          latitude: this.view.center.latitude,
+          longitude: this.view.center.longitude,
+          altitude: arcgisFOVToDeckAltitude(this.view.camera.fov, width / height),
+          zoom: this.view.zoom,
+          bearing: this.view.camera.heading,
+          pitch: this.view.camera.tilt
         });
       }
     }
     return DeckRenderer;
   }
 
-  // src/load-modules.js
+  // dist/load-modules.js
   var import_esri_loader = __toESM(require_esri_loader(), 1);
-  var arcGIS = null;
+  var arcGIS;
   async function loadArcGISModules(modules, loadScriptOptions) {
     const namespace = Array.isArray(modules) ? null : modules;
     await loadArcGISModule(namespace, loadScriptOptions);
@@ -6036,28 +6052,24 @@ void main(void) {
     }
     return arcGIS;
   }
-  function loadArcGISModule(esri, loadScriptOptions) {
+  async function loadArcGISModule(esri, loadScriptOptions) {
     if (arcGIS) {
       return arcGIS;
     }
     if (esri) {
-      const Layer2 = esri.layers.Layer;
-      const Accessor2 = esri.core.Accessor;
-      const BaseLayerViewGL2D = esri.views["2d"].layers.BaseLayerViewGL2D;
-      const externalRenderers = esri.views["3d"].externalRenderers;
-      return initialize(Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers);
-    }
-    return (0, import_esri_loader.loadModules)(
-      [
-        "esri/layers/Layer",
-        "esri/core/Accessor",
-        "esri/views/2d/layers/BaseLayerViewGL2D",
-        "esri/views/3d/externalRenderers"
-      ],
-      loadScriptOptions
-    ).then(([Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers]) => {
-      return initialize(Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers);
-    });
+      const Layer3 = esri.layers.Layer;
+      const Accessor3 = esri.core.Accessor;
+      const BaseLayerViewGL2D2 = esri.views["2d"].layers.BaseLayerViewGL2D;
+      const externalRenderers2 = esri.views["3d"].externalRenderers;
+      return initialize(Layer3, Accessor3, BaseLayerViewGL2D2, externalRenderers2);
+    }
+    const [Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers] = await (0, import_esri_loader.loadModules)([
+      "esri/layers/Layer",
+      "esri/core/Accessor",
+      "esri/views/2d/layers/BaseLayerViewGL2D",
+      "esri/views/3d/externalRenderers"
+    ], loadScriptOptions);
+    return initialize(Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers);
   }
   function initialize(Layer2, Accessor2, BaseLayerViewGL2D, externalRenderers) {
     const DeckProps = createDeckProps(Accessor2);