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

package/dist/dist.dev.js

@@ -3213,6 +3213,498 @@ Source: ${sourceLine}` : "";
     }
   });
 
+  // ../../node_modules/@luma.gl/webgl/dist/adapter/converters/webgl-shadertypes.js
+  function convertDataTypeToGLDataType(normalizedType) {
+    return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
+  }
+  function convertGLUniformTypeToShaderVariableType(glUniformType) {
+    return WEBGL_SHADER_TYPES[glUniformType];
+  }
+  function isGLSamplerType(type) {
+    return Boolean(WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[type]);
+  }
+  function getTextureBindingFromGLSamplerType(glSamplerType) {
+    return WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[glSamplerType];
+  }
+  var WEBGL_SHADER_TYPES, WEBGL_SAMPLER_TO_TEXTURE_BINDINGS, NORMALIZED_SHADER_TYPE_TO_WEBGL;
+  var init_webgl_shadertypes = __esm({
+    "../../node_modules/@luma.gl/webgl/dist/adapter/converters/webgl-shadertypes.js"() {
+      WEBGL_SHADER_TYPES = {
+        [5126]: "f32",
+        [35664]: "vec2<f32>",
+        [35665]: "vec3<f32>",
+        [35666]: "vec4<f32>",
+        [5124]: "i32",
+        [35667]: "vec2<i32>",
+        [35668]: "vec3<i32>",
+        [35669]: "vec4<i32>",
+        [5125]: "u32",
+        [36294]: "vec2<u32>",
+        [36295]: "vec3<u32>",
+        [36296]: "vec4<u32>",
+        [35670]: "f32",
+        [35671]: "vec2<f32>",
+        [35672]: "vec3<f32>",
+        [35673]: "vec4<f32>",
+        // TODO - are sizes/components below correct?
+        [35674]: "mat2x2<f32>",
+        [35685]: "mat2x3<f32>",
+        [35686]: "mat2x4<f32>",
+        [35687]: "mat3x2<f32>",
+        [35675]: "mat3x3<f32>",
+        [35688]: "mat3x4<f32>",
+        [35689]: "mat4x2<f32>",
+        [35690]: "mat4x3<f32>",
+        [35676]: "mat4x4<f32>"
+      };
+      WEBGL_SAMPLER_TO_TEXTURE_BINDINGS = {
+        [35678]: { viewDimension: "2d", sampleType: "float" },
+        [35680]: { viewDimension: "cube", sampleType: "float" },
+        [35679]: { viewDimension: "3d", sampleType: "float" },
+        [35682]: { viewDimension: "3d", sampleType: "depth" },
+        [36289]: { viewDimension: "2d-array", sampleType: "float" },
+        [36292]: { viewDimension: "2d-array", sampleType: "depth" },
+        [36293]: { viewDimension: "cube", sampleType: "float" },
+        [36298]: { viewDimension: "2d", sampleType: "sint" },
+        [36299]: { viewDimension: "3d", sampleType: "sint" },
+        [36300]: { viewDimension: "cube", sampleType: "sint" },
+        [36303]: { viewDimension: "2d-array", sampleType: "uint" },
+        [36306]: { viewDimension: "2d", sampleType: "uint" },
+        [36307]: { viewDimension: "3d", sampleType: "uint" },
+        [36308]: { viewDimension: "cube", sampleType: "uint" },
+        [36311]: { viewDimension: "2d-array", sampleType: "uint" }
+      };
+      NORMALIZED_SHADER_TYPE_TO_WEBGL = {
+        uint8: 5121,
+        sint8: 5120,
+        unorm8: 5121,
+        snorm8: 5120,
+        uint16: 5123,
+        sint16: 5122,
+        unorm16: 5123,
+        snorm16: 5122,
+        uint32: 5125,
+        sint32: 5124,
+        // WebGPU does not support normalized 32 bit integer attributes
+        //  'unorm32': GL.UNSIGNED_INT,
+        //  'snorm32': GL.INT,
+        float16: 5131,
+        float32: 5126
+      };
+    }
+  });
+
+  // ../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js
+  function getShaderLayoutFromGLSL(gl, program, options = {}) {
+    const shaderLayout = {
+      attributes: [],
+      bindings: []
+    };
+    shaderLayout.attributes = readAttributeDeclarations(gl, program);
+    const uniformBlocks = readUniformBlocks(gl, program, options);
+    for (const uniformBlock of uniformBlocks) {
+      const uniforms2 = uniformBlock.uniforms.map((uniform) => ({
+        name: uniform.name,
+        format: uniform.format,
+        byteOffset: uniform.byteOffset,
+        byteStride: uniform.byteStride,
+        arrayLength: uniform.arrayLength
+      }));
+      shaderLayout.bindings.push({
+        type: "uniform",
+        name: uniformBlock.name,
+        group: 0,
+        location: uniformBlock.location,
+        visibility: (uniformBlock.vertex ? 1 : 0) | (uniformBlock.fragment ? 2 : 0),
+        minBindingSize: uniformBlock.byteLength,
+        uniforms: uniforms2
+      });
+    }
+    const uniforms = readUniformBindings(gl, program);
+    let textureUnit = 0;
+    for (const uniform of uniforms) {
+      if (isGLSamplerType(uniform.type)) {
+        const { viewDimension, sampleType } = getTextureBindingFromGLSamplerType(uniform.type);
+        shaderLayout.bindings.push({
+          type: "texture",
+          name: uniform.name,
+          group: 0,
+          location: textureUnit,
+          viewDimension,
+          sampleType
+        });
+        uniform.textureUnit = textureUnit;
+        textureUnit += 1;
+      }
+    }
+    if (uniforms.length) {
+      shaderLayout.uniforms = uniforms;
+    }
+    const varyings = readVaryings(gl, program);
+    if (varyings?.length) {
+      shaderLayout.varyings = varyings;
+    }
+    return shaderLayout;
+  }
+  function readAttributeDeclarations(gl, program) {
+    const attributes = [];
+    const count = gl.getProgramParameter(program, 35721);
+    for (let index = 0; index < count; index++) {
+      const activeInfo = gl.getActiveAttrib(program, index);
+      if (!activeInfo) {
+        throw new Error("activeInfo");
+      }
+      const {
+        name,
+        type: compositeType
+        /* , size*/
+      } = activeInfo;
+      const location = gl.getAttribLocation(program, name);
+      if (location >= 0) {
+        const attributeType = convertGLUniformTypeToShaderVariableType(compositeType);
+        const stepMode = /instance/i.test(name) ? "instance" : "vertex";
+        attributes.push({
+          name,
+          location,
+          stepMode,
+          type: attributeType
+          // size - for arrays, size is the number of elements in the array
+        });
+      }
+    }
+    attributes.sort((a, b) => a.location - b.location);
+    return attributes;
+  }
+  function readVaryings(gl, program) {
+    const varyings = [];
+    const count = gl.getProgramParameter(program, 35971);
+    for (let location = 0; location < count; location++) {
+      const activeInfo = gl.getTransformFeedbackVarying(program, location);
+      if (!activeInfo) {
+        throw new Error("activeInfo");
+      }
+      const { name, type: glUniformType, size } = activeInfo;
+      const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
+      const { type, components } = (0, import_core15.getVariableShaderTypeInfo)(uniformType);
+      varyings.push({ location, name, type, size: size * components });
+    }
+    varyings.sort((a, b) => a.location - b.location);
+    return varyings;
+  }
+  function readUniformBindings(gl, program) {
+    const uniforms = [];
+    const uniformCount = gl.getProgramParameter(program, 35718);
+    for (let i = 0; i < uniformCount; i++) {
+      const activeInfo = gl.getActiveUniform(program, i);
+      if (!activeInfo) {
+        throw new Error("activeInfo");
+      }
+      const { name: rawName, size, type } = activeInfo;
+      const { name, isArray: isArray4 } = parseUniformName(rawName);
+      let webglLocation = gl.getUniformLocation(program, name);
+      const uniformInfo = {
+        // WebGL locations are uniquely typed but just numbers
+        location: webglLocation,
+        name,
+        size,
+        type,
+        isArray: isArray4
+      };
+      uniforms.push(uniformInfo);
+      if (uniformInfo.size > 1) {
+        for (let j = 0; j < uniformInfo.size; j++) {
+          const elementName = `${name}[${j}]`;
+          webglLocation = gl.getUniformLocation(program, elementName);
+          const arrayElementUniformInfo = {
+            ...uniformInfo,
+            name: elementName,
+            location: webglLocation
+          };
+          uniforms.push(arrayElementUniformInfo);
+        }
+      }
+    }
+    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 = {
@@ -3223,7 +3715,7 @@ Source: ${sourceLine}` : "";
     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`);
+        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;
@@ -3232,7 +3724,7 @@ Source: ${sourceLine}` : "";
     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`);
+        import_core16.log.warn(`shader layout binding ${binding.name} not present in shader`);
         continue;
       }
       Object.assign(baseBinding, binding);
@@ -3245,16 +3737,17 @@ Source: ${sourceLine}` : "";
   function getBindingValueForLayoutBinding(bindings, bindingName) {
     return bindings[bindingName] || bindings[`${bindingName}Uniforms`] || bindings[bindingName.replace(/Uniforms$/, "")];
   }
-  var import_core15, WEBGLRenderPipeline;
+  var import_core16, 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);
+      import_core16 = __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 {
+      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 */
@@ -3286,7 +3779,10 @@ Source: ${sourceLine}` : "";
           this.vs = webglSharedRenderPipeline.vs;
           this.fs = webglSharedRenderPipeline.fs;
           this.linkStatus = webglSharedRenderPipeline.linkStatus;
-          this.introspectedLayout = webglSharedRenderPipeline.introspectedLayout;
+          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;
         }
@@ -3301,17 +3797,17 @@ Source: ${sourceLine}` : "";
         }
         /** @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));
+          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_core15.log.warn(`No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`, value)();
+                import_core16.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}"`)();
+                import_core16.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
               }
               switch (binding.type) {
                 case "uniform":
@@ -3325,7 +3821,7 @@ Source: ${sourceLine}` : "";
                   }
                   break;
                 case "sampler":
-                  import_core15.log.warn(`Ignoring sampler ${name}`)();
+                  import_core16.log.warn(`Ignoring sampler ${name}`)();
                   break;
                 default:
                   throw new Error(binding.type);
@@ -3340,7 +3836,7 @@ Source: ${sourceLine}` : "";
          */
         draw(options) {
           const webglRenderPass = options.renderPass;
-          const drawBindings = options.bindGroups ? (0, import_core15.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
+          const drawBindings = options.bindGroups ? (0, import_core16.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
           webglRenderPass.setPipeline(this);
           webglRenderPass.setBindings(drawBindings);
           webglRenderPass.setVertexArray(options.vertexArray);
@@ -3368,7 +3864,7 @@ Source: ${sourceLine}` : "";
           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}`)();
+              import_core16.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
               texturesRenderable = false;
             }
           }
@@ -3415,7 +3911,7 @@ Source: ${sourceLine}` : "";
                 } 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")();
+                  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");
@@ -3452,301 +3948,11 @@ Source: ${sourceLine}` : "";
     }
   });
 
-  // ../../node_modules/@luma.gl/webgl/dist/adapter/converters/webgl-shadertypes.js
-  function convertDataTypeToGLDataType(normalizedType) {
-    return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
-  }
-  function convertGLUniformTypeToShaderVariableType(glUniformType) {
-    return WEBGL_SHADER_TYPES[glUniformType];
-  }
-  function isGLSamplerType(type) {
-    return Boolean(WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[type]);
-  }
-  function getTextureBindingFromGLSamplerType(glSamplerType) {
-    return WEBGL_SAMPLER_TO_TEXTURE_BINDINGS[glSamplerType];
-  }
-  var WEBGL_SHADER_TYPES, WEBGL_SAMPLER_TO_TEXTURE_BINDINGS, NORMALIZED_SHADER_TYPE_TO_WEBGL;
-  var init_webgl_shadertypes = __esm({
-    "../../node_modules/@luma.gl/webgl/dist/adapter/converters/webgl-shadertypes.js"() {
-      WEBGL_SHADER_TYPES = {
-        [5126]: "f32",
-        [35664]: "vec2<f32>",
-        [35665]: "vec3<f32>",
-        [35666]: "vec4<f32>",
-        [5124]: "i32",
-        [35667]: "vec2<i32>",
-        [35668]: "vec3<i32>",
-        [35669]: "vec4<i32>",
-        [5125]: "u32",
-        [36294]: "vec2<u32>",
-        [36295]: "vec3<u32>",
-        [36296]: "vec4<u32>",
-        [35670]: "f32",
-        [35671]: "vec2<f32>",
-        [35672]: "vec3<f32>",
-        [35673]: "vec4<f32>",
-        // TODO - are sizes/components below correct?
-        [35674]: "mat2x2<f32>",
-        [35685]: "mat2x3<f32>",
-        [35686]: "mat2x4<f32>",
-        [35687]: "mat3x2<f32>",
-        [35675]: "mat3x3<f32>",
-        [35688]: "mat3x4<f32>",
-        [35689]: "mat4x2<f32>",
-        [35690]: "mat4x3<f32>",
-        [35676]: "mat4x4<f32>"
-      };
-      WEBGL_SAMPLER_TO_TEXTURE_BINDINGS = {
-        [35678]: { viewDimension: "2d", sampleType: "float" },
-        [35680]: { viewDimension: "cube", sampleType: "float" },
-        [35679]: { viewDimension: "3d", sampleType: "float" },
-        [35682]: { viewDimension: "3d", sampleType: "depth" },
-        [36289]: { viewDimension: "2d-array", sampleType: "float" },
-        [36292]: { viewDimension: "2d-array", sampleType: "depth" },
-        [36293]: { viewDimension: "cube", sampleType: "float" },
-        [36298]: { viewDimension: "2d", sampleType: "sint" },
-        [36299]: { viewDimension: "3d", sampleType: "sint" },
-        [36300]: { viewDimension: "cube", sampleType: "sint" },
-        [36303]: { viewDimension: "2d-array", sampleType: "uint" },
-        [36306]: { viewDimension: "2d", sampleType: "uint" },
-        [36307]: { viewDimension: "3d", sampleType: "uint" },
-        [36308]: { viewDimension: "cube", sampleType: "uint" },
-        [36311]: { viewDimension: "2d-array", sampleType: "uint" }
-      };
-      NORMALIZED_SHADER_TYPE_TO_WEBGL = {
-        uint8: 5121,
-        sint8: 5120,
-        unorm8: 5121,
-        snorm8: 5120,
-        uint16: 5123,
-        sint16: 5122,
-        unorm16: 5123,
-        snorm16: 5122,
-        uint32: 5125,
-        sint32: 5124,
-        // WebGPU does not support normalized 32 bit integer attributes
-        //  'unorm32': GL.UNSIGNED_INT,
-        //  'snorm32': GL.INT,
-        float16: 5131,
-        float32: 5126
-      };
-    }
-  });
-
-  // ../../node_modules/@luma.gl/webgl/dist/adapter/helpers/get-shader-layout-from-glsl.js
-  function getShaderLayoutFromGLSL(gl, program) {
-    const shaderLayout = {
-      attributes: [],
-      bindings: []
-    };
-    shaderLayout.attributes = readAttributeDeclarations(gl, program);
-    const uniformBlocks = readUniformBlocks(gl, program);
-    for (const uniformBlock of uniformBlocks) {
-      const uniforms2 = uniformBlock.uniforms.map((uniform) => ({
-        name: uniform.name,
-        format: uniform.format,
-        byteOffset: uniform.byteOffset,
-        byteStride: uniform.byteStride,
-        arrayLength: uniform.arrayLength
-      }));
-      shaderLayout.bindings.push({
-        type: "uniform",
-        name: uniformBlock.name,
-        group: 0,
-        location: uniformBlock.location,
-        visibility: (uniformBlock.vertex ? 1 : 0) & (uniformBlock.fragment ? 2 : 0),
-        minBindingSize: uniformBlock.byteLength,
-        uniforms: uniforms2
-      });
-    }
-    const uniforms = readUniformBindings(gl, program);
-    let textureUnit = 0;
-    for (const uniform of uniforms) {
-      if (isGLSamplerType(uniform.type)) {
-        const { viewDimension, sampleType } = getTextureBindingFromGLSamplerType(uniform.type);
-        shaderLayout.bindings.push({
-          type: "texture",
-          name: uniform.name,
-          group: 0,
-          location: textureUnit,
-          viewDimension,
-          sampleType
-        });
-        uniform.textureUnit = textureUnit;
-        textureUnit += 1;
-      }
-    }
-    if (uniforms.length) {
-      shaderLayout.uniforms = uniforms;
-    }
-    const varyings = readVaryings(gl, program);
-    if (varyings?.length) {
-      shaderLayout.varyings = varyings;
-    }
-    return shaderLayout;
-  }
-  function readAttributeDeclarations(gl, program) {
-    const attributes = [];
-    const count = gl.getProgramParameter(program, 35721);
-    for (let index = 0; index < count; index++) {
-      const activeInfo = gl.getActiveAttrib(program, index);
-      if (!activeInfo) {
-        throw new Error("activeInfo");
-      }
-      const {
-        name,
-        type: compositeType
-        /* , size*/
-      } = activeInfo;
-      const location = gl.getAttribLocation(program, name);
-      if (location >= 0) {
-        const attributeType = convertGLUniformTypeToShaderVariableType(compositeType);
-        const stepMode = /instance/i.test(name) ? "instance" : "vertex";
-        attributes.push({
-          name,
-          location,
-          stepMode,
-          type: attributeType
-          // size - for arrays, size is the number of elements in the array
-        });
-      }
-    }
-    attributes.sort((a, b) => a.location - b.location);
-    return attributes;
-  }
-  function readVaryings(gl, program) {
-    const varyings = [];
-    const count = gl.getProgramParameter(program, 35971);
-    for (let location = 0; location < count; location++) {
-      const activeInfo = gl.getTransformFeedbackVarying(program, location);
-      if (!activeInfo) {
-        throw new Error("activeInfo");
-      }
-      const { name, type: glUniformType, size } = activeInfo;
-      const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
-      const { type, components } = (0, import_core16.getVariableShaderTypeInfo)(uniformType);
-      varyings.push({ location, name, type, size: size * components });
-    }
-    varyings.sort((a, b) => a.location - b.location);
-    return varyings;
-  }
-  function readUniformBindings(gl, program) {
-    const uniforms = [];
-    const uniformCount = gl.getProgramParameter(program, 35718);
-    for (let i = 0; i < uniformCount; i++) {
-      const activeInfo = gl.getActiveUniform(program, i);
-      if (!activeInfo) {
-        throw new Error("activeInfo");
-      }
-      const { name: rawName, size, type } = activeInfo;
-      const { name, isArray: isArray4 } = parseUniformName(rawName);
-      let webglLocation = gl.getUniformLocation(program, name);
-      const uniformInfo = {
-        // WebGL locations are uniquely typed but just numbers
-        location: webglLocation,
-        name,
-        size,
-        type,
-        isArray: isArray4
-      };
-      uniforms.push(uniformInfo);
-      if (uniformInfo.size > 1) {
-        for (let j = 0; j < uniformInfo.size; j++) {
-          const elementName = `${name}[${j}]`;
-          webglLocation = gl.getUniformLocation(program, elementName);
-          const arrayElementUniformInfo = {
-            ...uniformInfo,
-            name: elementName,
-            location: webglLocation
-          };
-          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]
-          });
-        }
-      }
-      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
-      };
-    }
-    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
   var import_core17, LOG_PROGRAM_PERF_PRIORITY, WEBGLSharedRenderPipeline;
   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) {