@kepler.gl/deckgl-layers 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/raster/raster-mesh-layer/raster-mesh-layer.js

@@ -0,0 +1,318 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import { Geometry } from '@luma.gl/engine';
+import { Model } from '@luma.gl/engine';
+import { buildRasterMeshFragmentShader, buildRasterMeshVertexShader, rasterMeshUniforms } from './raster-mesh-layer-shaders';
+import { ensureRasterHooksRegistered, prepareLumaModules } from '../raster-layer/raster-layer-shaders';
+import { loadImages } from '../images';
+import { modulesEqual, applyModuleUniforms } from '../util';
+import { patchPipelineValidation } from '../pipeline-validation-patch';
+import { rasterProcessingUniforms } from '../raster-processing-uniforms';
+import { TOPOLOGY } from '@kepler.gl/constants';
+function validateGeometryAttributes(attributes) {
+  if (!(attributes.positions || attributes.POSITION)) {
+    throw new Error('RasterMeshLayer requires "positions" or "POSITION" attribute in mesh property.');
+  }
+}
+
+/*
+ * Convert mesh data into geometry
+ * @returns geometry
+ */
+function getGeometry(data) {
+  if ('attributes' in data && data.attributes) {
+    validateGeometryAttributes(data.attributes);
+    if (data instanceof Geometry) {
+      return data;
+    }
+    return new Geometry(data);
+  } else if ('positions' in data || 'POSITION' in data) {
+    validateGeometryAttributes(data);
+    return new Geometry({
+      attributes: data
+    });
+  }
+  throw Error('Invalid mesh');
+}
+var defaultProps = _objectSpread(_objectSpread({}, SimpleMeshLayer.defaultProps), {}, {
+  modules: {
+    type: 'array',
+    value: [],
+    compare: true
+  },
+  images: {
+    type: 'object',
+    value: {},
+    compare: true
+  },
+  moduleProps: {
+    type: 'object',
+    value: {},
+    compare: true
+  },
+  onRedrawNeeded: {
+    type: 'function',
+    value: null,
+    compare: false
+  }
+});
+var RasterMeshLayer = /*#__PURE__*/function (_SimpleMeshLayer) {
+  function RasterMeshLayer() {
+    var _this;
+    _classCallCheck(this, RasterMeshLayer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, RasterMeshLayer, [].concat(args));
+    _defineProperty(_this, "_redrawScheduled", false);
+    _defineProperty(_this, "_pendingImageRetry", null);
+    /** How many consecutive frames have retried a failed texture upload. */
+    _defineProperty(_this, "_imageRetryCount", 0);
+    return _this;
+  }
+  _inherits(RasterMeshLayer, _SimpleMeshLayer);
+  return _createClass(RasterMeshLayer, [{
+    key: "initializeState",
+    value: function initializeState() {
+      patchPipelineValidation();
+      ensureRasterHooksRegistered();
+      this.setState({
+        images: {}
+      });
+      _superPropGet(RasterMeshLayer, "initializeState", this, 3)([]);
+    }
+  }, {
+    key: "getShaders",
+    value: function getShaders() {
+      var _this$props$modules = this.props.modules,
+        modules = _this$props$modules === void 0 ? [] : _this$props$modules;
+      var lumaModules = prepareLumaModules(modules);
+      var parentShaders = _superPropGet(RasterMeshLayer, "getShaders", this, 3)([]);
+
+      // Filter out simpleMeshUniforms from parent — RasterMeshLayer uses its own
+      // shaders that don't reference SimpleMesh uniforms, and every UBO counts
+      // against the WebGL2 GL_MAX_FRAGMENT_UNIFORM_BUFFERS limit (typically 12).
+      var parentModules = (parentShaders.modules || []).filter(function (m) {
+        return m.name !== 'simpleMesh';
+      });
+      return _objectSpread(_objectSpread({}, parentShaders), {}, {
+        vs: buildRasterMeshVertexShader(),
+        fs: buildRasterMeshFragmentShader(),
+        modules: [].concat(_toConsumableArray(parentModules), [rasterMeshUniforms, rasterProcessingUniforms], _toConsumableArray(lumaModules))
+      });
+    }
+
+    // eslint-disable-next-line complexity
+  }, {
+    key: "updateState",
+    value: function updateState(params) {
+      var props = params.props,
+        oldProps = params.oldProps,
+        changeFlags = params.changeFlags,
+        context = params.context;
+      _superPropGet(RasterMeshLayer, "updateState", this, 3)([{
+        props: props,
+        oldProps: oldProps,
+        changeFlags: changeFlags,
+        context: context
+      }]);
+      var modules = props && props.modules;
+      var oldModules = oldProps && oldProps.modules;
+      if (props.mesh !== oldProps.mesh || changeFlags.extensionsChanged || !modulesEqual(modules, oldModules)) {
+        var _this$getAttributeMan;
+        if (this.state.model) {
+          var _this$state$model$des, _this$state$model;
+          (_this$state$model$des = (_this$state$model = this.state.model).destroy) === null || _this$state$model$des === void 0 || _this$state$model$des.call(_this$state$model);
+        }
+        if (props.mesh) {
+          this.state.model = this.getModel(props.mesh);
+          var attributes = props.mesh.attributes || props.mesh;
+          this.setState({
+            hasNormals: Boolean(attributes.NORMAL || attributes.normals)
+          });
+        }
+        (_this$getAttributeMan = this.getAttributeManager()) === null || _this$getAttributeMan === void 0 || _this$getAttributeMan.invalidateAll();
+      }
+      if (props && props.images) {
+        this.updateImages({
+          props: props,
+          oldProps: oldProps
+        });
+      }
+      if (this.state.model) {
+        var _this$state$model$set, _this$state$model2;
+        (_this$state$model$set = (_this$state$model2 = this.state.model).setTopology) === null || _this$state$model$set === void 0 || _this$state$model$set.call(_this$state$model2, this.props.wireframe ? TOPOLOGY.LINE_STRIP : TOPOLOGY.TRIANGLE_LIST);
+      }
+    }
+  }, {
+    key: "updateImages",
+    value: function updateImages(_ref) {
+      var props = _ref.props,
+        oldProps = _ref.oldProps;
+      var images = this.state.images;
+      var device = this.context.device;
+      var gl = (device === null || device === void 0 ? void 0 : device.gl) || this.context.gl;
+      var _loadImages = loadImages({
+          gl: gl,
+          device: device,
+          images: images,
+          imagesData: props.images,
+          oldImagesData: oldProps.images
+        }),
+        newImages = _loadImages.images,
+        hasPendingUploads = _loadImages.hasPendingUploads;
+      if (newImages) {
+        this.setState({
+          images: newImages
+        });
+      }
+      // If any texture upload failed, stash the imagesData and schedule a retry
+      // next frame. The retry passes oldImagesData: {} so all keys bypass the
+      // isEqual skip-check.
+      if (hasPendingUploads) {
+        this._pendingImageRetry = props.images;
+        this._imageRetryCount = 0;
+        this._scheduleRedraw();
+      }
+    }
+  }, {
+    key: "draw",
+    value: function draw(_opts) {
+      var _this$props$opacity;
+      // If a previous frame had failed texture uploads, retry them now before
+      // checking whether the images state is complete. Pass oldImagesData: {} so
+      // all keys are treated as new and bypass the isEqual skip-check.
+      // Retries are bounded to MAX_IMAGE_RETRY_ATTEMPTS to avoid an infinite
+      // redraw loop when image data is permanently invalid.
+      if (this._pendingImageRetry) {
+        var _this$context$device;
+        var retry = this._pendingImageRetry;
+        this._pendingImageRetry = null;
+        var _loadImages2 = loadImages({
+            gl: ((_this$context$device = this.context.device) === null || _this$context$device === void 0 ? void 0 : _this$context$device.gl) || this.context.gl,
+            device: this.context.device,
+            images: this.state.images,
+            imagesData: retry,
+            oldImagesData: {}
+          }),
+          newImages = _loadImages2.images,
+          hasPendingUploads = _loadImages2.hasPendingUploads;
+        if (newImages) {
+          this.setState({
+            images: newImages
+          });
+        }
+        if (hasPendingUploads) {
+          this._imageRetryCount++;
+          if (this._imageRetryCount < RasterMeshLayer.MAX_IMAGE_RETRY_ATTEMPTS) {
+            this._pendingImageRetry = retry;
+            this._scheduleRedraw();
+          } else {
+            console.warn("RasterMeshLayer: texture upload failed after ".concat(RasterMeshLayer.MAX_IMAGE_RETRY_ATTEMPTS, " attempts, giving up."));
+            this._imageRetryCount = 0;
+          }
+        } else {
+          this._imageRetryCount = 0;
+        }
+      }
+      var _this$state = this.state,
+        model = _this$state.model,
+        images = _this$state.images;
+      var moduleProps = this.props.moduleProps;
+      if (!model || !images || Object.keys(images).length === 0 || !Object.values(images).every(function (item) {
+        return item;
+      })) {
+        return;
+      }
+
+      // Set mesh-specific UBO uniforms
+      model.shaderInputs.setProps({
+        rasterMesh: {
+          meshOpacity: (_this$props$opacity = this.props.opacity) !== null && _this$props$opacity !== void 0 ? _this$props$opacity : 1,
+          meshFlatShading: !this.state.hasNormals ? 1.0 : 0.0
+        }
+      });
+
+      // Apply each custom module's uniforms/bindings to shaderInputs directly.
+      // We call getUniforms once per module and write the results into
+      // shaderInputs.moduleUniforms/moduleBindings, bypassing setProps() which
+      // would call getUniforms a second time on already-transformed values.
+      var allModuleProps = _objectSpread(_objectSpread({}, moduleProps), images);
+      var modules = this.props.modules || [];
+      applyModuleUniforms(model.shaderInputs, modules, allModuleProps);
+      var drawSuccess = model.draw(this.context.renderPass);
+      if (!drawSuccess) {
+        this._scheduleRedraw();
+      }
+    }
+  }, {
+    key: "_scheduleRedraw",
+    value: function _scheduleRedraw() {
+      var _this2 = this;
+      if (this._redrawScheduled) return;
+      this._redrawScheduled = true;
+      requestAnimationFrame(function () {
+        var _this2$context$layerM;
+        _this2._redrawScheduled = false;
+        if (_this2.context.deck) {
+          // @ts-expect-error accessing private deck.gl property
+          _this2.context.deck._needsRedraw = 'RasterMeshLayer pipeline pending';
+        }
+        (_this2$context$layerM = _this2.context.layerManager) === null || _this2$context$layerM === void 0 || _this2$context$layerM.setNeedsRedraw('RasterMeshLayer pipeline pending');
+        if (typeof _this2.props.onRedrawNeeded === 'function') {
+          _this2.props.onRedrawNeeded();
+        }
+      });
+    }
+  }, {
+    key: "finalizeState",
+    value: function finalizeState() {
+      _superPropGet(RasterMeshLayer, "finalizeState", this, 3)([this.context]);
+      if (this.state.images) {
+        for (var _i = 0, _Object$values = Object.values(this.state.images); _i < _Object$values.length; _i++) {
+          var image = _Object$values[_i];
+          if (Array.isArray(image)) {
+            image.map(function (x) {
+              var _x$delete;
+              return x && (x.destroy ? x.destroy() : (_x$delete = x["delete"]) === null || _x$delete === void 0 ? void 0 : _x$delete.call(x));
+            });
+          } else if (image) {
+            var _image$delete;
+            image.destroy ? image.destroy() : (_image$delete = image["delete"]) === null || _image$delete === void 0 ? void 0 : _image$delete.call(image);
+          }
+        }
+      }
+    }
+  }, {
+    key: "getModel",
+    value: function getModel(mesh) {
+      var device = this.context.device || this.context.gl;
+      var model = new Model(device, Object.assign({}, this.getShaders(), {
+        id: this.props.id,
+        geometry: getGeometry(mesh),
+        isInstanced: false
+      }));
+      return model;
+    }
+  }]);
+}(SimpleMeshLayer);
+_defineProperty(RasterMeshLayer, "MAX_IMAGE_RETRY_ATTEMPTS", 3);
+export { RasterMeshLayer as default };
+RasterMeshLayer.layerName = 'RasterMeshLayer';
+RasterMeshLayer.defaultProps = defaultProps;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SimpleMeshLayer","Geometry","Model","buildRasterMeshFragmentShader","buildRasterMeshVertexShader","rasterMeshUniforms","ensureRasterHooksRegistered","prepareLumaModules","loadImages","modulesEqual","applyModuleUniforms","patchPipelineValidation","rasterProcessingUniforms","TOPOLOGY","validateGeometryAttributes","attributes","positions","POSITION","Error","getGeometry","data","defaultProps","_objectSpread","modules","type","value","compare","images","moduleProps","onRedrawNeeded","RasterMeshLayer","_SimpleMeshLayer","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","_inherits","_createClass","key","initializeState","setState","_superPropGet","getShaders","_this$props$modules","props","lumaModules","parentShaders","parentModules","filter","m","name","vs","fs","_toConsumableArray","updateState","params","oldProps","changeFlags","context","oldModules","mesh","extensionsChanged","_this$getAttributeMan","state","model","_this$state$model$des","_this$state$model","destroy","call","getModel","hasNormals","Boolean","NORMAL","normals","getAttributeManager","invalidateAll","updateImages","_this$state$model$set","_this$state$model2","setTopology","wireframe","LINE_STRIP","TRIANGLE_LIST","_ref","device","gl","_loadImages","imagesData","oldImagesData","newImages","hasPendingUploads","_pendingImageRetry","_imageRetryCount","_scheduleRedraw","draw","_opts","_this$props$opacity","_this$context$device","retry","_loadImages2","MAX_IMAGE_RETRY_ATTEMPTS","console","warn","_this$state","Object","keys","values","every","item","shaderInputs","setProps","rasterMesh","meshOpacity","opacity","meshFlatShading","allModuleProps","drawSuccess","renderPass","_this2","_redrawScheduled","requestAnimationFrame","_this2$context$layerM","deck","_needsRedraw","layerManager","setNeedsRedraw","finalizeState","_i","_Object$values","image","isArray","map","x","_x$delete","_image$delete","assign","id","geometry","isInstanced","default","layerName"],"sources":["../../../../src/raster/raster-mesh-layer/raster-mesh-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {UpdateParameters} from '@deck.gl/core';\nimport {SimpleMeshLayer, SimpleMeshLayerProps} from '@deck.gl/mesh-layers';\nimport {Geometry} from '@luma.gl/engine';\nimport {Model} from '@luma.gl/engine';\n\nimport {\n  buildRasterMeshFragmentShader,\n  buildRasterMeshVertexShader,\n  rasterMeshUniforms\n} from './raster-mesh-layer-shaders';\nimport {\n  ensureRasterHooksRegistered,\n  prepareLumaModules\n} from '../raster-layer/raster-layer-shaders';\nimport {loadImages} from '../images';\nimport type {RasterLayerAddedProps, ImageState} from '../types';\nimport {modulesEqual, applyModuleUniforms} from '../util';\nimport {patchPipelineValidation} from '../pipeline-validation-patch';\nimport {rasterProcessingUniforms} from '../raster-processing-uniforms';\nimport {TOPOLOGY} from '@kepler.gl/constants';\n\ntype Mesh = SimpleMeshLayerProps['mesh'];\n\ninterface MeshData {\n  attributes?: Record<string, unknown>;\n  positions?: unknown;\n  POSITION?: unknown;\n  NORMAL?: unknown;\n  normals?: unknown;\n  [key: string]: unknown;\n}\n\nfunction validateGeometryAttributes(attributes: Record<string, unknown>) {\n  if (!(attributes.positions || attributes.POSITION)) {\n    throw new Error(\n      'RasterMeshLayer requires \"positions\" or \"POSITION\" attribute in mesh property.'\n    );\n  }\n}\n\n/*\n * Convert mesh data into geometry\n * @returns geometry\n */\nfunction getGeometry(data: MeshData | Geometry): Geometry {\n  if ('attributes' in data && data.attributes) {\n    validateGeometryAttributes(data.attributes);\n    if (data instanceof Geometry) {\n      return data;\n    }\n    return new Geometry(data as ConstructorParameters<typeof Geometry>[0]);\n  } else if ('positions' in data || 'POSITION' in data) {\n    validateGeometryAttributes(data as Record<string, unknown>);\n    return new Geometry({\n      attributes: data as Record<string, unknown>\n    } as ConstructorParameters<typeof Geometry>[0]);\n  }\n  throw Error('Invalid mesh');\n}\n\nconst defaultProps = {\n  ...SimpleMeshLayer.defaultProps,\n  modules: {type: 'array', value: [], compare: true},\n  images: {type: 'object', value: {}, compare: true},\n  moduleProps: {type: 'object', value: {}, compare: true},\n  onRedrawNeeded: {type: 'function', value: null, compare: false}\n};\n\nexport default class RasterMeshLayer extends SimpleMeshLayer<any, RasterLayerAddedProps> {\n  declare state: SimpleMeshLayer<RasterLayerAddedProps>['state'] & {\n    images: ImageState;\n  };\n\n  _redrawScheduled = false;\n  _pendingImageRetry: RasterLayerAddedProps['images'] | null = null;\n  /** How many consecutive frames have retried a failed texture upload. */\n  _imageRetryCount = 0;\n  static readonly MAX_IMAGE_RETRY_ATTEMPTS = 3;\n\n  initializeState(): void {\n    patchPipelineValidation();\n    ensureRasterHooksRegistered();\n    this.setState({images: {}});\n    super.initializeState();\n  }\n\n  getShaders(): any {\n    const {modules = []} = this.props;\n\n    const lumaModules = prepareLumaModules(modules);\n    const parentShaders = super.getShaders();\n\n    // Filter out simpleMeshUniforms from parent — RasterMeshLayer uses its own\n    // shaders that don't reference SimpleMesh uniforms, and every UBO counts\n    // against the WebGL2 GL_MAX_FRAGMENT_UNIFORM_BUFFERS limit (typically 12).\n    const parentModules = (parentShaders.modules || []).filter(\n      (m: {name?: string}) => m.name !== 'simpleMesh'\n    );\n\n    return {\n      ...parentShaders,\n      vs: buildRasterMeshVertexShader(),\n      fs: buildRasterMeshFragmentShader(),\n      modules: [...parentModules, rasterMeshUniforms, rasterProcessingUniforms, ...lumaModules]\n    };\n  }\n\n  // eslint-disable-next-line complexity\n  updateState(params: UpdateParameters<SimpleMeshLayer<any, RasterLayerAddedProps>>): void {\n    const {props, oldProps, changeFlags, context} = params;\n    super.updateState({props, oldProps, changeFlags, context});\n\n    const modules = props && props.modules;\n    const oldModules = oldProps && oldProps.modules;\n\n    if (\n      props.mesh !== oldProps.mesh ||\n      changeFlags.extensionsChanged ||\n      !modulesEqual(modules, oldModules)\n    ) {\n      if (this.state.model) {\n        this.state.model.destroy?.();\n      }\n      if (props.mesh) {\n        this.state.model = this.getModel(props.mesh as Mesh);\n\n        const attributes = ((props.mesh as MeshData).attributes || props.mesh) as MeshData;\n        this.setState({\n          hasNormals: Boolean(attributes.NORMAL || attributes.normals)\n        });\n      }\n      this.getAttributeManager()?.invalidateAll();\n    }\n\n    if (props && props.images) {\n      this.updateImages({props, oldProps});\n    }\n\n    if (this.state.model) {\n      this.state.model.setTopology?.(\n        this.props.wireframe ? TOPOLOGY.LINE_STRIP : TOPOLOGY.TRIANGLE_LIST\n      );\n    }\n  }\n\n  updateImages({\n    props,\n    oldProps\n  }: {\n    props: RasterLayerAddedProps;\n    oldProps: RasterLayerAddedProps;\n  }): void {\n    const {images} = this.state;\n    const device = this.context.device;\n    const gl = device?.gl || this.context.gl;\n\n    const {images: newImages, hasPendingUploads} = loadImages({\n      gl,\n      device,\n      images,\n      imagesData: props.images,\n      oldImagesData: oldProps.images\n    });\n\n    if (newImages) {\n      this.setState({images: newImages});\n    }\n    // If any texture upload failed, stash the imagesData and schedule a retry\n    // next frame. The retry passes oldImagesData: {} so all keys bypass the\n    // isEqual skip-check.\n    if (hasPendingUploads) {\n      this._pendingImageRetry = props.images;\n      this._imageRetryCount = 0;\n      this._scheduleRedraw();\n    }\n  }\n\n  draw(_opts: Record<string, unknown>): void {\n    // If a previous frame had failed texture uploads, retry them now before\n    // checking whether the images state is complete. Pass oldImagesData: {} so\n    // all keys are treated as new and bypass the isEqual skip-check.\n    // Retries are bounded to MAX_IMAGE_RETRY_ATTEMPTS to avoid an infinite\n    // redraw loop when image data is permanently invalid.\n    if (this._pendingImageRetry) {\n      const retry = this._pendingImageRetry;\n      this._pendingImageRetry = null;\n      const {images: newImages, hasPendingUploads} = loadImages({\n        gl: this.context.device?.gl || this.context.gl,\n        device: this.context.device,\n        images: this.state.images,\n        imagesData: retry,\n        oldImagesData: {}\n      });\n      if (newImages) {\n        this.setState({images: newImages});\n      }\n      if (hasPendingUploads) {\n        this._imageRetryCount++;\n        if (this._imageRetryCount < RasterMeshLayer.MAX_IMAGE_RETRY_ATTEMPTS) {\n          this._pendingImageRetry = retry;\n          this._scheduleRedraw();\n        } else {\n          console.warn(\n            `RasterMeshLayer: texture upload failed after ${RasterMeshLayer.MAX_IMAGE_RETRY_ATTEMPTS} attempts, giving up.`\n          );\n          this._imageRetryCount = 0;\n        }\n      } else {\n        this._imageRetryCount = 0;\n      }\n    }\n\n    const {model, images} = this.state;\n    const {moduleProps} = this.props;\n\n    if (\n      !model ||\n      !images ||\n      Object.keys(images).length === 0 ||\n      !Object.values(images).every(item => item)\n    ) {\n      return;\n    }\n\n    // Set mesh-specific UBO uniforms\n    model.shaderInputs.setProps({\n      rasterMesh: {\n        meshOpacity: this.props.opacity ?? 1,\n        meshFlatShading: !this.state.hasNormals ? 1.0 : 0.0\n      }\n    });\n\n    // Apply each custom module's uniforms/bindings to shaderInputs directly.\n    // We call getUniforms once per module and write the results into\n    // shaderInputs.moduleUniforms/moduleBindings, bypassing setProps() which\n    // would call getUniforms a second time on already-transformed values.\n    const allModuleProps = {...moduleProps, ...images};\n    const modules = this.props.modules || [];\n    applyModuleUniforms(model.shaderInputs, modules, allModuleProps);\n\n    const drawSuccess = model.draw(this.context.renderPass);\n    if (!drawSuccess) {\n      this._scheduleRedraw();\n    }\n  }\n\n  _scheduleRedraw(): void {\n    if (this._redrawScheduled) return;\n    this._redrawScheduled = true;\n    requestAnimationFrame(() => {\n      this._redrawScheduled = false;\n      if (this.context.deck) {\n        // @ts-expect-error accessing private deck.gl property\n        this.context.deck._needsRedraw = 'RasterMeshLayer pipeline pending';\n      }\n      this.context.layerManager?.setNeedsRedraw('RasterMeshLayer pipeline pending');\n      if (typeof this.props.onRedrawNeeded === 'function') {\n        this.props.onRedrawNeeded();\n      }\n    });\n  }\n\n  finalizeState(): void {\n    super.finalizeState(this.context);\n\n    if (this.state.images) {\n      for (const image of Object.values(this.state.images)) {\n        if (Array.isArray(image)) {\n          image.map(x => x && (x.destroy ? x.destroy() : x.delete?.()));\n        } else if (image) {\n          image.destroy ? image.destroy() : image.delete?.();\n        }\n      }\n    }\n  }\n\n  protected getModel(mesh: Mesh): Model {\n    const device = this.context.device || this.context.gl;\n\n    const model = new Model(\n      device,\n      Object.assign({}, this.getShaders(), {\n        id: this.props.id,\n        geometry: getGeometry(mesh as MeshData | Geometry),\n        isInstanced: false\n      })\n    );\n\n    return model;\n  }\n}\n\nRasterMeshLayer.layerName = 'RasterMeshLayer';\nRasterMeshLayer.defaultProps = defaultProps;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/raster/raster-processing-uniforms.js

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Shared UBO for all raster processing module uniforms.
+ *
+ * WebGL2 guarantees only 12 fragment uniform blocks (GL_MAX_FRAGMENT_UNIFORM_BUFFERS).
+ * Without consolidation, the base layer already uses 8–9 blocks (project, picking,
+ * lighting, phongMaterial, floatColors, layer, shadow, simpleMesh/rasterMesh, raster),
+ * leaving only 3–4 for raster processing modules. Since a typical pipeline can use
+ * 5–9 raster modules (combineBands, mask, reorderBands, linearRescale, gammaContrast,
+ * sigmoidalContrast, colormap, filter, saturation), each declaring its own UBO block
+ * would exceed the limit.
+ *
+ * This module declares a single UBO that contains all possible raster processing
+ * uniforms. Individual modules' GLSL code still references the uniforms through
+ * the block instance name, and prepareLumaModules() rewires the declarations.
+ */
+
+var RASTER_PROCESSING_UNIFORM_BLOCK = "uniform rasterProcessingUniforms {\n  // linear_rescale\n  float linear_rescale_scaler;\n  float linear_rescale_offset;\n\n  // gamma_contrast\n  float gamma_contrast_gamma1;\n  float gamma_contrast_gamma2;\n  float gamma_contrast_gamma3;\n  float gamma_contrast_gamma4;\n\n  // sigmoidalContrast\n  float sigmoidalContrast_contrast;\n  float sigmoidalContrast_bias;\n\n  // colormap\n  int colormap_hasCategoricalColors;\n  int colormap_categoricalMinValue;\n  int colormap_categoricalMaxValue;\n  int colormap_maxPixelValue;\n\n  // bandFilter\n  float bandFilter_min1;\n  float bandFilter_max1;\n  float bandFilter_min2;\n  float bandFilter_max2;\n  float bandFilter_min3;\n  float bandFilter_max3;\n  float bandFilter_min4;\n  float bandFilter_max4;\n\n  // saturation\n  float saturation_value;\n\n  // reorder_bands\n  mat4 reorder_bands_ordering;\n\n  // mask (shared by mask_image_float, mask_image_uint, mask_image_int)\n  float mask_keepMin;\n  float mask_keepMax;\n\n  // pansharpen_brovey\n  float pansharpen_brovey_panWeight;\n} rasterProcessing;\n";
+
+/**
+ * GLSL #define aliases that let per-module code continue referencing uniforms
+ * through their original block instance names (e.g. `linear_rescale.scaler`).
+ */
+var ALIAS_DEFINES = "#define linear_rescale_scaler_ALIAS rasterProcessing.linear_rescale_scaler\n#define linear_rescale_offset_ALIAS rasterProcessing.linear_rescale_offset\n#define gamma_contrast_gamma1_ALIAS rasterProcessing.gamma_contrast_gamma1\n#define gamma_contrast_gamma2_ALIAS rasterProcessing.gamma_contrast_gamma2\n#define gamma_contrast_gamma3_ALIAS rasterProcessing.gamma_contrast_gamma3\n#define gamma_contrast_gamma4_ALIAS rasterProcessing.gamma_contrast_gamma4\n#define sigmoidalContrast_contrast_ALIAS rasterProcessing.sigmoidalContrast_contrast\n#define sigmoidalContrast_bias_ALIAS rasterProcessing.sigmoidalContrast_bias\n#define colormap_hasCategoricalColors_ALIAS rasterProcessing.colormap_hasCategoricalColors\n#define colormap_categoricalMinValue_ALIAS rasterProcessing.colormap_categoricalMinValue\n#define colormap_categoricalMaxValue_ALIAS rasterProcessing.colormap_categoricalMaxValue\n#define colormap_maxPixelValue_ALIAS rasterProcessing.colormap_maxPixelValue\n#define bandFilter_min1_ALIAS rasterProcessing.bandFilter_min1\n#define bandFilter_max1_ALIAS rasterProcessing.bandFilter_max1\n#define bandFilter_min2_ALIAS rasterProcessing.bandFilter_min2\n#define bandFilter_max2_ALIAS rasterProcessing.bandFilter_max2\n#define bandFilter_min3_ALIAS rasterProcessing.bandFilter_min3\n#define bandFilter_max3_ALIAS rasterProcessing.bandFilter_max3\n#define bandFilter_min4_ALIAS rasterProcessing.bandFilter_min4\n#define bandFilter_max4_ALIAS rasterProcessing.bandFilter_max4\n#define saturation_value_ALIAS rasterProcessing.saturation_value\n#define reorder_bands_ordering_ALIAS rasterProcessing.reorder_bands_ordering\n#define mask_keepMin_ALIAS rasterProcessing.mask_keepMin\n#define mask_keepMax_ALIAS rasterProcessing.mask_keepMax\n#define pansharpen_brovey_panWeight_ALIAS rasterProcessing.pansharpen_brovey_panWeight\n";
+export var RASTER_PROCESSING_FS = RASTER_PROCESSING_UNIFORM_BLOCK + ALIAS_DEFINES;
+export var rasterProcessingUniforms = {
+  name: 'rasterProcessing',
+  fs: RASTER_PROCESSING_FS,
+  vs: '',
+  uniformTypes: {
+    linear_rescale_scaler: 'f32',
+    linear_rescale_offset: 'f32',
+    gamma_contrast_gamma1: 'f32',
+    gamma_contrast_gamma2: 'f32',
+    gamma_contrast_gamma3: 'f32',
+    gamma_contrast_gamma4: 'f32',
+    sigmoidalContrast_contrast: 'f32',
+    sigmoidalContrast_bias: 'f32',
+    colormap_hasCategoricalColors: 'i32',
+    colormap_categoricalMinValue: 'i32',
+    colormap_categoricalMaxValue: 'i32',
+    colormap_maxPixelValue: 'i32',
+    bandFilter_min1: 'f32',
+    bandFilter_max1: 'f32',
+    bandFilter_min2: 'f32',
+    bandFilter_max2: 'f32',
+    bandFilter_min3: 'f32',
+    bandFilter_max3: 'f32',
+    bandFilter_min4: 'f32',
+    bandFilter_max4: 'f32',
+    saturation_value: 'f32',
+    reorder_bands_ordering: 'mat4x4<f32>',
+    mask_keepMin: 'f32',
+    mask_keepMax: 'f32',
+    pansharpen_brovey_panWeight: 'f32'
+  }
+};
+
+/**
+ * Map from original module uniform names (as returned by getUniforms) to
+ * the prefixed names used in the shared UBO.
+ */
+export var UNIFORM_NAME_MAP = {
+  linear_rescale: {
+    scaler: 'linear_rescale_scaler',
+    offset: 'linear_rescale_offset'
+  },
+  gamma_contrast: {
+    gamma1: 'gamma_contrast_gamma1',
+    gamma2: 'gamma_contrast_gamma2',
+    gamma3: 'gamma_contrast_gamma3',
+    gamma4: 'gamma_contrast_gamma4'
+  },
+  sigmoidalContrast: {
+    contrast: 'sigmoidalContrast_contrast',
+    bias: 'sigmoidalContrast_bias'
+  },
+  colormap: {
+    hasCategoricalColors: 'colormap_hasCategoricalColors',
+    categoricalMinValue: 'colormap_categoricalMinValue',
+    categoricalMaxValue: 'colormap_categoricalMaxValue',
+    maxPixelValue: 'colormap_maxPixelValue'
+  },
+  bandFilter: {
+    min1: 'bandFilter_min1',
+    max1: 'bandFilter_max1',
+    min2: 'bandFilter_min2',
+    max2: 'bandFilter_max2',
+    min3: 'bandFilter_min3',
+    max3: 'bandFilter_max3',
+    min4: 'bandFilter_min4',
+    max4: 'bandFilter_max4'
+  },
+  saturation: {
+    value: 'saturation_value'
+  },
+  reorder_bands: {
+    ordering: 'reorder_bands_ordering'
+  },
+  mask_image_float: {
+    keepMin: 'mask_keepMin',
+    keepMax: 'mask_keepMax'
+  },
+  mask_image_uint: {
+    keepMin: 'mask_keepMin',
+    keepMax: 'mask_keepMax'
+  },
+  mask_image_int: {
+    keepMin: 'mask_keepMin',
+    keepMax: 'mask_keepMax'
+  },
+  pansharpen_brovey: {
+    panWeight: 'pansharpen_brovey_panWeight'
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["RASTER_PROCESSING_UNIFORM_BLOCK","ALIAS_DEFINES","RASTER_PROCESSING_FS","rasterProcessingUniforms","name","fs","vs","uniformTypes","linear_rescale_scaler","linear_rescale_offset","gamma_contrast_gamma1","gamma_contrast_gamma2","gamma_contrast_gamma3","gamma_contrast_gamma4","sigmoidalContrast_contrast","sigmoidalContrast_bias","colormap_hasCategoricalColors","colormap_categoricalMinValue","colormap_categoricalMaxValue","colormap_maxPixelValue","bandFilter_min1","bandFilter_max1","bandFilter_min2","bandFilter_max2","bandFilter_min3","bandFilter_max3","bandFilter_min4","bandFilter_max4","saturation_value","reorder_bands_ordering","mask_keepMin","mask_keepMax","pansharpen_brovey_panWeight","UNIFORM_NAME_MAP","linear_rescale","scaler","offset","gamma_contrast","gamma1","gamma2","gamma3","gamma4","sigmoidalContrast","contrast","bias","colormap","hasCategoricalColors","categoricalMinValue","categoricalMaxValue","maxPixelValue","bandFilter","min1","max1","min2","max2","min3","max3","min4","max4","saturation","value","reorder_bands","ordering","mask_image_float","keepMin","keepMax","mask_image_uint","mask_image_int","pansharpen_brovey","panWeight"],"sources":["../../../src/raster/raster-processing-uniforms.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Shared UBO for all raster processing module uniforms.\n *\n * WebGL2 guarantees only 12 fragment uniform blocks (GL_MAX_FRAGMENT_UNIFORM_BUFFERS).\n * Without consolidation, the base layer already uses 8–9 blocks (project, picking,\n * lighting, phongMaterial, floatColors, layer, shadow, simpleMesh/rasterMesh, raster),\n * leaving only 3–4 for raster processing modules. Since a typical pipeline can use\n * 5–9 raster modules (combineBands, mask, reorderBands, linearRescale, gammaContrast,\n * sigmoidalContrast, colormap, filter, saturation), each declaring its own UBO block\n * would exceed the limit.\n *\n * This module declares a single UBO that contains all possible raster processing\n * uniforms. Individual modules' GLSL code still references the uniforms through\n * the block instance name, and prepareLumaModules() rewires the declarations.\n */\n\nconst RASTER_PROCESSING_UNIFORM_BLOCK = `\\\nuniform rasterProcessingUniforms {\n  // linear_rescale\n  float linear_rescale_scaler;\n  float linear_rescale_offset;\n\n  // gamma_contrast\n  float gamma_contrast_gamma1;\n  float gamma_contrast_gamma2;\n  float gamma_contrast_gamma3;\n  float gamma_contrast_gamma4;\n\n  // sigmoidalContrast\n  float sigmoidalContrast_contrast;\n  float sigmoidalContrast_bias;\n\n  // colormap\n  int colormap_hasCategoricalColors;\n  int colormap_categoricalMinValue;\n  int colormap_categoricalMaxValue;\n  int colormap_maxPixelValue;\n\n  // bandFilter\n  float bandFilter_min1;\n  float bandFilter_max1;\n  float bandFilter_min2;\n  float bandFilter_max2;\n  float bandFilter_min3;\n  float bandFilter_max3;\n  float bandFilter_min4;\n  float bandFilter_max4;\n\n  // saturation\n  float saturation_value;\n\n  // reorder_bands\n  mat4 reorder_bands_ordering;\n\n  // mask (shared by mask_image_float, mask_image_uint, mask_image_int)\n  float mask_keepMin;\n  float mask_keepMax;\n\n  // pansharpen_brovey\n  float pansharpen_brovey_panWeight;\n} rasterProcessing;\n`;\n\n/**\n * GLSL #define aliases that let per-module code continue referencing uniforms\n * through their original block instance names (e.g. `linear_rescale.scaler`).\n */\nconst ALIAS_DEFINES = `\\\n#define linear_rescale_scaler_ALIAS rasterProcessing.linear_rescale_scaler\n#define linear_rescale_offset_ALIAS rasterProcessing.linear_rescale_offset\n#define gamma_contrast_gamma1_ALIAS rasterProcessing.gamma_contrast_gamma1\n#define gamma_contrast_gamma2_ALIAS rasterProcessing.gamma_contrast_gamma2\n#define gamma_contrast_gamma3_ALIAS rasterProcessing.gamma_contrast_gamma3\n#define gamma_contrast_gamma4_ALIAS rasterProcessing.gamma_contrast_gamma4\n#define sigmoidalContrast_contrast_ALIAS rasterProcessing.sigmoidalContrast_contrast\n#define sigmoidalContrast_bias_ALIAS rasterProcessing.sigmoidalContrast_bias\n#define colormap_hasCategoricalColors_ALIAS rasterProcessing.colormap_hasCategoricalColors\n#define colormap_categoricalMinValue_ALIAS rasterProcessing.colormap_categoricalMinValue\n#define colormap_categoricalMaxValue_ALIAS rasterProcessing.colormap_categoricalMaxValue\n#define colormap_maxPixelValue_ALIAS rasterProcessing.colormap_maxPixelValue\n#define bandFilter_min1_ALIAS rasterProcessing.bandFilter_min1\n#define bandFilter_max1_ALIAS rasterProcessing.bandFilter_max1\n#define bandFilter_min2_ALIAS rasterProcessing.bandFilter_min2\n#define bandFilter_max2_ALIAS rasterProcessing.bandFilter_max2\n#define bandFilter_min3_ALIAS rasterProcessing.bandFilter_min3\n#define bandFilter_max3_ALIAS rasterProcessing.bandFilter_max3\n#define bandFilter_min4_ALIAS rasterProcessing.bandFilter_min4\n#define bandFilter_max4_ALIAS rasterProcessing.bandFilter_max4\n#define saturation_value_ALIAS rasterProcessing.saturation_value\n#define reorder_bands_ordering_ALIAS rasterProcessing.reorder_bands_ordering\n#define mask_keepMin_ALIAS rasterProcessing.mask_keepMin\n#define mask_keepMax_ALIAS rasterProcessing.mask_keepMax\n#define pansharpen_brovey_panWeight_ALIAS rasterProcessing.pansharpen_brovey_panWeight\n`;\n\nexport const RASTER_PROCESSING_FS = RASTER_PROCESSING_UNIFORM_BLOCK + ALIAS_DEFINES;\n\nexport const rasterProcessingUniforms = {\n  name: 'rasterProcessing',\n  fs: RASTER_PROCESSING_FS,\n  vs: '',\n  uniformTypes: {\n    linear_rescale_scaler: 'f32',\n    linear_rescale_offset: 'f32',\n    gamma_contrast_gamma1: 'f32',\n    gamma_contrast_gamma2: 'f32',\n    gamma_contrast_gamma3: 'f32',\n    gamma_contrast_gamma4: 'f32',\n    sigmoidalContrast_contrast: 'f32',\n    sigmoidalContrast_bias: 'f32',\n    colormap_hasCategoricalColors: 'i32',\n    colormap_categoricalMinValue: 'i32',\n    colormap_categoricalMaxValue: 'i32',\n    colormap_maxPixelValue: 'i32',\n    bandFilter_min1: 'f32',\n    bandFilter_max1: 'f32',\n    bandFilter_min2: 'f32',\n    bandFilter_max2: 'f32',\n    bandFilter_min3: 'f32',\n    bandFilter_max3: 'f32',\n    bandFilter_min4: 'f32',\n    bandFilter_max4: 'f32',\n    saturation_value: 'f32',\n    reorder_bands_ordering: 'mat4x4<f32>',\n    mask_keepMin: 'f32',\n    mask_keepMax: 'f32',\n    pansharpen_brovey_panWeight: 'f32'\n  }\n};\n\n/**\n * Map from original module uniform names (as returned by getUniforms) to\n * the prefixed names used in the shared UBO.\n */\nexport const UNIFORM_NAME_MAP: Record<string, Record<string, string>> = {\n  linear_rescale: {\n    scaler: 'linear_rescale_scaler',\n    offset: 'linear_rescale_offset'\n  },\n  gamma_contrast: {\n    gamma1: 'gamma_contrast_gamma1',\n    gamma2: 'gamma_contrast_gamma2',\n    gamma3: 'gamma_contrast_gamma3',\n    gamma4: 'gamma_contrast_gamma4'\n  },\n  sigmoidalContrast: {\n    contrast: 'sigmoidalContrast_contrast',\n    bias: 'sigmoidalContrast_bias'\n  },\n  colormap: {\n    hasCategoricalColors: 'colormap_hasCategoricalColors',\n    categoricalMinValue: 'colormap_categoricalMinValue',\n    categoricalMaxValue: 'colormap_categoricalMaxValue',\n    maxPixelValue: 'colormap_maxPixelValue'\n  },\n  bandFilter: {\n    min1: 'bandFilter_min1',\n    max1: 'bandFilter_max1',\n    min2: 'bandFilter_min2',\n    max2: 'bandFilter_max2',\n    min3: 'bandFilter_min3',\n    max3: 'bandFilter_max3',\n    min4: 'bandFilter_min4',\n    max4: 'bandFilter_max4'\n  },\n  saturation: {\n    value: 'saturation_value'\n  },\n  reorder_bands: {\n    ordering: 'reorder_bands_ordering'\n  },\n  mask_image_float: {\n    keepMin: 'mask_keepMin',\n    keepMax: 'mask_keepMax'\n  },\n  mask_image_uint: {\n    keepMin: 'mask_keepMin',\n    keepMax: 'mask_keepMax'\n  },\n  mask_image_int: {\n    keepMin: 'mask_keepMin',\n    keepMax: 'mask_keepMax'\n  },\n  pansharpen_brovey: {\n    panWeight: 'pansharpen_brovey_panWeight'\n  }\n};\n"],"mappings":"AAAA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAMA,+BAA+B,0iCA6CpC;;AAED;AACA;AACA;AACA;AACA,IAAMC,aAAa,2yDA0BlB;AAED,OAAO,IAAMC,oBAAoB,GAAGF,+BAA+B,GAAGC,aAAa;AAEnF,OAAO,IAAME,wBAAwB,GAAG;EACtCC,IAAI,EAAE,kBAAkB;EACxBC,EAAE,EAAEH,oBAAoB;EACxBI,EAAE,EAAE,EAAE;EACNC,YAAY,EAAE;IACZC,qBAAqB,EAAE,KAAK;IAC5BC,qBAAqB,EAAE,KAAK;IAC5BC,qBAAqB,EAAE,KAAK;IAC5BC,qBAAqB,EAAE,KAAK;IAC5BC,qBAAqB,EAAE,KAAK;IAC5BC,qBAAqB,EAAE,KAAK;IAC5BC,0BAA0B,EAAE,KAAK;IACjCC,sBAAsB,EAAE,KAAK;IAC7BC,6BAA6B,EAAE,KAAK;IACpCC,4BAA4B,EAAE,KAAK;IACnCC,4BAA4B,EAAE,KAAK;IACnCC,sBAAsB,EAAE,KAAK;IAC7BC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,eAAe,EAAE,KAAK;IACtBC,gBAAgB,EAAE,KAAK;IACvBC,sBAAsB,EAAE,aAAa;IACrCC,YAAY,EAAE,KAAK;IACnBC,YAAY,EAAE,KAAK;IACnBC,2BAA2B,EAAE;EAC/B;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA,OAAO,IAAMC,gBAAwD,GAAG;EACtEC,cAAc,EAAE;IACdC,MAAM,EAAE,uBAAuB;IAC/BC,MAAM,EAAE;EACV,CAAC;EACDC,cAAc,EAAE;IACdC,MAAM,EAAE,uBAAuB;IAC/BC,MAAM,EAAE,uBAAuB;IAC/BC,MAAM,EAAE,uBAAuB;IAC/BC,MAAM,EAAE;EACV,CAAC;EACDC,iBAAiB,EAAE;IACjBC,QAAQ,EAAE,4BAA4B;IACtCC,IAAI,EAAE;EACR,CAAC;EACDC,QAAQ,EAAE;IACRC,oBAAoB,EAAE,+BAA+B;IACrDC,mBAAmB,EAAE,8BAA8B;IACnDC,mBAAmB,EAAE,8BAA8B;IACnDC,aAAa,EAAE;EACjB,CAAC;EACDC,UAAU,EAAE;IACVC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE,iBAAiB;IACvBC,IAAI,EAAE;EACR,CAAC;EACDC,UAAU,EAAE;IACVC,KAAK,EAAE;EACT,CAAC;EACDC,aAAa,EAAE;IACbC,QAAQ,EAAE;EACZ,CAAC;EACDC,gBAAgB,EAAE;IAChBC,OAAO,EAAE,cAAc;IACvBC,OAAO,EAAE;EACX,CAAC;EACDC,eAAe,EAAE;IACfF,OAAO,EAAE,cAAc;IACvBC,OAAO,EAAE;EACX,CAAC;EACDE,cAAc,EAAE;IACdH,OAAO,EAAE,cAAc;IACvBC,OAAO,EAAE;EACX,CAAC;EACDG,iBAAiB,EAAE;IACjBC,SAAS,EAAE;EACb;AACF,CAAC","ignoreList":[]}

package/dist/esm/raster/types.js

@@ -0,0 +1,3 @@
+export {};
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jhc3Rlci90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgdHlwZSB7VGV4dHVyZX0gZnJvbSAnQGx1bWEuZ2wvY29yZSc7XG5pbXBvcnQgdHlwZSB7U2hhZGVyTW9kdWxlfSBmcm9tICcuL3dlYmdsJztcblxuLyoqIEFsbG93ZWQgaW5wdXQgZm9yIGltYWdlcyBwcm9wIOKAlCBlaXRoZXIgR1BVLXJlc2lkZW50IFRleHR1cmUgb2JqZWN0cyBvclxuICogbGVnYWN5IHJhc3RlciB0ZXh0dXJlIGRlc2NyaXB0b3JzIHdpdGggQ1BVIGRhdGEgdGhhdCB3aWxsIGJlIHVwbG9hZGVkLlxuICovXG5leHBvcnQgdHlwZSBJbWFnZUlucHV0ID0gUmVjb3JkPFxuICBzdHJpbmcsXG4gIFRleHR1cmUgfCBUZXh0dXJlW10gfCBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiB8IFJlY29yZDxzdHJpbmcsIHVua25vd24+W11cbj47XG5cbi8qKiBJbnRlcm5hbCBzdG9yYWdlIG9mIGltYWdlc1xuICogVGhlIFRleHR1cmUgb2JqZWN0IHJlZmVyZW5jZXMgZGF0YSBvbiB0aGUgR1BVXG4gKi9cbmV4cG9ydCB0eXBlIEltYWdlU3RhdGUgPSBSZWNvcmQ8c3RyaW5nLCBUZXh0dXJlIHwgVGV4dHVyZVtdPjtcblxuLyoqIFByb3BlcnRpZXMgYWRkZWQgYnkgUmFzdGVyTGF5ZXIuICovXG5leHBvcnQgdHlwZSBSYXN0ZXJMYXllckFkZGVkUHJvcHMgPSB7XG4gIG1vZHVsZXM6IFNoYWRlck1vZHVsZVtdO1xuICBpbWFnZXM6IEltYWdlSW5wdXQ7XG4gIG1vZHVsZVByb3BzOiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuICBvblJlZHJhd05lZWRlZD86ICgoKSA9PiB2b2lkKSB8IG51bGw7XG59O1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119