@deck.gl/arcgis 9.4.0-beta.1 → 9.4.0-beta.4

package/dist/dist.dev.js

@@ -3213,245 +3213,6 @@ Source: ${sourceLine}` : "";
     }
   });
 
-  // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js
-  function mergeShaderLayout(baseLayout, overrideLayout) {
-    const mergedLayout = {
-      ...baseLayout,
-      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })),
-      bindings: baseLayout.bindings.map((binding) => ({ ...binding }))
-    };
-    for (const attribute of overrideLayout?.attributes || []) {
-      const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
-      if (!baseAttribute) {
-        import_core15.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-      } else {
-        baseAttribute.type = attribute.type || baseAttribute.type;
-        baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-      }
-    }
-    for (const binding of overrideLayout?.bindings || []) {
-      const baseBinding = getShaderLayoutBindingByName(mergedLayout, binding.name);
-      if (!baseBinding) {
-        import_core15.log.warn(`shader layout binding ${binding.name} not present in shader`);
-        continue;
-      }
-      Object.assign(baseBinding, binding);
-    }
-    return mergedLayout;
-  }
-  function getShaderLayoutBindingByName(shaderLayout, bindingName) {
-    return shaderLayout.bindings.find((binding) => binding.name === bindingName || binding.name === `${bindingName}Uniforms` || `${binding.name}Uniforms` === bindingName);
-  }
-  function getBindingValueForLayoutBinding(bindings, bindingName) {
-    return bindings[bindingName] || bindings[`${bindingName}Uniforms`] || bindings[bindingName.replace(/Uniforms$/, "")];
-  }
-  var import_core15, WEBGLRenderPipeline;
-  var init_webgl_render_pipeline = __esm({
-    "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js"() {
-      import_core15 = __toESM(require_core2(), 1);
-      init_set_uniform();
-      init_webgl_buffer();
-      init_webgl_framebuffer();
-      init_webgl_texture();
-      init_webgl_texture_view();
-      WEBGLRenderPipeline = class extends import_core15.RenderPipeline {
-        /** The WebGL device that created this render pipeline */
-        device;
-        /** Handle to underlying WebGL program */
-        handle;
-        /** vertex shader */
-        vs;
-        /** fragment shader */
-        fs;
-        /** The layout extracted from shader by WebGL introspection APIs */
-        introspectedLayout;
-        /** Compatibility path for direct pipeline.setBindings() usage */
-        bindings = {};
-        /** Compatibility path for direct pipeline.uniforms usage */
-        uniforms = {};
-        /** WebGL varyings */
-        varyings = null;
-        _uniformCount = 0;
-        _uniformSetters = {};
-        // TODO are these used?
-        get [Symbol.toStringTag]() {
-          return "WEBGLRenderPipeline";
-        }
-        constructor(device, props) {
-          super(device, props);
-          this.device = device;
-          const webglSharedRenderPipeline = this.sharedRenderPipeline || this.device._createSharedRenderPipelineWebGL(props);
-          this.sharedRenderPipeline = webglSharedRenderPipeline;
-          this.handle = webglSharedRenderPipeline.handle;
-          this.vs = webglSharedRenderPipeline.vs;
-          this.fs = webglSharedRenderPipeline.fs;
-          this.linkStatus = webglSharedRenderPipeline.linkStatus;
-          this.introspectedLayout = webglSharedRenderPipeline.introspectedLayout;
-          this.device._setWebGLDebugMetadata(this.handle, this, { spector: { id: this.props.id } });
-          this.shaderLayout = props.shaderLayout ? mergeShaderLayout(this.introspectedLayout, props.shaderLayout) : this.introspectedLayout;
-        }
-        destroy() {
-          if (this.destroyed) {
-            return;
-          }
-          if (this.sharedRenderPipeline && !this.props._sharedRenderPipeline) {
-            this.sharedRenderPipeline.destroy();
-          }
-          this.destroyResource();
-        }
-        /** @deprecated Set bindings on RenderPass instead. Will be removed in the next major release. */
-        setBindings(bindings, options) {
-          const flatBindings = (0, import_core15.flattenBindingsByGroup)((0, import_core15.normalizeBindingsByGroup)(this.shaderLayout, bindings));
-          for (const [name, value] of Object.entries(flatBindings)) {
-            const binding = getShaderLayoutBindingByName(this.shaderLayout, name);
-            if (!binding) {
-              const validBindings = this.shaderLayout.bindings.map((binding_) => `"${binding_.name}"`).join(", ");
-              if (!options?.disableWarnings) {
-                import_core15.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
-              }
-            } else {
-              if (!value) {
-                import_core15.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
-              }
-              switch (binding.type) {
-                case "uniform":
-                  if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
-                    throw new Error("buffer value");
-                  }
-                  break;
-                case "texture":
-                  if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
-                    throw new Error(`${this} Bad texture binding for ${name}`);
-                  }
-                  break;
-                case "sampler":
-                  import_core15.log.warn(`Ignoring sampler ${name}`)();
-                  break;
-                default:
-                  throw new Error(binding.type);
-              }
-              this.bindings[name] = value;
-            }
-          }
-        }
-        /** @todo needed for portable model
-         * @note The WebGL API is offers many ways to draw things
-         * This function unifies those ways into a single call using common parameters with sane defaults
-         */
-        draw(options) {
-          const webglRenderPass = options.renderPass;
-          const drawBindings = options.bindGroups ? (0, import_core15.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
-          webglRenderPass.setPipeline(this);
-          webglRenderPass.setBindings(drawBindings);
-          webglRenderPass.setVertexArray(options.vertexArray);
-          return webglRenderPass.draw({
-            parameters: options.parameters,
-            topology: options.topology,
-            isInstanced: options.isInstanced,
-            vertexCount: options.vertexCount,
-            indexCount: options.indexCount,
-            instanceCount: options.instanceCount,
-            firstVertex: options.firstVertex,
-            firstIndex: options.firstIndex,
-            firstInstance: options.firstInstance,
-            baseVertex: options.baseVertex,
-            transformFeedback: options.transformFeedback,
-            uniforms: options.uniforms
-          });
-        }
-        /**
-         * Checks if all texture-values uniforms are renderable (i.e. loaded)
-         * Update a texture if needed (e.g. from video)
-         * Note: This is currently done before every draw call
-         */
-        _areTexturesRenderable(bindings) {
-          let texturesRenderable = true;
-          for (const bindingInfo of this.shaderLayout.bindings) {
-            if (!getBindingValueForLayoutBinding(bindings, bindingInfo.name)) {
-              import_core15.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
-              texturesRenderable = false;
-            }
-          }
-          return texturesRenderable;
-        }
-        /** Apply any bindings (before each draw call) */
-        _applyBindings(bindings, _options) {
-          this._syncLinkStatus();
-          if (this.linkStatus !== "success") {
-            return;
-          }
-          const { gl } = this.device;
-          gl.useProgram(this.handle);
-          let textureUnit = 0;
-          let uniformBufferIndex = 0;
-          for (const binding of this.shaderLayout.bindings) {
-            const value = getBindingValueForLayoutBinding(bindings, binding.name);
-            if (!value) {
-              throw new Error(`No value for binding ${binding.name} in ${this.id}`);
-            }
-            switch (binding.type) {
-              case "uniform":
-                const { name } = binding;
-                const location = gl.getUniformBlockIndex(this.handle, name);
-                if (location === 4294967295) {
-                  throw new Error(`Invalid uniform block name ${name}`);
-                }
-                gl.uniformBlockBinding(this.handle, location, uniformBufferIndex);
-                if (value instanceof WEBGLBuffer) {
-                  gl.bindBufferBase(35345, uniformBufferIndex, value.handle);
-                } else {
-                  const bufferBinding = value;
-                  gl.bindBufferRange(35345, uniformBufferIndex, bufferBinding.buffer.handle, bufferBinding.offset || 0, bufferBinding.size || bufferBinding.buffer.byteLength - (bufferBinding.offset || 0));
-                }
-                uniformBufferIndex += 1;
-                break;
-              case "texture":
-                if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
-                  throw new Error("texture");
-                }
-                let texture;
-                if (value instanceof WEBGLTextureView) {
-                  texture = value.texture;
-                } else if (value instanceof WEBGLTexture) {
-                  texture = value;
-                } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-                  import_core15.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
-                  texture = value.colorAttachments[0].texture;
-                } else {
-                  throw new Error("No texture");
-                }
-                gl.activeTexture(33984 + textureUnit);
-                gl.bindTexture(texture.glTarget, texture.handle);
-                textureUnit += 1;
-                break;
-              case "sampler":
-                break;
-              case "storage":
-              case "read-only-storage":
-                throw new Error(`binding type '${binding.type}' not supported in WebGL`);
-            }
-          }
-        }
-        /**
-         * Due to program sharing, uniforms need to be reset before every draw call
-         * (though caching will avoid redundant WebGL calls)
-         */
-        _applyUniforms(uniforms) {
-          for (const uniformLayout of this.shaderLayout.uniforms || []) {
-            const { name, location, type, textureUnit } = uniformLayout;
-            const value = uniforms[name] ?? textureUnit;
-            if (value !== void 0) {
-              setUniform(this.device.gl, location, type, value);
-            }
-          }
-        }
-        _syncLinkStatus() {
-          this.linkStatus = this.sharedRenderPipeline.linkStatus;
-        }
-      };
-    }
-  });
-
   // ../../node_modules/@luma.gl/webgl/dist/adapter/converters/webgl-shadertypes.js
   function convertDataTypeToGLDataType(normalizedType) {
     return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
@@ -3534,13 +3295,13 @@ Source: ${sourceLine}` : "";
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js
-  function getShaderLayoutFromGLSL(gl, program) {
+  function getShaderLayoutFromGLSL(gl, program, options = {}) {
     const shaderLayout = {
       attributes: [],
       bindings: []
     };
     shaderLayout.attributes = readAttributeDeclarations(gl, program);
-    const uniformBlocks = readUniformBlocks(gl, program);
+    const uniformBlocks = readUniformBlocks(gl, program, options);
     for (const uniformBlock of uniformBlocks) {
       const uniforms2 = uniformBlock.uniforms.map((uniform) => ({
         name: uniform.name,
@@ -3554,7 +3315,7 @@ Source: ${sourceLine}` : "";
         name: uniformBlock.name,
         group: 0,
         location: uniformBlock.location,
-        visibility: (uniformBlock.vertex ? 1 : 0) & (uniformBlock.fragment ? 2 : 0),
+        visibility: (uniformBlock.vertex ? 1 : 0) | (uniformBlock.fragment ? 2 : 0),
         minBindingSize: uniformBlock.byteLength,
         uniforms: uniforms2
       });
@@ -3624,7 +3385,7 @@ Source: ${sourceLine}` : "";
       }
       const { name, type: glUniformType, size } = activeInfo;
       const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
-      const { type, components } = (0, import_core16.getVariableShaderTypeInfo)(uniformType);
+      const { type, components } = (0, import_core15.getVariableShaderTypeInfo)(uniformType);
       varyings.push({ location, name, type, size: size * components });
     }
     varyings.sort((a, b) => a.location - b.location);
@@ -3661,84 +3422,530 @@ Source: ${sourceLine}` : "";
           };
           uniforms.push(arrayElementUniformInfo);
         }
-      }
-    }
-    return uniforms;
-  }
-  function readUniformBlocks(gl, program) {
-    const getBlockParameter = (blockIndex, pname) => gl.getActiveUniformBlockParameter(program, blockIndex, pname);
-    const uniformBlocks = [];
-    const blockCount = gl.getProgramParameter(program, 35382);
-    for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-      const blockInfo = {
-        name: gl.getActiveUniformBlockName(program, blockIndex) || "",
-        location: getBlockParameter(blockIndex, 35391),
-        byteLength: getBlockParameter(blockIndex, 35392),
-        vertex: getBlockParameter(blockIndex, 35396),
-        fragment: getBlockParameter(blockIndex, 35398),
-        uniformCount: getBlockParameter(blockIndex, 35394),
-        uniforms: []
-      };
-      const uniformIndices = getBlockParameter(blockIndex, 35395) || [];
-      const uniformType = gl.getActiveUniforms(program, uniformIndices, 35383);
-      const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, 35384);
-      const uniformOffset = gl.getActiveUniforms(program, uniformIndices, 35387);
-      const uniformStride = gl.getActiveUniforms(program, uniformIndices, 35388);
-      for (let i = 0; i < blockInfo.uniformCount; ++i) {
-        const uniformIndex = uniformIndices[i];
-        if (uniformIndex !== void 0) {
-          const activeInfo = gl.getActiveUniform(program, uniformIndex);
-          if (!activeInfo) {
-            throw new Error("activeInfo");
-          }
-          const format = convertGLUniformTypeToShaderVariableType(uniformType[i]);
-          blockInfo.uniforms.push({
-            name: activeInfo.name,
-            format,
-            type: uniformType[i],
-            arrayLength: uniformArrayLength[i],
-            byteOffset: uniformOffset[i],
-            byteStride: uniformStride[i]
-            // matrixStride: uniformStride[i],
-            // rowMajor: uniformRowMajor[i]
+      }
+    }
+    return uniforms;
+  }
+  function readUniformBlocks(gl, program, options) {
+    const uniformBlocks = [];
+    const knownBlocksByIndex = getKnownUniformBlocksByIndex(gl, program, options);
+    for (const [blockIndex, uniformBlock] of knownBlocksByIndex) {
+      uniformBlocks.push(uniformBlock);
+      try {
+        const reflectedUniformBlock = readReflectedUniformBlock(gl, program, blockIndex, uniformBlock.name);
+        validateReflectedUniformBlock(reflectedUniformBlock, uniformBlock);
+      } catch (error) {
+        const message2 = error instanceof Error ? error.message : String(error);
+        import_core15.log.once(0, `WebGL uniform block reflection failed for "${uniformBlock.name}"; using supplied std140 metadata. ${message2}`)();
+      }
+    }
+    const blockCount = gl.getProgramParameter(program, 35382);
+    if (!Number.isInteger(blockCount) || blockCount < 0) {
+      throw new Error(`Failed to reflect WebGL uniform blocks: ACTIVE_UNIFORM_BLOCKS returned ${String(blockCount)}`);
+    }
+    for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+      if (!knownBlocksByIndex.has(blockIndex)) {
+        uniformBlocks.push(readReflectedUniformBlock(gl, program, blockIndex));
+      }
+    }
+    uniformBlocks.sort((a, b) => a.location - b.location);
+    return uniformBlocks;
+  }
+  function validateReflectedUniformBlock(reflectedUniformBlock, knownUniformBlock) {
+    for (const reflectedUniform of reflectedUniformBlock.uniforms) {
+      const knownUniform = knownUniformBlock.uniforms.find((uniform) => reflectedUniform.name === uniform.name || reflectedUniform.name.endsWith(`.${uniform.name}`));
+      if (!knownUniform) {
+        throw new Error(`Failed to validate WebGL uniform block "${knownUniformBlock.name}": reflected unexpected member "${reflectedUniform.name}"`);
+      }
+      if (reflectedUniform.format !== knownUniform.format || reflectedUniform.arrayLength !== knownUniform.arrayLength || reflectedUniform.byteOffset !== knownUniform.byteOffset || reflectedUniform.byteStride !== knownUniform.byteStride) {
+        throw new Error(`Failed to validate WebGL uniform block "${knownUniformBlock.name}": reflected layout for "${reflectedUniform.name}" does not match supplied std140 metadata`);
+      }
+    }
+  }
+  function getKnownUniformBlocksByIndex(gl, program, options) {
+    const knownUniformBlocks = /* @__PURE__ */ new Map();
+    for (const uniformBlockLayout of options.uniformBlockLayouts || []) {
+      knownUniformBlocks.set(uniformBlockLayout.name, makeUniformBlockBindingFromTypes(uniformBlockLayout));
+    }
+    for (const binding of options.shaderLayout?.bindings || []) {
+      if (isUsableUniformBlockBinding(binding)) {
+        knownUniformBlocks.set(binding.name, binding);
+      }
+    }
+    const knownBlocksByIndex = /* @__PURE__ */ new Map();
+    for (const binding of knownUniformBlocks.values()) {
+      const resolvedBlock = getActiveUniformBlockIndex(gl, program, binding.name);
+      if (!resolvedBlock) {
+        continue;
+      }
+      const { blockIndex, blockName } = resolvedBlock;
+      if (knownBlocksByIndex.has(blockIndex)) {
+        throw new Error(`Multiple supplied uniform block layouts resolve to active WebGL block "${blockName}"`);
+      }
+      knownBlocksByIndex.set(blockIndex, {
+        name: blockName,
+        location: blockIndex,
+        byteLength: binding.minBindingSize,
+        vertex: Boolean(binding.visibility && binding.visibility & 1),
+        fragment: Boolean(binding.visibility && binding.visibility & 2),
+        uniformCount: binding.uniforms.length,
+        uniforms: binding.uniforms.map((uniform) => ({ ...uniform }))
+      });
+    }
+    return knownBlocksByIndex;
+  }
+  function getActiveUniformBlockIndex(gl, program, blockName) {
+    const blockNames = blockName.endsWith("Uniforms") ? [blockName, blockName.slice(0, -"Uniforms".length)] : [blockName, `${blockName}Uniforms`];
+    for (const candidateBlockName of blockNames) {
+      const blockIndex = gl.getUniformBlockIndex(program, candidateBlockName);
+      if (blockIndex !== 4294967295) {
+        if (!Number.isInteger(blockIndex) || blockIndex < 0) {
+          throw new Error(`Failed to resolve WebGL uniform block "${candidateBlockName}": getUniformBlockIndex returned ${String(blockIndex)}`);
+        }
+        return { blockIndex, blockName: candidateBlockName };
+      }
+    }
+    return null;
+  }
+  function readReflectedUniformBlock(gl, program, blockIndex, knownBlockName) {
+    const blockName = knownBlockName || gl.getActiveUniformBlockName(program, blockIndex);
+    if (!blockName) {
+      throw new Error(`Failed to reflect WebGL uniform block at index ${blockIndex}: missing block name`);
+    }
+    const getBlockParameter = (pname, label) => {
+      const value = gl.getActiveUniformBlockParameter(program, blockIndex, pname);
+      if (value === null || value === void 0) {
+        throw new Error(`Failed to reflect WebGL uniform block "${blockName}": ${label} returned null`);
+      }
+      return value;
+    };
+    const location = getFiniteInteger(getBlockParameter(35391, "UNIFORM_BLOCK_BINDING"), blockName, "UNIFORM_BLOCK_BINDING", 0);
+    const byteLength = getFiniteInteger(getBlockParameter(35392, "UNIFORM_BLOCK_DATA_SIZE"), blockName, "UNIFORM_BLOCK_DATA_SIZE", 0);
+    const uniformCount = getFiniteInteger(getBlockParameter(35394, "UNIFORM_BLOCK_ACTIVE_UNIFORMS"), blockName, "UNIFORM_BLOCK_ACTIVE_UNIFORMS", 0);
+    const uniformIndices = getNumericArray(getBlockParameter(35395, "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"), blockName, "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", uniformCount);
+    const uniformTypes = getActiveUniformValues(gl, program, uniformIndices, 35383, "UNIFORM_TYPE", blockName, uniformCount);
+    const uniformArrayLengths = getActiveUniformValues(gl, program, uniformIndices, 35384, "UNIFORM_SIZE", blockName, uniformCount);
+    const uniformBlockIndices = getActiveUniformValues(gl, program, uniformIndices, 35386, "UNIFORM_BLOCK_INDEX", blockName, uniformCount);
+    const uniformOffsets = getActiveUniformValues(gl, program, uniformIndices, 35387, "UNIFORM_OFFSET", blockName, uniformCount);
+    const uniformStrides = getActiveUniformValues(gl, program, uniformIndices, 35388, "UNIFORM_ARRAY_STRIDE", blockName, uniformCount);
+    const uniforms = [];
+    for (let uniformPosition = 0; uniformPosition < uniformCount; uniformPosition++) {
+      if (uniformBlockIndices[uniformPosition] !== blockIndex) {
+        throw new Error(`Failed to reflect WebGL uniform block "${blockName}": active uniform index ${uniformIndices[uniformPosition]} belongs to block ${uniformBlockIndices[uniformPosition]}, expected ${blockIndex}`);
+      }
+      const uniformIndex = uniformIndices[uniformPosition];
+      const activeInfo = gl.getActiveUniform(program, uniformIndex);
+      if (!activeInfo) {
+        throw new Error(`Failed to reflect WebGL uniform block "${blockName}": getActiveUniform(${uniformIndex}) returned null`);
+      }
+      const uniformType = getFiniteInteger(uniformTypes[uniformPosition], blockName, `UNIFORM_TYPE[${uniformPosition}]`, 1);
+      const arrayLength = getFiniteInteger(uniformArrayLengths[uniformPosition], blockName, `UNIFORM_SIZE[${uniformPosition}]`, 1);
+      const byteOffset = getFiniteInteger(uniformOffsets[uniformPosition], blockName, `UNIFORM_OFFSET[${uniformPosition}]`, 0);
+      const byteStride = getFiniteInteger(uniformStrides[uniformPosition], blockName, `UNIFORM_ARRAY_STRIDE[${uniformPosition}]`, 0);
+      if (activeInfo.type !== uniformType || activeInfo.size !== arrayLength) {
+        throw new Error(`Failed to reflect WebGL uniform block "${blockName}": getActiveUniform(${uniformIndex}) disagrees with getActiveUniforms`);
+      }
+      uniforms.push({
+        name: activeInfo.name,
+        format: convertGLUniformTypeToShaderVariableType(uniformType),
+        arrayLength,
+        byteOffset,
+        byteStride
+      });
+    }
+    const blockInfo = {
+      name: blockName,
+      location,
+      byteLength,
+      vertex: Boolean(getBlockParameter(35396, "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER")),
+      fragment: Boolean(getBlockParameter(35398, "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER")),
+      uniformCount,
+      uniforms
+    };
+    const uniformInstancePrefixes = new Set(blockInfo.uniforms.map((uniform) => uniform.name.split(".")[0]).filter((instanceName) => Boolean(instanceName)));
+    const blockAlias = blockInfo.name.replace(/Uniforms$/, "");
+    if (uniformInstancePrefixes.size === 1 && !uniformInstancePrefixes.has(blockInfo.name) && !uniformInstancePrefixes.has(blockAlias)) {
+      const [instanceName] = uniformInstancePrefixes;
+      import_core15.log.warn(`Uniform block "${blockInfo.name}" uses GLSL instance "${instanceName}". luma.gl binds uniform buffers by block name ("${blockInfo.name}") and alias ("${blockAlias}"). Prefer matching the instance name to one of those to avoid confusing silent mismatches.`)();
+    }
+    return blockInfo;
+  }
+  function getActiveUniformValues(gl, program, uniformIndices, pname, label, blockName, expectedLength) {
+    const values = gl.getActiveUniforms(program, uniformIndices, pname);
+    if (values === null) {
+      throw new Error(`Failed to reflect WebGL uniform block "${blockName}": ${label} returned null`);
+    }
+    return getNumericArray(values, blockName, label, expectedLength);
+  }
+  function getNumericArray(value, blockName, label, expectedLength) {
+    if (!Array.isArray(value) && !ArrayBuffer.isView(value)) {
+      throw new Error(`Failed to reflect WebGL uniform block "${blockName}": ${label} returned a non-array value`);
+    }
+    const values = Array.from(value);
+    if (values.length !== expectedLength || values.some((item) => !Number.isInteger(item))) {
+      throw new Error(`Failed to reflect WebGL uniform block "${blockName}": ${label} returned ${values.length} invalid values, expected ${expectedLength}`);
+    }
+    return values;
+  }
+  function getFiniteInteger(value, blockName, label, minimum) {
+    if (!Number.isInteger(value) || value < minimum) {
+      throw new Error(`Failed to reflect WebGL uniform block "${blockName}": ${label} returned ${String(value)}`);
+    }
+    return value;
+  }
+  function makeUniformBlockBindingFromTypes(uniformBlockLayout) {
+    const shaderBlockLayout = (0, import_core15.makeShaderBlockLayout)(uniformBlockLayout.uniformTypes, {
+      layout: "std140"
+    });
+    const uniforms = getUniformInfosFromTypes(uniformBlockLayout.uniformTypes, shaderBlockLayout.fields);
+    return {
+      type: "uniform",
+      name: uniformBlockLayout.name,
+      group: 0,
+      location: 0,
+      minBindingSize: shaderBlockLayout.byteLength,
+      uniforms
+    };
+  }
+  function getUniformInfosFromTypes(uniformTypes, fields) {
+    const uniforms = [];
+    const addType = (name, type) => {
+      if (typeof type === "string") {
+        const field = fields[name];
+        if (!field) {
+          throw new Error(`Missing std140 layout field ${name}`);
+        }
+        uniforms.push({
+          name,
+          format: field.shaderType,
+          arrayLength: 1,
+          byteOffset: field.offset * 4,
+          byteStride: 0
+        });
+        return;
+      }
+      if (Array.isArray(type)) {
+        addArrayType(name, type[0], type[1]);
+        return;
+      }
+      for (const [memberName, memberType] of Object.entries(type)) {
+        addType(`${name}.${memberName}`, memberType);
+      }
+    };
+    const addArrayType = (name, type, arrayLength) => {
+      if (typeof type === "string") {
+        const firstField = fields[`${name}[0]`];
+        const secondField = arrayLength > 1 ? fields[`${name}[1]`] : void 0;
+        if (!firstField) {
+          throw new Error(`Missing std140 array layout field ${name}[0]`);
+        }
+        uniforms.push({
+          name: `${name}[0]`,
+          format: firstField.shaderType,
+          arrayLength,
+          byteOffset: firstField.offset * 4,
+          byteStride: secondField ? (secondField.offset - firstField.offset) * 4 : 0
+        });
+        return;
+      }
+      if (Array.isArray(type)) {
+        throw new Error(`Nested uniform arrays are not supported for ${name}`);
+      }
+      for (const [memberName, memberType] of Object.entries(type)) {
+        if (typeof memberType !== "string") {
+          throw new Error(`Composite uniform array members are not supported for ${name}`);
+        }
+        const firstName = `${name}[0].${memberName}`;
+        const secondName = `${name}[1].${memberName}`;
+        const firstField = fields[firstName];
+        const secondField = arrayLength > 1 ? fields[secondName] : void 0;
+        if (!firstField) {
+          throw new Error(`Missing std140 array layout field ${firstName}`);
+        }
+        uniforms.push({
+          name: firstName,
+          format: firstField.shaderType,
+          arrayLength,
+          byteOffset: firstField.offset * 4,
+          byteStride: secondField ? (secondField.offset - firstField.offset) * 4 : 0
+        });
+      }
+    };
+    for (const [uniformName, uniformType] of Object.entries(uniformTypes)) {
+      addType(uniformName, uniformType);
+    }
+    return uniforms;
+  }
+  function isUsableUniformBlockBinding(binding) {
+    return binding.type === "uniform" && Number.isInteger(binding.minBindingSize) && binding.minBindingSize >= 0 && Array.isArray(binding.uniforms) && binding.uniforms.every((uniform) => typeof uniform.name === "string" && typeof uniform.format === "string" && Number.isInteger(uniform.arrayLength) && uniform.arrayLength > 0 && Number.isInteger(uniform.byteOffset) && uniform.byteOffset >= 0 && Number.isInteger(uniform.byteStride) && uniform.byteStride >= 0);
+  }
+  function parseUniformName(name) {
+    if (name[name.length - 1] !== "]") {
+      return {
+        name,
+        length: 1,
+        isArray: false
+      };
+    }
+    const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
+    const matches = UNIFORM_NAME_REGEXP.exec(name);
+    const uniformName = (0, import_core15.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
+    return {
+      name: uniformName,
+      // TODO - is this a bug, shouldn't we return the value?
+      length: matches?.[2] ? 1 : 0,
+      isArray: Boolean(matches?.[2])
+    };
+  }
+  var import_core15;
+  var init_get_shader_layout_from_glsl = __esm({
+    "../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js"() {
+      import_core15 = __toESM(require_core2(), 1);
+      init_webgl_shadertypes();
+    }
+  });
+
+  // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js
+  function mergeShaderLayout(baseLayout, overrideLayout) {
+    const mergedLayout = {
+      ...baseLayout,
+      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })),
+      bindings: baseLayout.bindings.map((binding) => ({ ...binding }))
+    };
+    for (const attribute of overrideLayout?.attributes || []) {
+      const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
+      if (!baseAttribute) {
+        import_core16.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+      } else {
+        baseAttribute.type = attribute.type || baseAttribute.type;
+        baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
+      }
+    }
+    for (const binding of overrideLayout?.bindings || []) {
+      const baseBinding = getShaderLayoutBindingByName(mergedLayout, binding.name);
+      if (!baseBinding) {
+        import_core16.log.warn(`shader layout binding ${binding.name} not present in shader`);
+        continue;
+      }
+      Object.assign(baseBinding, binding);
+    }
+    return mergedLayout;
+  }
+  function getShaderLayoutBindingByName(shaderLayout, bindingName) {
+    return shaderLayout.bindings.find((binding) => binding.name === bindingName || binding.name === `${bindingName}Uniforms` || `${binding.name}Uniforms` === bindingName);
+  }
+  function getBindingValueForLayoutBinding(bindings, bindingName) {
+    return bindings[bindingName] || bindings[`${bindingName}Uniforms`] || bindings[bindingName.replace(/Uniforms$/, "")];
+  }
+  var import_core16, WEBGLRenderPipeline;
+  var init_webgl_render_pipeline = __esm({
+    "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-render-pipeline.js"() {
+      import_core16 = __toESM(require_core2(), 1);
+      init_set_uniform();
+      init_webgl_buffer();
+      init_webgl_framebuffer();
+      init_webgl_texture();
+      init_webgl_texture_view();
+      init_get_shader_layout_from_glsl();
+      WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
+        /** The WebGL device that created this render pipeline */
+        device;
+        /** Handle to underlying WebGL program */
+        handle;
+        /** vertex shader */
+        vs;
+        /** fragment shader */
+        fs;
+        /** The layout extracted from shader by WebGL introspection APIs */
+        introspectedLayout;
+        /** Compatibility path for direct pipeline.setBindings() usage */
+        bindings = {};
+        /** Compatibility path for direct pipeline.uniforms usage */
+        uniforms = {};
+        /** WebGL varyings */
+        varyings = null;
+        _uniformCount = 0;
+        _uniformSetters = {};
+        // TODO are these used?
+        get [Symbol.toStringTag]() {
+          return "WEBGLRenderPipeline";
+        }
+        constructor(device, props) {
+          super(device, props);
+          this.device = device;
+          const webglSharedRenderPipeline = this.sharedRenderPipeline || this.device._createSharedRenderPipelineWebGL(props);
+          this.sharedRenderPipeline = webglSharedRenderPipeline;
+          this.handle = webglSharedRenderPipeline.handle;
+          this.vs = webglSharedRenderPipeline.vs;
+          this.fs = webglSharedRenderPipeline.fs;
+          this.linkStatus = webglSharedRenderPipeline.linkStatus;
+          this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle, {
+            uniformBlockLayouts: props._uniformBlockLayouts,
+            shaderLayout: props.shaderLayout
+          });
+          this.device._setWebGLDebugMetadata(this.handle, this, { spector: { id: this.props.id } });
+          this.shaderLayout = props.shaderLayout ? mergeShaderLayout(this.introspectedLayout, props.shaderLayout) : this.introspectedLayout;
+        }
+        destroy() {
+          if (this.destroyed) {
+            return;
+          }
+          if (this.sharedRenderPipeline && !this.props._sharedRenderPipeline) {
+            this.sharedRenderPipeline.destroy();
+          }
+          this.destroyResource();
+        }
+        /** @deprecated Set bindings on RenderPass instead. Will be removed in the next major release. */
+        setBindings(bindings, options) {
+          const flatBindings = (0, import_core16.flattenBindingsByGroup)((0, import_core16.normalizeBindingsByGroup)(this.shaderLayout, bindings));
+          for (const [name, value] of Object.entries(flatBindings)) {
+            const binding = getShaderLayoutBindingByName(this.shaderLayout, name);
+            if (!binding) {
+              const validBindings = this.shaderLayout.bindings.map((binding_) => `"${binding_.name}"`).join(", ");
+              if (!options?.disableWarnings) {
+                import_core16.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
+              }
+            } else {
+              if (!value) {
+                import_core16.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+              }
+              switch (binding.type) {
+                case "uniform":
+                  if (!(value instanceof WEBGLBuffer) && !(value.buffer instanceof WEBGLBuffer)) {
+                    throw new Error("buffer value");
+                  }
+                  break;
+                case "texture":
+                  if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+                    throw new Error(`${this} Bad texture binding for ${name}`);
+                  }
+                  break;
+                case "sampler":
+                  import_core16.log.warn(`Ignoring sampler ${name}`)();
+                  break;
+                default:
+                  throw new Error(binding.type);
+              }
+              this.bindings[name] = value;
+            }
+          }
+        }
+        /** @todo needed for portable model
+         * @note The WebGL API is offers many ways to draw things
+         * This function unifies those ways into a single call using common parameters with sane defaults
+         */
+        draw(options) {
+          const webglRenderPass = options.renderPass;
+          const drawBindings = options.bindGroups ? (0, import_core16.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
+          webglRenderPass.setPipeline(this);
+          webglRenderPass.setBindings(drawBindings);
+          webglRenderPass.setVertexArray(options.vertexArray);
+          return webglRenderPass.draw({
+            parameters: options.parameters,
+            topology: options.topology,
+            isInstanced: options.isInstanced,
+            vertexCount: options.vertexCount,
+            indexCount: options.indexCount,
+            instanceCount: options.instanceCount,
+            firstVertex: options.firstVertex,
+            firstIndex: options.firstIndex,
+            firstInstance: options.firstInstance,
+            baseVertex: options.baseVertex,
+            transformFeedback: options.transformFeedback,
+            uniforms: options.uniforms
           });
         }
-      }
-      const uniformInstancePrefixes = new Set(blockInfo.uniforms.map((uniform) => uniform.name.split(".")[0]).filter((instanceName) => Boolean(instanceName)));
-      const blockAlias = blockInfo.name.replace(/Uniforms$/, "");
-      if (uniformInstancePrefixes.size === 1 && !uniformInstancePrefixes.has(blockInfo.name) && !uniformInstancePrefixes.has(blockAlias)) {
-        const [instanceName] = uniformInstancePrefixes;
-        import_core16.log.warn(`Uniform block "${blockInfo.name}" uses GLSL instance "${instanceName}". luma.gl binds uniform buffers by block name ("${blockInfo.name}") and alias ("${blockAlias}"). Prefer matching the instance name to one of those to avoid confusing silent mismatches.`)();
-      }
-      uniformBlocks.push(blockInfo);
-    }
-    uniformBlocks.sort((a, b) => a.location - b.location);
-    return uniformBlocks;
-  }
-  function parseUniformName(name) {
-    if (name[name.length - 1] !== "]") {
-      return {
-        name,
-        length: 1,
-        isArray: false
+        /**
+         * Checks if all texture-values uniforms are renderable (i.e. loaded)
+         * Update a texture if needed (e.g. from video)
+         * Note: This is currently done before every draw call
+         */
+        _areTexturesRenderable(bindings) {
+          let texturesRenderable = true;
+          for (const bindingInfo of this.shaderLayout.bindings) {
+            if (!getBindingValueForLayoutBinding(bindings, bindingInfo.name)) {
+              import_core16.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+              texturesRenderable = false;
+            }
+          }
+          return texturesRenderable;
+        }
+        /** Apply any bindings (before each draw call) */
+        _applyBindings(bindings, _options) {
+          this._syncLinkStatus();
+          if (this.linkStatus !== "success") {
+            return;
+          }
+          const { gl } = this.device;
+          gl.useProgram(this.handle);
+          let textureUnit = 0;
+          let uniformBufferIndex = 0;
+          for (const binding of this.shaderLayout.bindings) {
+            const value = getBindingValueForLayoutBinding(bindings, binding.name);
+            if (!value) {
+              throw new Error(`No value for binding ${binding.name} in ${this.id}`);
+            }
+            switch (binding.type) {
+              case "uniform":
+                const { name } = binding;
+                const location = gl.getUniformBlockIndex(this.handle, name);
+                if (location === 4294967295) {
+                  throw new Error(`Invalid uniform block name ${name}`);
+                }
+                gl.uniformBlockBinding(this.handle, location, uniformBufferIndex);
+                if (value instanceof WEBGLBuffer) {
+                  gl.bindBufferBase(35345, uniformBufferIndex, value.handle);
+                } else {
+                  const bufferBinding = value;
+                  gl.bindBufferRange(35345, uniformBufferIndex, bufferBinding.buffer.handle, bufferBinding.offset || 0, bufferBinding.size || bufferBinding.buffer.byteLength - (bufferBinding.offset || 0));
+                }
+                uniformBufferIndex += 1;
+                break;
+              case "texture":
+                if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+                  throw new Error("texture");
+                }
+                let texture;
+                if (value instanceof WEBGLTextureView) {
+                  texture = value.texture;
+                } else if (value instanceof WEBGLTexture) {
+                  texture = value;
+                } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
+                  import_core16.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+                  texture = value.colorAttachments[0].texture;
+                } else {
+                  throw new Error("No texture");
+                }
+                gl.activeTexture(33984 + textureUnit);
+                gl.bindTexture(texture.glTarget, texture.handle);
+                textureUnit += 1;
+                break;
+              case "sampler":
+                break;
+              case "storage":
+              case "read-only-storage":
+                throw new Error(`binding type '${binding.type}' not supported in WebGL`);
+            }
+          }
+        }
+        /**
+         * Due to program sharing, uniforms need to be reset before every draw call
+         * (though caching will avoid redundant WebGL calls)
+         */
+        _applyUniforms(uniforms) {
+          for (const uniformLayout of this.shaderLayout.uniforms || []) {
+            const { name, location, type, textureUnit } = uniformLayout;
+            const value = uniforms[name] ?? textureUnit;
+            if (value !== void 0) {
+              setUniform(this.device.gl, location, type, value);
+            }
+          }
+        }
+        _syncLinkStatus() {
+          this.linkStatus = this.sharedRenderPipeline.linkStatus;
+        }
       };
     }
-    const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-    const matches = UNIFORM_NAME_REGEXP.exec(name);
-    const uniformName = (0, import_core16.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
-    return {
-      name: uniformName,
-      // TODO - is this a bug, shouldn't we return the value?
-      length: matches?.[2] ? 1 : 0,
-      isArray: Boolean(matches?.[2])
-    };
-  }
-  var import_core16;
-  var init_get_shader_layout_from_glsl = __esm({
-    "../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js"() {
-      import_core16 = __toESM(require_core2(), 1);
-      init_webgl_shadertypes();
-    }
   });
 
   // ../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shared-render-pipeline.js
@@ -3746,7 +3953,6 @@ Source: ${sourceLine}` : "";
   var init_webgl_shared_render_pipeline = __esm({
     "../../node_modules/@luma.gl/webgl/dist/adapter/resources/webgl-shared-render-pipeline.js"() {
       import_core17 = __toESM(require_core2(), 1);
-      init_get_shader_layout_from_glsl();
       init_webgl_shadertypes();
       LOG_PROGRAM_PERF_PRIORITY = 4;
       WEBGLSharedRenderPipeline = class extends import_core17.SharedRenderPipeline {
@@ -3754,7 +3960,6 @@ Source: ${sourceLine}` : "";
         handle;
         vs;
         fs;
-        introspectedLayout = { attributes: [], bindings: [], uniforms: [] };
         linkStatus = "pending";
         constructor(device, props) {
           super(device, props);
@@ -3766,9 +3971,6 @@ Source: ${sourceLine}` : "";
             this.device.gl.transformFeedbackVaryings(this.handle, props.varyings, props.bufferMode || 35981);
           }
           this._linkShaders();
-          import_core17.log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
-          this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
-          import_core17.log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
         }
         destroy() {
           if (this.destroyed) {
@@ -11463,8 +11665,8 @@ void main(void) {
       }
       return PROJECTION_MODE.IDENTITY;
     }
-    // Two viewports are equal if width and height are identical, and if
-    // their view and projection matrices are (approximately) equal.
+    // Two viewports are equal if their dimensions, common-space scale, and
+    // view and projection matrices are (approximately) equal.
     equals(viewport) {
       if (!(viewport instanceof _Viewport)) {
         return false;
@@ -11472,7 +11674,7 @@ void main(void) {
       if (this === viewport) {
         return true;
       }
-      return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix);
+      return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && viewport.projectionMode === this.projectionMode && viewport.resolution === this.resolution && equals(viewport.distanceScales.unitsPerMeter, this.distanceScales.unitsPerMeter) && equals(viewport.projectionMatrix, this.projectionMatrix) && equals(viewport.viewMatrix, this.viewMatrix);
     }
     /**
      * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
@@ -11807,6 +12009,10 @@ void main(void) {
       }
       return this._subViewports;
     }
+    /** Returns whether two Web Mercator viewports use the same projection settings. */
+    equals(viewport) {
+      return viewport instanceof _WebMercatorViewport && viewport._pseudoMeters === this._pseudoMeters && super.equals(viewport);
+    }
     projectPosition(xyz) {
       if (this._pseudoMeters) {
         return super.projectPosition(xyz);
@@ -12177,178 +12383,6 @@ void main(void) {
     }
   };
 
-  // ../core/src/viewports/globe-viewport.ts
-  var DEGREES_TO_RADIANS5 = Math.PI / 180;
-  var RADIANS_TO_DEGREES3 = 180 / Math.PI;
-  var EARTH_RADIUS = 6370972;
-  var GLOBE_RADIUS = 256;
-  function getDistanceScales2() {
-    const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
-    const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
-    return {
-      unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
-      unitsPerMeter2: [0, 0, 0],
-      metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
-      unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
-      unitsPerDegree2: [0, 0, 0],
-      degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
-    };
-  }
-  var GlobeViewport = class extends Viewport {
-    constructor(opts = {}) {
-      const {
-        longitude = 0,
-        bearing = 0,
-        pitch = 0,
-        zoom = 0,
-        // Matches Maplibre defaults
-        // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
-        nearZMultiplier = 0.5,
-        farZMultiplier = 1,
-        resolution = 10
-      } = opts;
-      let { latitude = 0, height, altitude = 1.5, fovy } = opts;
-      latitude = Math.max(Math.min(latitude, 90), -90);
-      height = height || 1;
-      if (fovy) {
-        altitude = fovyToAltitude(fovy);
-      } else {
-        fovy = altitudeToFovy(altitude);
-      }
-      const scaleLatitude = Math.max(Math.min(latitude, MAX_LATITUDE), -MAX_LATITUDE);
-      const scale5 = Math.pow(2, zoom - zoomAdjust(scaleLatitude));
-      const pitchRadians = pitch * DEGREES_TO_RADIANS5;
-      const nearZ = opts.nearZ ?? nearZMultiplier;
-      const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale5 / height / Math.max(Math.cos(pitchRadians), 0.1)) * farZMultiplier;
-      const viewMatrix = new Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }).rotateX(-pitchRadians).rotateY(-bearing * DEGREES_TO_RADIANS5).rotateX(latitude * DEGREES_TO_RADIANS5).rotateZ(-longitude * DEGREES_TO_RADIANS5).scale(scale5 / height);
-      super({
-        ...opts,
-        // x, y, width,
-        height,
-        // view matrix
-        viewMatrix,
-        longitude,
-        latitude,
-        zoom,
-        // projection matrix parameters
-        distanceScales: getDistanceScales2(),
-        fovy,
-        focalDistance: altitude,
-        near: nearZ,
-        far: farZ
-      });
-      this.scale = scale5;
-      this.latitude = latitude;
-      this.longitude = longitude;
-      this.bearing = bearing;
-      this.pitch = pitch;
-      this.fovy = fovy;
-      this.resolution = resolution;
-    }
-    get projectionMode() {
-      return PROJECTION_MODE.GLOBE;
-    }
-    getDistanceScales() {
-      return this.distanceScales;
-    }
-    getBounds(options = {}) {
-      const unprojectOption = { targetZ: options.z || 0 };
-      const left = this.unproject([0, this.height / 2], unprojectOption);
-      const top = this.unproject([this.width / 2, 0], unprojectOption);
-      const right = this.unproject([this.width, this.height / 2], unprojectOption);
-      const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
-      if (right[0] < this.longitude) right[0] += 360;
-      if (left[0] > this.longitude) left[0] -= 360;
-      return [
-        Math.min(left[0], right[0], top[0], bottom[0]),
-        Math.min(left[1], right[1], top[1], bottom[1]),
-        Math.max(left[0], right[0], top[0], bottom[0]),
-        Math.max(left[1], right[1], top[1], bottom[1])
-      ];
-    }
-    unproject(xyz, { topLeft = true, targetZ } = {}) {
-      const [x, y, z] = xyz;
-      const y2 = topLeft ? y : this.height - y;
-      const { pixelUnprojectionMatrix } = this;
-      let coord;
-      if (Number.isFinite(z)) {
-        coord = transformVector2(pixelUnprojectionMatrix, [x, y2, z, 1]);
-      } else {
-        const coord0 = transformVector2(pixelUnprojectionMatrix, [x, y2, -1, 1]);
-        const coord1 = transformVector2(pixelUnprojectionMatrix, [x, y2, 1, 1]);
-        const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-        const lSqr = vec3_exports.sqrLen(vec3_exports.sub([], coord0, coord1));
-        const l0Sqr = vec3_exports.sqrLen(coord0);
-        const l1Sqr = vec3_exports.sqrLen(coord1);
-        const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;
-        const dSqr = 4 * sSqr / lSqr;
-        const r0 = Math.sqrt(l0Sqr - dSqr);
-        const dr = Math.sqrt(Math.max(0, lt * lt - dSqr));
-        const t = (r0 - dr) / Math.sqrt(lSqr);
-        coord = vec3_exports.lerp([], coord0, coord1, t);
-      }
-      const [X, Y, Z] = this.unprojectPosition(coord);
-      if (Number.isFinite(z)) {
-        return [X, Y, Z];
-      }
-      return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
-    }
-    projectPosition(xyz) {
-      const [lng, lat, Z = 0] = xyz;
-      const lambda = lng * DEGREES_TO_RADIANS5;
-      const phi = lat * DEGREES_TO_RADIANS5;
-      const cosPhi = Math.cos(phi);
-      const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-      return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];
-    }
-    unprojectPosition(xyz) {
-      const [x, y, z] = xyz;
-      const D = vec3_exports.len(xyz);
-      const phi = Math.asin(z / D);
-      const lambda = Math.atan2(x, -y);
-      const lng = lambda * RADIANS_TO_DEGREES3;
-      const lat = phi * RADIANS_TO_DEGREES3;
-      const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;
-      return [lng, lat, Z];
-    }
-    projectFlat(xyz) {
-      return xyz;
-    }
-    unprojectFlat(xyz) {
-      return xyz;
-    }
-    /**
-     * Pan the globe using delta-based movement
-     * @param coords - the geographic coordinates where the pan started
-     * @param pixel - the current screen position
-     * @param startPixel - the screen position where the pan started
-     * @returns updated viewport options with new longitude/latitude
-     */
-    panByPosition([startLng, startLat, startZoom], pixel, startPixel) {
-      const scale5 = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
-      const rotationSpeed = 0.25 / scale5;
-      const longitude = startLng + rotationSpeed * (startPixel[0] - pixel[0]);
-      let latitude = startLat - rotationSpeed * (startPixel[1] - pixel[1]);
-      latitude = Math.max(Math.min(latitude, 90), -90);
-      const out = { longitude, latitude, zoom: startZoom - zoomAdjust(startLat) };
-      out.zoom += zoomAdjust(out.latitude);
-      return out;
-    }
-  };
-  GlobeViewport.displayName = "GlobeViewport";
-  function zoomAdjust(latitude, clampToPoles) {
-    if (clampToPoles) {
-      latitude = Math.max(Math.min(latitude, MAX_LATITUDE), -MAX_LATITUDE);
-    }
-    const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
-    return Math.log2(scaleAdjust);
-  }
-  function transformVector2(matrix, vector) {
-    const result = vec4_exports.transformMat4([], vector, matrix);
-    vec4_exports.scale(result, result, 1 / result[3]);
-    return result;
-  }
-
   // ../core/src/transitions/linear-interpolator.ts
   var DEFAULT_PROPS = ["longitude", "latitude", "zoom", "bearing", "pitch"];
   var DEFAULT_REQUIRED_PROPS = ["longitude", "latitude", "zoom"];
@@ -12376,21 +12410,16 @@ void main(void) {
       const result = super.initializeProps(startProps, endProps);
       const { makeViewport, around } = this.opts;
       if (makeViewport && around) {
-        const TestViewport = makeViewport(startProps);
-        if (TestViewport instanceof GlobeViewport) {
-          log_default.warn("around not supported in GlobeView")();
-        } else {
-          const startViewport = makeViewport(startProps);
-          const endViewport = makeViewport(endProps);
-          const aroundPosition = startViewport.unproject(around);
-          result.start.around = around;
-          Object.assign(result.end, {
-            around: endViewport.project(aroundPosition),
-            aroundPosition,
-            width: endProps.width,
-            height: endProps.height
-          });
-        }
+        const startViewport = makeViewport(startProps);
+        const endViewport = makeViewport(endProps);
+        const aroundPosition = startViewport.unproject(around);
+        result.start.around = around;
+        Object.assign(result.end, {
+          around: endViewport.project(aroundPosition),
+          aroundPosition,
+          width: endProps.width,
+          height: endProps.height
+        });
       }
       return result;
     }
@@ -12463,6 +12492,7 @@ void main(void) {
       this.touchRotate = false;
       this.multiTouchDrag = null;
       this.trackpadGesture = false;
+      this.zoomAround = "pointer";
       this.keyboard = true;
       this.transitionManager = new TransitionManager({
         ...opts,
@@ -12556,6 +12586,15 @@ void main(void) {
       const { offsetCenter } = event;
       return [offsetCenter.x - x, offsetCenter.y - y];
     }
+    /** Resolves the zoom anchor for pointer-based controls. */
+    getZoomPosition(position) {
+      if (this.zoomAround === "pointer") {
+        return position;
+      }
+      const viewport = this.makeViewport(this.controllerState.getViewportProps());
+      const [centerX, centerY] = worldToPixels(viewport.center, viewport.pixelProjectionMatrix);
+      return [centerX, centerY];
+    }
     isPointInBounds(pos, event) {
       const { width, height } = this.props;
       if (event && event.handled) {
@@ -12613,6 +12652,7 @@ void main(void) {
         touchRotate = false,
         multiTouchDrag = touchRotate ? "rotate" : null,
         trackpadGesture = false,
+        zoomAround = "pointer",
         keyboard = true
       } = props;
       const isInteractive = Boolean(this.onViewStateChange);
@@ -12635,6 +12675,7 @@ void main(void) {
       this.touchRotate = multiTouchDrag === "rotate";
       this.multiTouchDrag = multiTouchDrag;
       this.trackpadGesture = trackpadGesture;
+      this.zoomAround = zoomAround;
       this.keyboard = keyboard;
       const constraintChanged = !oldProps || oldProps.height !== props.height || oldProps.width !== props.width || oldProps.maxBounds !== props.maxBounds || oldProps.maxBoundsPadding !== props.maxBoundsPadding;
       if (constraintChanged && props.maxBounds) {
@@ -12868,8 +12909,9 @@ void main(void) {
       if (delta < 0 && scale5 !== 0) {
         scale5 = 1 / scale5;
       }
-      const transitionProps = smooth ? { ...this._getTransitionProps({ around: pos }), transitionDuration: 250 } : NO_TRANSITION_PROPS;
-      const newControllerState = this.controllerState.zoom({ pos, scale: scale5 });
+      const zoomPosition = this.getZoomPosition(pos);
+      const transitionProps = smooth ? { ...this._getTransitionProps({ around: zoomPosition }), transitionDuration: 250 } : NO_TRANSITION_PROPS;
+      const newControllerState = this.controllerState.zoom({ pos: zoomPosition, scale: scale5 });
       this.updateViewport(newControllerState, transitionProps, {
         isZooming: true,
         isPanning: true
@@ -12955,7 +12997,7 @@ void main(void) {
       if (!this.isPointInBounds(pos, event)) {
         return false;
       }
-      const newControllerState = this.controllerState.zoomStart({ pos }, this._getConstraintContext("zoom", "start")).rotateStart({ pos }, this._getConstraintContext("rotate", "start"));
+      const newControllerState = this.controllerState.zoomStart({ pos: this.getZoomPosition(pos) }, this._getConstraintContext("zoom", "start")).rotateStart({ pos }, this._getConstraintContext("rotate", "start"));
       pinchEventWorkaround._startPinchRotation = event.rotation;
       pinchEventWorkaround._lastPinchEvent = event;
       this.updateViewport(newControllerState, NO_TRANSITION_PROPS, { isDragging: true });
@@ -12974,7 +13016,7 @@ void main(void) {
         const { scale: scale5 } = event;
         const pos = this.getCenter(event);
         newControllerState = newControllerState.zoom(
-          { pos, scale: scale5 },
+          { pos: this.getZoomPosition(pos), scale: scale5 },
           this._getConstraintContext("zoom", "update")
         );
       }
@@ -13002,15 +13044,16 @@ void main(void) {
       const { _lastPinchEvent } = pinchEventWorkaround;
       if (this.touchZoom && inertia && _lastPinchEvent && event.scale !== _lastPinchEvent.scale) {
         const pos = this.getCenter(event);
+        const zoomPosition = this.getZoomPosition(pos);
         let newControllerState = this.controllerState.rotateEnd();
         const z = Math.log2(event.scale);
         const velocityZ = (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime);
         const endScale = Math.pow(2, z + velocityZ * inertia / 2);
-        newControllerState = newControllerState.zoom({ pos, scale: endScale }).zoomEnd();
+        newControllerState = newControllerState.zoom({ pos: zoomPosition, scale: endScale }).zoomEnd();
         this.updateViewport(
           newControllerState,
           {
-            ...this._getTransitionProps({ around: pos }),
+            ...this._getTransitionProps({ around: zoomPosition }),
             transitionDuration: inertia,
             transitionEasing: INERTIA_EASING
           },
@@ -13055,8 +13098,12 @@ void main(void) {
         return false;
       }
       const isZoomOut = this.isFunctionKeyPressed(event);
-      const newControllerState = this.controllerState.zoom({ pos, scale: isZoomOut ? 0.5 : 2 });
-      this.updateViewport(newControllerState, this._getTransitionProps({ around: pos }), {
+      const zoomPosition = this.getZoomPosition(pos);
+      const newControllerState = this.controllerState.zoom({
+        pos: zoomPosition,
+        scale: isZoomOut ? 0.5 : 2
+      });
+      this.updateViewport(newControllerState, this._getTransitionProps({ around: zoomPosition }), {
         isZooming: true,
         isPanning: true
       });
@@ -13073,14 +13120,14 @@ void main(void) {
         this._doubleClickDragAnchor = null;
         return false;
       }
-      this._doubleClickDragAnchor = pos;
+      this._doubleClickDragAnchor = this.getZoomPosition(pos);
       let newControllerState = this.controllerState.zoomStart(
-        { pos },
+        { pos: this._doubleClickDragAnchor },
         this._getConstraintContext("zoom", "start")
       );
       if (event.scale !== 1) {
         newControllerState = newControllerState.zoom(
-          { pos, scale: event.scale },
+          { pos: this._doubleClickDragAnchor, scale: event.scale },
           this._getConstraintContext("zoom", "update")
         );
       }