ol 10.4.1-dev.1740542736318 → 10.4.1-dev.1740751716860

package/render/webgl/{utils.d.ts → bufferUtil.d.ts}

@@ -61,43 +61,7 @@ export function writeLineSegmentToBuffers(instructions: Float32Array, segmentSta
  * @private
  */
 export function writePolygonTrianglesToBuffers(instructions: Float32Array, polygonStartIndex: number, vertexArray: Array<number>, indexArray: Array<number>, customAttributesSize: number): number;
-/**
- * Returns a texture of 1x1 pixel, white
- * @private
- * @return {ImageData} Image data.
- */
-export function getBlankImageData(): ImageData;
-/**
- * Generates a color array based on a numerical id
- * Note: the range for each component is 0 to 1 with 256 steps
- * @param {number} id Id
- * @param {Array<number>} [array] Reusable array
- * @return {Array<number>} Color array containing the encoded id
- */
-export function colorEncodeId(id: number, array?: Array<number>): Array<number>;
-/**
- * Reads an id from a color-encoded array
- * Note: the expected range for each component is 0 to 1 with 256 steps.
- * @param {Array<number>} color Color array containing the encoded id
- * @return {number} Decoded id
- */
-export function colorDecodeId(color: Array<number>): number;
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
- */
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
- */
-/**
- * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
- * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
- * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
- * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
- */
-export function breakDownFlatStyle(style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders): Array<StyleAsShaders | StyleAsRule>;
 export const LINESTRING_ANGLE_COSINE_CUTOFF: 0.985;
-export type StyleAsShaders = import("./VectorStyleRenderer.js").AsShaders;
-export type StyleAsRule = import("./VectorStyleRenderer.js").AsRule;
 /**
  * An object holding positions both in an index and a vertex buffer.
  */
@@ -111,4 +75,4 @@ export type BufferPositions = {
      */
     indexPosition: number;
 };
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=bufferUtil.d.ts.map

package/render/webgl/bufferUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferUtil.d.ts","sourceRoot":"","sources":["bufferUtil.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;GAYG;AACH,yDAXW,YAAY,gBACZ,MAAM,gBACN,YAAY,eACZ,WAAW,wBACX,MAAM,oBACN,eAAe,GACd,eAAe,CAgE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDAdW,YAAY,qBACZ,MAAM,mBACN,MAAM,sBACN,MAAM,GAAC,IAAI,qBACX,MAAM,GAAC,IAAI,eACX,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,oBACb,KAAK,CAAC,MAAM,CAAC,oBACb,OAAO,oBAAoB,EAAE,SAAS,iBACtC,MAAM,0BACN,MAAM,GACL;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAgM1C;AAED;;;;;;;;;GASG;AACH,6DARW,YAAY,qBACZ,MAAM,eACN,KAAK,CAAC,MAAM,CAAC,cACb,KAAK,CAAC,MAAM,CAAC,wBACb,MAAM,GACL,MAAM,CA0CjB;AAtXD,6CAA8C,KAAK,CAAC;;;;;;;;oBAQtC,MAAM;;;;mBACN,MAAM"}

package/render/webgl/{utils.js → bufferUtil.js}

@@ -1,5 +1,6 @@
 /**
- * @module ol/render/webgl/utils
+ * Utilities for filling WebGL buffers
+ * @module ol/render/webgl/bufferUtil
  */
 import earcut from 'earcut';
 import {clamp} from '../../math.js';
@@ -380,125 +381,3 @@ export function writePolygonTrianglesToBuffers(
 
   return instructionsIndex + verticesCount * instructionsPerVertex;
 }
-
-/**
- * Returns a texture of 1x1 pixel, white
- * @private
- * @return {ImageData} Image data.
- */
-export function getBlankImageData() {
-  const canvas = document.createElement('canvas');
-  const image = canvas.getContext('2d').createImageData(1, 1);
-  image.data[0] = 255;
-  image.data[1] = 255;
-  image.data[2] = 255;
-  image.data[3] = 255;
-  return image;
-}
-
-/**
- * Generates a color array based on a numerical id
- * Note: the range for each component is 0 to 1 with 256 steps
- * @param {number} id Id
- * @param {Array<number>} [array] Reusable array
- * @return {Array<number>} Color array containing the encoded id
- */
-export function colorEncodeId(id, array) {
-  array = array || [];
-  const radix = 256;
-  const divide = radix - 1;
-  array[0] = Math.floor(id / radix / radix / radix) / divide;
-  array[1] = (Math.floor(id / radix / radix) % radix) / divide;
-  array[2] = (Math.floor(id / radix) % radix) / divide;
-  array[3] = (id % radix) / divide;
-  return array;
-}
-
-/**
- * Reads an id from a color-encoded array
- * Note: the expected range for each component is 0 to 1 with 256 steps.
- * @param {Array<number>} color Color array containing the encoded id
- * @return {number} Decoded id
- */
-export function colorDecodeId(color) {
-  let id = 0;
-  const radix = 256;
-  const mult = radix - 1;
-  id += Math.round(color[0] * radix * radix * radix * mult);
-  id += Math.round(color[1] * radix * radix * mult);
-  id += Math.round(color[2] * radix * mult);
-  id += Math.round(color[3] * mult);
-  return id;
-}
-
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
- */
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
- */
-
-/**
- * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
- * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
- * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
- * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
- */
-export function breakDownFlatStyle(style) {
-  // possible cases:
-  // - single shader
-  // - multiple shaders
-  // - single style
-  // - multiple styles
-  // - multiple rules
-  const asArray = Array.isArray(style) ? style : [style];
-
-  // if array of rules: break rules into separate styles, compute "else" filters
-  if ('style' in asArray[0]) {
-    /** @type {Array<StyleAsRule>} */
-    const styles = [];
-    const rules = /** @type {Array<import('../../style/flat.js').Rule>} */ (
-      asArray
-    );
-    const previousFilters = [];
-    for (const rule of rules) {
-      const ruleStyles = Array.isArray(rule.style) ? rule.style : [rule.style];
-      /** @type {import("../../expr/expression.js").EncodedExpression} */
-      let currentFilter = rule.filter;
-      if (rule.else && previousFilters.length) {
-        currentFilter = [
-          'all',
-          ...previousFilters.map((filter) => ['!', filter]),
-        ];
-        if (rule.filter) {
-          currentFilter.push(rule.filter);
-        }
-        if (currentFilter.length < 3) {
-          currentFilter = currentFilter[1];
-        }
-      }
-      if (rule.filter) {
-        previousFilters.push(rule.filter);
-      }
-      /** @type {Array<StyleAsRule>} */
-      const stylesWithFilters = ruleStyles.map((style) => ({
-        style,
-        ...(currentFilter && {filter: currentFilter}),
-      }));
-      styles.push(...stylesWithFilters);
-    }
-    return styles;
-  }
-
-  // if array of shaders: return as is
-  if ('builder' in asArray[0]) {
-    return /** @type {Array<StyleAsShaders>} */ (asArray);
-  }
-
-  return asArray.map(
-    (style) =>
-      /** @type {StyleAsRule} */ ({
-        style,
-      }),
-  );
-}

package/render/webgl/compileUtil.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Recursively parses a style expression and outputs a GLSL-compatible string. Takes in a compilation context that
+ * will be read and modified during the parsing operation.
+ * @param {import("../../expr/gpu.js").CompilationContext} compilationContext Compilation context
+ * @param {import("../../expr/expression.js").EncodedExpression} value Value
+ * @param {number} [expectedType] Expected final type (can be several types combined)
+ * @return {string} GLSL-compatible output
+ */
+export function expressionToGlsl(compilationContext: import("../../expr/gpu.js").CompilationContext, value: import("../../expr/expression.js").EncodedExpression, expectedType?: number): string;
+/**
+ * Packs all components of a color into a two-floats array
+ * @param {import("../../color.js").Color|string} color Color as array of numbers or string
+ * @return {Array<number>} Vec2 array containing the color in compressed form
+ */
+export function packColor(color: import("../../color.js").Color | string): Array<number>;
+/**
+ * @param {number} type Value type
+ * @return {1|2|3|4} The amount of components for this value
+ */
+export function getGlslSizeFromType(type: number): 1 | 2 | 3 | 4;
+/**
+ * @param {number} type Value type
+ * @return {'float'|'vec2'|'vec3'|'vec4'} The corresponding GLSL type for this value
+ */
+export function getGlslTypeFromType(type: number): "float" | "vec2" | "vec3" | "vec4";
+/**
+ * Applies the properties and variables collected in a compilation context to a ShaderBuilder instance:
+ * properties will show up as attributes in shaders, and variables will show up as uniforms.
+ * @param {import("./ShaderBuilder.js").ShaderBuilder} builder Shader builder
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ */
+export function applyContextToBuilder(builder: import("./ShaderBuilder.js").ShaderBuilder, context: import("../../expr/gpu.js").CompilationContext): void;
+/**
+ * Generates a set of uniforms from variables collected in a compilation context,
+ * to be fed to a WebGLHelper instance
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ * @param {import('../../style/flat.js').StyleVariables} [variables] Style variables.
+ * @return {Object<string,import("../../webgl/Helper").UniformValue>} Uniforms
+ */
+export function generateUniformsFromContext(context: import("../../expr/gpu.js").CompilationContext, variables?: import("../../style/flat.js").StyleVariables): {
+    [x: string]: import("../../webgl/Helper").UniformValue;
+};
+/**
+ * Generates a set of attributes from properties collected in a compilation context,
+ * to be fed to a WebGLHelper instance
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ * @return {import('./VectorStyleRenderer.js').AttributeDefinitions} Attributes
+ */
+export function generateAttributesFromContext(context: import("../../expr/gpu.js").CompilationContext): import("./VectorStyleRenderer.js").AttributeDefinitions;
+export const UNPACK_COLOR_FN: "vec4 unpackColor(vec2 packedColor) {\n  return vec4(\n    fract(floor(packedColor[0] / 256.0) / 256.0),\n    fract(packedColor[0] / 256.0),\n    fract(floor(packedColor[1] / 256.0) / 256.0),\n    fract(packedColor[1] / 256.0)\n  );\n}";
+//# sourceMappingURL=compileUtil.d.ts.map

package/render/webgl/compileUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileUtil.d.ts","sourceRoot":"","sources":["compileUtil.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,qDALW,OAAO,mBAAmB,EAAE,kBAAkB,SAC9C,OAAO,0BAA0B,EAAE,iBAAiB,iBACpD,MAAM,GACL,MAAM,CAUjB;AAED;;;;GAIG;AACH,iCAHW,OAAO,gBAAgB,EAAE,KAAK,GAAC,MAAM,GACpC,KAAK,CAAC,MAAM,CAAC,CASxB;AAWD;;;GAGG;AACH,0CAHW,MAAM,GACL,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,CAAC,CAUlB;AAED;;;GAGG;AACH,0CAHW,MAAM,GACL,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,CAQvC;AAED;;;;;GAKG;AACH,+CAHW,OAAO,oBAAoB,EAAE,aAAa,WAC1C,OAAO,mBAAmB,EAAE,kBAAkB,QAuCxD;AAED;;;;;;GAMG;AACH,qDAJW,OAAO,mBAAmB,EAAE,kBAAkB,cAC9C,OAAO,qBAAqB,EAAE,cAAc;;EA+BtD;AAED;;;;;GAKG;AACH,uDAHW,OAAO,mBAAmB,EAAE,kBAAkB,GAC7C,OAAO,0BAA0B,EAAE,oBAAoB,CA+BlE;AAxJD,2QAOG"}

package/render/webgl/compileUtil.js

@@ -0,0 +1,203 @@
+/**
+ * Utilities for compiling expressions and turning them into WebGL concepts
+ * @module ol/render/webgl/compileUtil
+ */
+
+import {asArray} from '../../color.js';
+import {
+  ColorType,
+  NumberArrayType,
+  SizeType,
+  newParsingContext,
+} from '../../expr/expression.js';
+import {
+  buildExpression,
+  getStringNumberEquivalent,
+  uniformNameForVariable,
+} from '../../expr/gpu.js';
+
+/**
+ * Recursively parses a style expression and outputs a GLSL-compatible string. Takes in a compilation context that
+ * will be read and modified during the parsing operation.
+ * @param {import("../../expr/gpu.js").CompilationContext} compilationContext Compilation context
+ * @param {import("../../expr/expression.js").EncodedExpression} value Value
+ * @param {number} [expectedType] Expected final type (can be several types combined)
+ * @return {string} GLSL-compatible output
+ */
+export function expressionToGlsl(compilationContext, value, expectedType) {
+  const parsingContext = newParsingContext();
+  return buildExpression(
+    value,
+    expectedType,
+    parsingContext,
+    compilationContext,
+  );
+}
+
+/**
+ * Packs all components of a color into a two-floats array
+ * @param {import("../../color.js").Color|string} color Color as array of numbers or string
+ * @return {Array<number>} Vec2 array containing the color in compressed form
+ */
+export function packColor(color) {
+  const array = asArray(color);
+  const r = array[0] * 256;
+  const g = array[1];
+  const b = array[2] * 256;
+  const a = Math.round(array[3] * 255);
+  return [r + g, b + a];
+}
+
+export const UNPACK_COLOR_FN = `vec4 unpackColor(vec2 packedColor) {
+  return vec4(
+    fract(floor(packedColor[0] / 256.0) / 256.0),
+    fract(packedColor[0] / 256.0),
+    fract(floor(packedColor[1] / 256.0) / 256.0),
+    fract(packedColor[1] / 256.0)
+  );
+}`;
+
+/**
+ * @param {number} type Value type
+ * @return {1|2|3|4} The amount of components for this value
+ */
+export function getGlslSizeFromType(type) {
+  if (type === ColorType || type === SizeType) {
+    return 2;
+  }
+  if (type === NumberArrayType) {
+    return 4;
+  }
+  return 1;
+}
+
+/**
+ * @param {number} type Value type
+ * @return {'float'|'vec2'|'vec3'|'vec4'} The corresponding GLSL type for this value
+ */
+export function getGlslTypeFromType(type) {
+  const size = getGlslSizeFromType(type);
+  if (size > 1) {
+    return /** @type {'vec2'|'vec3'|'vec4'} */ (`vec${size}`);
+  }
+  return 'float';
+}
+
+/**
+ * Applies the properties and variables collected in a compilation context to a ShaderBuilder instance:
+ * properties will show up as attributes in shaders, and variables will show up as uniforms.
+ * @param {import("./ShaderBuilder.js").ShaderBuilder} builder Shader builder
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ */
+export function applyContextToBuilder(builder, context) {
+  // define one uniform per variable
+  for (const varName in context.variables) {
+    const variable = context.variables[varName];
+    const uniformName = uniformNameForVariable(variable.name);
+    let glslType = getGlslTypeFromType(variable.type);
+    if (variable.type === ColorType) {
+      // we're not packing colors when they're passed as uniforms
+      glslType = 'vec4';
+    }
+    builder.addUniform(`${glslType} ${uniformName}`);
+  }
+
+  // for each feature attribute used in the fragment shader, define a varying that will be used to pass data
+  // from the vertex to the fragment shader, as well as an attribute in the vertex shader (if not already present)
+  for (const propName in context.properties) {
+    const property = context.properties[propName];
+    const glslType = getGlslTypeFromType(property.type);
+    const attributeName = `a_prop_${property.name}`;
+    if (property.type === ColorType) {
+      builder.addAttribute(
+        attributeName,
+        glslType,
+        `unpackColor(${attributeName})`,
+        'vec4',
+      );
+      builder.addVertexShaderFunction(UNPACK_COLOR_FN);
+    } else {
+      builder.addAttribute(attributeName, glslType);
+    }
+  }
+
+  // add functions that were collected in the compilation contexts
+  for (const functionName in context.functions) {
+    builder.addVertexShaderFunction(context.functions[functionName]);
+    builder.addFragmentShaderFunction(context.functions[functionName]);
+  }
+}
+
+/**
+ * Generates a set of uniforms from variables collected in a compilation context,
+ * to be fed to a WebGLHelper instance
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ * @param {import('../../style/flat.js').StyleVariables} [variables] Style variables.
+ * @return {Object<string,import("../../webgl/Helper").UniformValue>} Uniforms
+ */
+export function generateUniformsFromContext(context, variables) {
+  /** @type {Object<string,import("../../webgl/Helper").UniformValue>} */
+  const uniforms = {};
+
+  // define one uniform per variable
+  for (const varName in context.variables) {
+    const variable = context.variables[varName];
+    const uniformName = uniformNameForVariable(variable.name);
+
+    uniforms[uniformName] = () => {
+      const value = variables[variable.name];
+      if (typeof value === 'number') {
+        return value;
+      }
+      if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+      }
+      if (variable.type === ColorType) {
+        return asArray(value || '#eee');
+      }
+      if (typeof value === 'string') {
+        return getStringNumberEquivalent(value);
+      }
+      return value;
+    };
+  }
+
+  return uniforms;
+}
+
+/**
+ * Generates a set of attributes from properties collected in a compilation context,
+ * to be fed to a WebGLHelper instance
+ * @param {import("../../expr/gpu.js").CompilationContext} context Compilation context
+ * @return {import('./VectorStyleRenderer.js').AttributeDefinitions} Attributes
+ */
+export function generateAttributesFromContext(context) {
+  /**
+   * @type {import('./VectorStyleRenderer.js').AttributeDefinitions}
+   */
+  const attributes = {};
+
+  // Define attributes with their callback for each property used in the vertex shader
+  for (const propName in context.properties) {
+    const property = context.properties[propName];
+    const callback = (feature) => {
+      const value = feature.get(property.name);
+      if (property.type === ColorType) {
+        return packColor([...asArray(value || '#eee')]);
+      }
+      if (typeof value === 'string') {
+        return getStringNumberEquivalent(value);
+      }
+      if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+      }
+      return value;
+    };
+
+    attributes[`prop_${property.name}`] = {
+      size: getGlslSizeFromType(property.type),
+      callback,
+    };
+  }
+  return attributes;
+}

package/render/webgl/encodeUtil.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utilities for encoding/decoding values to be used in shaders
+ * @module ol/render/webgl/encodeUtil
+ */
+/**
+ * Generates a color array based on a numerical id
+ * Note: the range for each component is 0 to 1 with 256 steps
+ * @param {number} id Id
+ * @param {Array<number>} [array] Reusable array
+ * @return {Array<number>} Color array containing the encoded id
+ */
+export function colorEncodeId(id: number, array?: Array<number>): Array<number>;
+/**
+ * Reads an id from a color-encoded array
+ * Note: the expected range for each component is 0 to 1 with 256 steps.
+ * @param {Array<number>} color Color array containing the encoded id
+ * @return {number} Decoded id
+ */
+export function colorDecodeId(color: Array<number>): number;
+//# sourceMappingURL=encodeUtil.d.ts.map

package/render/webgl/encodeUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeUtil.d.ts","sourceRoot":"","sources":["encodeUtil.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,kCAJW,MAAM,UACN,KAAK,CAAC,MAAM,CAAC,GACZ,KAAK,CAAC,MAAM,CAAC,CAWxB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,CAAC,MAAM,CAAC,GACZ,MAAM,CAWjB"}

package/render/webgl/encodeUtil.js

@@ -0,0 +1,39 @@
+/**
+ * Utilities for encoding/decoding values to be used in shaders
+ * @module ol/render/webgl/encodeUtil
+ */
+
+/**
+ * Generates a color array based on a numerical id
+ * Note: the range for each component is 0 to 1 with 256 steps
+ * @param {number} id Id
+ * @param {Array<number>} [array] Reusable array
+ * @return {Array<number>} Color array containing the encoded id
+ */
+export function colorEncodeId(id, array) {
+  array = array || [];
+  const radix = 256;
+  const divide = radix - 1;
+  array[0] = Math.floor(id / radix / radix / radix) / divide;
+  array[1] = (Math.floor(id / radix / radix) % radix) / divide;
+  array[2] = (Math.floor(id / radix) % radix) / divide;
+  array[3] = (id % radix) / divide;
+  return array;
+}
+
+/**
+ * Reads an id from a color-encoded array
+ * Note: the expected range for each component is 0 to 1 with 256 steps.
+ * @param {Array<number>} color Color array containing the encoded id
+ * @return {number} Decoded id
+ */
+export function colorDecodeId(color) {
+  let id = 0;
+  const radix = 256;
+  const mult = radix - 1;
+  id += Math.round(color[0] * radix * radix * radix * mult);
+  id += Math.round(color[1] * radix * radix * mult);
+  id += Math.round(color[2] * radix * mult);
+  id += Math.round(color[3] * mult);
+  return id;
+}

package/render/webgl/style.d.ts

@@ -0,0 +1,57 @@
+/**
+ * see https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+ * @param {Object|string} input The hash input, either an object or string
+ * @return {string} Hash (if the object cannot be serialized, it is based on `getUid`)
+ */
+export function computeHash(input: any | string): string;
+/**
+ * @typedef {Object} StyleParseResult
+ * @property {ShaderBuilder} builder Shader builder pre-configured according to a given style
+ * @property {import("./VectorStyleRenderer.js").UniformDefinitions} uniforms Uniform definitions
+ * @property {import("./VectorStyleRenderer.js").AttributeDefinitions} attributes Attribute definitions
+ */
+/**
+ * Parses a {@link import("../../style/flat.js").FlatStyle} object and returns a {@link ShaderBuilder}
+ * object that has been configured according to the given style, as well as `attributes` and `uniforms`
+ * arrays to be fed to the `WebGLPointsRenderer` class.
+ *
+ * Also returns `uniforms` and `attributes` properties as expected by the
+ * {@link module:ol/renderer/webgl/PointsLayer~WebGLPointsLayerRenderer}.
+ *
+ * @param {import("../../style/flat.js").FlatStyle} style Flat style.
+ * @param {import('../../style/flat.js').StyleVariables} [variables] Style variables.
+ * @param {import("../../expr/expression.js").EncodedExpression} [filter] Filter (if any)
+ * @return {StyleParseResult} Result containing shader params, attributes and uniforms.
+ */
+export function parseLiteralStyle(style: import("../../style/flat.js").FlatStyle, variables?: import("../../style/flat.js").StyleVariables, filter?: import("../../expr/expression.js").EncodedExpression): StyleParseResult;
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ */
+/**
+ * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
+ */
+/**
+ * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
+ * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
+ * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
+ * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
+ */
+export function breakDownFlatStyle(style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders): Array<StyleAsShaders | StyleAsRule>;
+export type StyleParseResult = {
+    /**
+     * Shader builder pre-configured according to a given style
+     */
+    builder: ShaderBuilder;
+    /**
+     * Uniform definitions
+     */
+    uniforms: import("./VectorStyleRenderer.js").UniformDefinitions;
+    /**
+     * Attribute definitions
+     */
+    attributes: import("./VectorStyleRenderer.js").AttributeDefinitions;
+};
+export type StyleAsShaders = import("./VectorStyleRenderer.js").AsShaders;
+export type StyleAsRule = import("./VectorStyleRenderer.js").AsRule;
+import { ShaderBuilder } from './ShaderBuilder.js';
+//# sourceMappingURL=style.d.ts.map

package/render/webgl/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["style.js"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,mCAHW,MAAO,MAAM,GACZ,MAAM,CAOjB;AAyrBD;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,yCALW,OAAO,qBAAqB,EAAE,SAAS,cACvC,OAAO,qBAAqB,EAAE,cAAc,WAC5C,OAAO,0BAA0B,EAAE,iBAAiB,GACnD,gBAAgB,CAyE3B;AAED;;GAEG;AACH;;GAEG;AAEH;;;;;GAKG;AACH,0CAHW,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc,GACnF,KAAK,CAAC,cAAc,GAAG,WAAW,CAAC,CA2D9C;;;;;aAjKa,aAAa;;;;cACb,OAAO,0BAA0B,EAAE,kBAAkB;;;;gBACrD,OAAO,0BAA0B,EAAE,oBAAoB;;6BA0FxD,OAAO,0BAA0B,EAAE,SAAS;0BAG5C,OAAO,0BAA0B,EAAE,MAAM;8BA9yB1B,oBAAoB"}