@kepler.gl/deckgl-layers 3.3.0-alpha.1 → 3.3.0-alpha.11

package/dist/esm/raster/images.js

@@ -0,0 +1,267 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// @ts-ignore GL resolution depends on moduleResolution setting
+import { GL } from '@luma.gl/constants';
+import isEqual from 'es-toolkit/compat/isEqual';
+import { FILTER_MODE, ADDRESS_MODE, TEXTURE_FORMAT } from '@kepler.gl/constants';
+
+/**
+ * Legacy texture creation descriptor used by raster shader modules.
+ * Contains CPU-side data + old GL-enum-based parameters that get
+ * translated to luma.gl 9's device.createTexture() props.
+ */
+
+/**
+ * Texture sampler parameters for luma.gl 9 textures
+ */
+var DEFAULT_SAMPLER_PARAMETERS = {
+  minFilter: FILTER_MODE.NEAREST,
+  magFilter: FILTER_MODE.NEAREST,
+  addressModeU: ADDRESS_MODE.CLAMP_TO_EDGE,
+  addressModeV: ADDRESS_MODE.CLAMP_TO_EDGE
+};
+
+/** luma.gl device interface for texture creation */
+
+/**
+ * Load image items to webgl context
+ */
+function loadImageItem(gl, device, imageItem) {
+  var result;
+  if (Array.isArray(imageItem)) {
+    var dirtyResult = imageItem.map(function (x) {
+      return loadTexture(gl, device, x);
+    });
+    result = [];
+    var _iterator = _createForOfIteratorHelper(dirtyResult),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var texture = _step.value;
+        if (texture) {
+          result.push(texture);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    if (!result.length) {
+      result = null;
+    }
+  } else {
+    result = loadTexture(gl, device, imageItem);
+  }
+  return result;
+}
+
+/**
+ * Load image items to webgl context
+ */
+
+// eslint-disable-next-line complexity
+export function loadImages(_ref) {
+  var gl = _ref.gl,
+    device = _ref.device,
+    images = _ref.images,
+    imagesData = _ref.imagesData,
+    oldImagesData = _ref.oldImagesData;
+  var imagesDirty = false;
+  var hasPendingUploads = false;
+  if (oldImagesData) {
+    for (var key in oldImagesData) {
+      if (imagesData && !(key in imagesData) && key in images) {
+        delete images[key];
+        imagesDirty = true;
+      }
+    }
+  }
+  var changedKeys = [];
+  for (var _key in imagesData) {
+    if (!oldImagesData || oldImagesData && !(_key in oldImagesData)) {
+      changedKeys.push(_key);
+      continue;
+    }
+    if (!isEqual(imagesData[_key], oldImagesData[_key])) {
+      changedKeys.push(_key);
+    }
+  }
+  for (var _i = 0, _changedKeys = changedKeys; _i < _changedKeys.length; _i++) {
+    var _key2 = _changedKeys[_i];
+    var imageData = imagesData[_key2];
+    if (!imageData) {
+      continue;
+    }
+    var loadedItem = loadImageItem(gl, device, imageData);
+    if (loadedItem) {
+      images[_key2] = loadedItem;
+      // Only mark dirty when the texture was actually uploaded.
+      imagesDirty = true;
+    } else {
+      // Upload failed (device not ready or createTexture threw). Signal that
+      // the caller should retry next frame — do NOT set imagesDirty so we
+      // don't propagate an images object with a missing key that causes
+      // draw() to bail permanently.
+      hasPendingUploads = true;
+    }
+  }
+  return {
+    images: imagesDirty ? images : null,
+    hasPendingUploads: hasPendingUploads
+  };
+}
+
+/**
+ * Map old GL texture parameter constants to luma.gl 9 sampler parameters
+ */
+function mapSamplerParameters(oldParams) {
+  var result = _objectSpread({}, DEFAULT_SAMPLER_PARAMETERS);
+  var magFilterMap = _defineProperty(_defineProperty({}, GL.NEAREST, FILTER_MODE.NEAREST), GL.LINEAR, FILTER_MODE.LINEAR);
+  var minFilterMap = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, GL.NEAREST, {
+    minFilter: FILTER_MODE.NEAREST
+  }), GL.LINEAR, {
+    minFilter: FILTER_MODE.LINEAR
+  }), GL.NEAREST_MIPMAP_NEAREST, {
+    minFilter: FILTER_MODE.NEAREST,
+    mipmapFilter: FILTER_MODE.NEAREST
+  }), GL.NEAREST_MIPMAP_LINEAR, {
+    minFilter: FILTER_MODE.NEAREST,
+    mipmapFilter: FILTER_MODE.LINEAR
+  }), GL.LINEAR_MIPMAP_NEAREST, {
+    minFilter: FILTER_MODE.LINEAR,
+    mipmapFilter: FILTER_MODE.NEAREST
+  }), GL.LINEAR_MIPMAP_LINEAR, {
+    minFilter: FILTER_MODE.LINEAR,
+    mipmapFilter: FILTER_MODE.LINEAR
+  });
+  var wrapMap = _defineProperty(_defineProperty(_defineProperty({}, GL.CLAMP_TO_EDGE, ADDRESS_MODE.CLAMP_TO_EDGE), GL.REPEAT, ADDRESS_MODE.REPEAT), GL.MIRRORED_REPEAT, ADDRESS_MODE.MIRROR_REPEAT);
+  if (oldParams) {
+    if (oldParams[GL.TEXTURE_MIN_FILTER] !== undefined) {
+      var mapped = minFilterMap[oldParams[GL.TEXTURE_MIN_FILTER]];
+      if (mapped) {
+        result.minFilter = mapped.minFilter;
+        if (mapped.mipmapFilter) {
+          result.mipmapFilter = mapped.mipmapFilter;
+        }
+      }
+    }
+    if (oldParams[GL.TEXTURE_MAG_FILTER] !== undefined) {
+      result.magFilter = magFilterMap[oldParams[GL.TEXTURE_MAG_FILTER]] || FILTER_MODE.NEAREST;
+    }
+    if (oldParams[GL.TEXTURE_WRAP_S] !== undefined) {
+      result.addressModeU = wrapMap[oldParams[GL.TEXTURE_WRAP_S]] || ADDRESS_MODE.CLAMP_TO_EDGE;
+    }
+    if (oldParams[GL.TEXTURE_WRAP_T] !== undefined) {
+      result.addressModeV = wrapMap[oldParams[GL.TEXTURE_WRAP_T]] || ADDRESS_MODE.CLAMP_TO_EDGE;
+    }
+  }
+  return result;
+}
+
+/**
+ * Map old GL format/type to luma.gl 9 texture format string
+ */
+function mapTextureFormat(glFormat, _glType) {
+  switch (glFormat) {
+    case GL.R8UI:
+      return TEXTURE_FORMAT.R8_UINT;
+    case GL.R16UI:
+      return TEXTURE_FORMAT.R16_UINT;
+    case GL.R32UI:
+      return TEXTURE_FORMAT.R32_UINT;
+    case GL.R8I:
+      return TEXTURE_FORMAT.R8_SINT;
+    case GL.R16I:
+      return TEXTURE_FORMAT.R16_SINT;
+    case GL.R32I:
+      return TEXTURE_FORMAT.R32_SINT;
+    case GL.R32F:
+      return TEXTURE_FORMAT.R32_FLOAT;
+    case GL.RGBA:
+      return TEXTURE_FORMAT.RGBA8_UNORM;
+    case GL.RGB:
+      return TEXTURE_FORMAT.RGBA8_UNORM;
+    default:
+      return TEXTURE_FORMAT.RGBA8_UNORM;
+  }
+}
+
+/**
+ * Expand 3-byte-per-pixel RGB data to 4-byte-per-pixel RGBA.
+ * Needed because WebGPU/luma.gl 9 has no 3-channel texture format.
+ */
+function expandRGBtoRGBA(data, width, height) {
+  var pixelCount = width * height;
+  var rgba = new Uint8Array(pixelCount * 4);
+  for (var i = 0; i < pixelCount; i++) {
+    rgba[i * 4] = data[i * 3];
+    rgba[i * 4 + 1] = data[i * 3 + 1];
+    rgba[i * 4 + 2] = data[i * 3 + 2];
+    rgba[i * 4 + 3] = 255;
+  }
+  return rgba;
+}
+
+/**
+ * Create texture object from image data using luma.gl 9 device API.
+ * Returns a proper luma.gl Texture object that works with the binding system.
+ */
+function loadTexture(gl, device, imageData) {
+  var _rasterTextureData$id, _rasterTextureData$id2, _gl$luma;
+  if (!imageData) {
+    return null;
+  }
+
+  // If already a luma.gl Texture instance, return as-is
+  var rasterTextureData = imageData;
+  if (rasterTextureData.handle || (_rasterTextureData$id = rasterTextureData.id) !== null && _rasterTextureData$id !== void 0 && (_rasterTextureData$id2 = _rasterTextureData$id.startsWith) !== null && _rasterTextureData$id2 !== void 0 && _rasterTextureData$id2.call(_rasterTextureData$id, 'luma') || rasterTextureData.device) {
+    return imageData;
+  }
+  var rawData = imageData;
+
+  // @ts-expect-error luma internal properties not in WebGL2RenderingContext type
+  var lumaDevice = device || ((_gl$luma = gl.luma) === null || _gl$luma === void 0 ? void 0 : _gl$luma.device) || gl.__luma_device;
+  if (!(lumaDevice !== null && lumaDevice !== void 0 && lumaDevice.createTexture)) {
+    console.warn('RasterLayer: No luma.gl device available for texture creation');
+    return null;
+  }
+  try {
+    var _rawData$data, _rawData$data2;
+    var samplerParams = mapSamplerParameters(rawData.parameters || {});
+    var textureFormat = rawData.format ? mapTextureFormat(rawData.format, rawData.type) : TEXTURE_FORMAT.RGBA8_UNORM;
+    var width = rawData.width || ((_rawData$data = rawData.data) === null || _rawData$data === void 0 ? void 0 : _rawData$data.width) || 1;
+    var height = rawData.height || ((_rawData$data2 = rawData.data) === null || _rawData$data2 === void 0 ? void 0 : _rawData$data2.height) || 1;
+    var textureProps = _objectSpread({
+      width: width,
+      height: height,
+      format: textureFormat,
+      sampler: samplerParams
+    }, rawData.mipmaps === false ? {
+      mipmaps: false
+    } : {});
+    if (rawData.data) {
+      if (rawData.data instanceof HTMLImageElement || rawData.data instanceof HTMLCanvasElement || rawData.data instanceof ImageBitmap || rawData.data instanceof ImageData) {
+        textureProps.data = rawData.data;
+      } else if (ArrayBuffer.isView(rawData.data)) {
+        if (rawData.format === GL.RGB && (rawData.data instanceof Uint8Array || rawData.data instanceof Uint8ClampedArray)) {
+          textureProps.data = expandRGBtoRGBA(rawData.data, width, height);
+        } else {
+          textureProps.data = rawData.data;
+        }
+      }
+    }
+    return lumaDevice.createTexture(textureProps);
+  } catch (e) {
+    console.warn('RasterLayer: Failed to create texture via device.createTexture:', e);
+    return null;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["GL","isEqual","FILTER_MODE","ADDRESS_MODE","TEXTURE_FORMAT","DEFAULT_SAMPLER_PARAMETERS","minFilter","NEAREST","magFilter","addressModeU","CLAMP_TO_EDGE","addressModeV","loadImageItem","gl","device","imageItem","result","Array","isArray","dirtyResult","map","x","loadTexture","_iterator","_createForOfIteratorHelper","_step","s","n","done","texture","value","push","err","e","f","length","loadImages","_ref","images","imagesData","oldImagesData","imagesDirty","hasPendingUploads","key","changedKeys","_i","_changedKeys","imageData","loadedItem","mapSamplerParameters","oldParams","_objectSpread","magFilterMap","_defineProperty","LINEAR","minFilterMap","NEAREST_MIPMAP_NEAREST","mipmapFilter","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_NEAREST","LINEAR_MIPMAP_LINEAR","wrapMap","REPEAT","MIRRORED_REPEAT","MIRROR_REPEAT","TEXTURE_MIN_FILTER","undefined","mapped","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","mapTextureFormat","glFormat","_glType","R8UI","R8_UINT","R16UI","R16_UINT","R32UI","R32_UINT","R8I","R8_SINT","R16I","R16_SINT","R32I","R32_SINT","R32F","R32_FLOAT","RGBA","RGBA8_UNORM","RGB","expandRGBtoRGBA","data","width","height","pixelCount","rgba","Uint8Array","i","_rasterTextureData$id","_rasterTextureData$id2","_gl$luma","rasterTextureData","handle","id","startsWith","call","rawData","lumaDevice","luma","__luma_device","createTexture","console","warn","_rawData$data","_rawData$data2","samplerParams","parameters","textureFormat","format","type","textureProps","sampler","mipmaps","HTMLImageElement","HTMLCanvasElement","ImageBitmap","ImageData","ArrayBuffer","isView","Uint8ClampedArray"],"sources":["../../../src/raster/images.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-ignore GL resolution depends on moduleResolution setting\nimport {GL} from '@luma.gl/constants';\nimport isEqual from 'es-toolkit/compat/isEqual';\n\nimport {FILTER_MODE, ADDRESS_MODE, TEXTURE_FORMAT} from '@kepler.gl/constants';\nimport type {Texture} from '@luma.gl/core';\nimport type {ImageInput, ImageState} from './types';\n\n/**\n * Legacy texture creation descriptor used by raster shader modules.\n * Contains CPU-side data + old GL-enum-based parameters that get\n * translated to luma.gl 9's device.createTexture() props.\n */\ntype TextureDataSource =\n  | HTMLImageElement\n  | HTMLCanvasElement\n  | ImageBitmap\n  | ImageData\n  | ArrayBufferView;\n\ntype RasterTextureData = {\n  handle?: unknown;\n  id?: string;\n  device?: unknown;\n  width?: number;\n  height?: number;\n  format?: number;\n  type?: number;\n  parameters?: Record<number, number>;\n  mipmaps?: boolean;\n  data?: TextureDataSource & {width?: number; height?: number};\n};\n\n/**\n * Texture sampler parameters for luma.gl 9 textures\n */\nconst DEFAULT_SAMPLER_PARAMETERS = {\n  minFilter: FILTER_MODE.NEAREST,\n  magFilter: FILTER_MODE.NEAREST,\n  addressModeU: ADDRESS_MODE.CLAMP_TO_EDGE,\n  addressModeV: ADDRESS_MODE.CLAMP_TO_EDGE\n};\n\n/** luma.gl device interface for texture creation */\ninterface LumaDevice {\n  createTexture(props: Record<string, unknown>): Texture;\n  gl?: WebGL2RenderingContext;\n}\n\ntype LoadImagesOptions = {\n  gl: WebGL2RenderingContext;\n  device?: LumaDevice;\n  images: ImageState;\n  imagesData: ImageInput;\n  oldImagesData: ImageInput;\n};\n\n/**\n * Load image items to webgl context\n */\nfunction loadImageItem(\n  gl: WebGL2RenderingContext,\n  device: LumaDevice | undefined,\n  imageItem: RasterTextureData | Texture | (RasterTextureData | Texture)[]\n): null | Texture | Texture[] {\n  let result: null | Texture | Texture[];\n  if (Array.isArray(imageItem)) {\n    const dirtyResult = imageItem.map(x => loadTexture(gl, device, x));\n    result = [];\n    for (const texture of dirtyResult) {\n      if (texture) {\n        result.push(texture);\n      }\n    }\n    if (!result.length) {\n      result = null;\n    }\n  } else {\n    result = loadTexture(gl, device, imageItem);\n  }\n  return result;\n}\n\n/**\n * Load image items to webgl context\n */\ntype LoadImagesResult = {\n  /** Updated images state, or null if nothing changed */\n  images: ImageState | null;\n  /** True when at least one texture upload failed and should be retried */\n  hasPendingUploads: boolean;\n};\n\n// eslint-disable-next-line complexity\nexport function loadImages({\n  gl,\n  device,\n  images,\n  imagesData,\n  oldImagesData\n}: LoadImagesOptions): LoadImagesResult {\n  let imagesDirty = false;\n  let hasPendingUploads = false;\n\n  if (oldImagesData) {\n    for (const key in oldImagesData) {\n      if (imagesData && !(key in imagesData) && key in images) {\n        delete images[key];\n        imagesDirty = true;\n      }\n    }\n  }\n\n  const changedKeys: string[] = [];\n  for (const key in imagesData) {\n    if (!oldImagesData || (oldImagesData && !(key in oldImagesData))) {\n      changedKeys.push(key);\n      continue;\n    }\n\n    if (!isEqual(imagesData[key], oldImagesData[key])) {\n      changedKeys.push(key);\n    }\n  }\n\n  for (const key of changedKeys) {\n    const imageData = imagesData[key];\n    if (!imageData) {\n      continue;\n    }\n\n    const loadedItem = loadImageItem(gl, device, imageData);\n    if (loadedItem) {\n      images[key] = loadedItem;\n      // Only mark dirty when the texture was actually uploaded.\n      imagesDirty = true;\n    } else {\n      // Upload failed (device not ready or createTexture threw). Signal that\n      // the caller should retry next frame — do NOT set imagesDirty so we\n      // don't propagate an images object with a missing key that causes\n      // draw() to bail permanently.\n      hasPendingUploads = true;\n    }\n  }\n\n  return {images: imagesDirty ? images : null, hasPendingUploads};\n}\n\n/**\n * Map old GL texture parameter constants to luma.gl 9 sampler parameters\n */\nfunction mapSamplerParameters(oldParams: Record<number, number>): Record<string, string> {\n  const result: Record<string, string> = {...DEFAULT_SAMPLER_PARAMETERS};\n\n  const magFilterMap = {\n    [GL.NEAREST]: FILTER_MODE.NEAREST,\n    [GL.LINEAR]: FILTER_MODE.LINEAR\n  };\n\n  const minFilterMap: Record<number, {minFilter: string; mipmapFilter?: string}> = {\n    [GL.NEAREST]: {minFilter: FILTER_MODE.NEAREST},\n    [GL.LINEAR]: {minFilter: FILTER_MODE.LINEAR},\n    [GL.NEAREST_MIPMAP_NEAREST]: {\n      minFilter: FILTER_MODE.NEAREST,\n      mipmapFilter: FILTER_MODE.NEAREST\n    },\n    [GL.NEAREST_MIPMAP_LINEAR]: {minFilter: FILTER_MODE.NEAREST, mipmapFilter: FILTER_MODE.LINEAR},\n    [GL.LINEAR_MIPMAP_NEAREST]: {minFilter: FILTER_MODE.LINEAR, mipmapFilter: FILTER_MODE.NEAREST},\n    [GL.LINEAR_MIPMAP_LINEAR]: {minFilter: FILTER_MODE.LINEAR, mipmapFilter: FILTER_MODE.LINEAR}\n  };\n\n  const wrapMap = {\n    [GL.CLAMP_TO_EDGE]: ADDRESS_MODE.CLAMP_TO_EDGE,\n    [GL.REPEAT]: ADDRESS_MODE.REPEAT,\n    [GL.MIRRORED_REPEAT]: ADDRESS_MODE.MIRROR_REPEAT\n  };\n\n  if (oldParams) {\n    if (oldParams[GL.TEXTURE_MIN_FILTER] !== undefined) {\n      const mapped = minFilterMap[oldParams[GL.TEXTURE_MIN_FILTER]];\n      if (mapped) {\n        result.minFilter = mapped.minFilter;\n        if (mapped.mipmapFilter) {\n          result.mipmapFilter = mapped.mipmapFilter;\n        }\n      }\n    }\n    if (oldParams[GL.TEXTURE_MAG_FILTER] !== undefined) {\n      result.magFilter = magFilterMap[oldParams[GL.TEXTURE_MAG_FILTER]] || FILTER_MODE.NEAREST;\n    }\n    if (oldParams[GL.TEXTURE_WRAP_S] !== undefined) {\n      result.addressModeU = wrapMap[oldParams[GL.TEXTURE_WRAP_S]] || ADDRESS_MODE.CLAMP_TO_EDGE;\n    }\n    if (oldParams[GL.TEXTURE_WRAP_T] !== undefined) {\n      result.addressModeV = wrapMap[oldParams[GL.TEXTURE_WRAP_T]] || ADDRESS_MODE.CLAMP_TO_EDGE;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Map old GL format/type to luma.gl 9 texture format string\n */\nfunction mapTextureFormat(glFormat: number, _glType?: number): string {\n  switch (glFormat) {\n    case GL.R8UI:\n      return TEXTURE_FORMAT.R8_UINT;\n    case GL.R16UI:\n      return TEXTURE_FORMAT.R16_UINT;\n    case GL.R32UI:\n      return TEXTURE_FORMAT.R32_UINT;\n    case GL.R8I:\n      return TEXTURE_FORMAT.R8_SINT;\n    case GL.R16I:\n      return TEXTURE_FORMAT.R16_SINT;\n    case GL.R32I:\n      return TEXTURE_FORMAT.R32_SINT;\n    case GL.R32F:\n      return TEXTURE_FORMAT.R32_FLOAT;\n    case GL.RGBA:\n      return TEXTURE_FORMAT.RGBA8_UNORM;\n    case GL.RGB:\n      return TEXTURE_FORMAT.RGBA8_UNORM;\n    default:\n      return TEXTURE_FORMAT.RGBA8_UNORM;\n  }\n}\n\n/**\n * Expand 3-byte-per-pixel RGB data to 4-byte-per-pixel RGBA.\n * Needed because WebGPU/luma.gl 9 has no 3-channel texture format.\n */\nfunction expandRGBtoRGBA(\n  data: Uint8Array | Uint8ClampedArray,\n  width: number,\n  height: number\n): Uint8Array {\n  const pixelCount = width * height;\n  const rgba = new Uint8Array(pixelCount * 4);\n  for (let i = 0; i < pixelCount; i++) {\n    rgba[i * 4] = data[i * 3];\n    rgba[i * 4 + 1] = data[i * 3 + 1];\n    rgba[i * 4 + 2] = data[i * 3 + 2];\n    rgba[i * 4 + 3] = 255;\n  }\n  return rgba;\n}\n\n/**\n * Create texture object from image data using luma.gl 9 device API.\n * Returns a proper luma.gl Texture object that works with the binding system.\n */\nfunction loadTexture(\n  gl: WebGL2RenderingContext,\n  device: LumaDevice | undefined,\n  imageData: Texture | RasterTextureData\n): Texture | null {\n  if (!imageData) {\n    return null;\n  }\n\n  // If already a luma.gl Texture instance, return as-is\n  const rasterTextureData = imageData as RasterTextureData;\n  if (\n    rasterTextureData.handle ||\n    rasterTextureData.id?.startsWith?.('luma') ||\n    rasterTextureData.device\n  ) {\n    return imageData as Texture;\n  }\n\n  const rawData = imageData as RasterTextureData;\n\n  // @ts-expect-error luma internal properties not in WebGL2RenderingContext type\n  const lumaDevice = device || gl.luma?.device || gl.__luma_device;\n\n  if (!lumaDevice?.createTexture) {\n    console.warn('RasterLayer: No luma.gl device available for texture creation');\n    return null;\n  }\n\n  try {\n    const samplerParams = mapSamplerParameters(rawData.parameters || {});\n    const textureFormat = rawData.format\n      ? mapTextureFormat(rawData.format, rawData.type)\n      : TEXTURE_FORMAT.RGBA8_UNORM;\n\n    const width = rawData.width || rawData.data?.width || 1;\n    const height = rawData.height || rawData.data?.height || 1;\n\n    const textureProps: Record<string, unknown> = {\n      width,\n      height,\n      format: textureFormat,\n      sampler: samplerParams,\n      ...(rawData.mipmaps === false ? {mipmaps: false} : {})\n    };\n\n    if (rawData.data) {\n      if (\n        rawData.data instanceof HTMLImageElement ||\n        rawData.data instanceof HTMLCanvasElement ||\n        rawData.data instanceof ImageBitmap ||\n        rawData.data instanceof ImageData\n      ) {\n        textureProps.data = rawData.data;\n      } else if (ArrayBuffer.isView(rawData.data)) {\n        if (\n          rawData.format === GL.RGB &&\n          (rawData.data instanceof Uint8Array || rawData.data instanceof Uint8ClampedArray)\n        ) {\n          textureProps.data = expandRGBtoRGBA(rawData.data, width, height);\n        } else {\n          textureProps.data = rawData.data;\n        }\n      }\n    }\n\n    return lumaDevice.createTexture(textureProps);\n  } catch (e) {\n    console.warn('RasterLayer: Failed to create texture via device.createTexture:', e);\n    return null;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/raster/pipeline-validation-patch.js

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Patch luma.gl 9's pipeline validation to tolerate mixed-sampler-type
+ * validation errors in _getLinkStatus().
+ *
+ * WebGL2's validateProgram checks that sampler uniforms of different types
+ * (sampler2D, usampler2D, isampler2D) are not assigned to the same texture
+ * unit. Programs that mix sampler types (e.g. raster band data as usampler2D +
+ * shadow maps as sampler2D) may fail validation even though they linked
+ * successfully and work correctly once texture units are assigned at draw time.
+ *
+ * In luma.gl ≥9.3 the _getLinkStatus method moved from WEBGLRenderPipeline to
+ * WEBGLSharedRenderPipeline and now calls _initializeSamplerUniforms() before
+ * validateProgram, which fixes most false positives. However, some WebGL
+ * drivers still report errors even with unique units, so we keep suppressing
+ * the known false-positive about mixed sampler types. We patch _getLinkStatus
+ * on whichever pipeline class owns it.
+ */
+
+// @ts-ignore resolution depends on moduleResolution setting
+import { WEBGLRenderPipeline, WebGLDevice } from '@luma.gl/webgl';
+var MIXED_SAMPLER_RE = /different type[s]? use the same sampler location/i;
+var _patched = false;
+function createPatchedLinkStatus(_original) {
+  return function _patchedGetLinkStatus() {
+    var gl = this.device.gl;
+    var linked = gl.getProgramParameter(this.handle, 0x8b82 /* LINK_STATUS */);
+    if (!linked) {
+      this.linkStatus = 'error';
+      return 'link-error';
+    }
+
+    // luma.gl ≥9.3 assigns unique texture units to samplers before
+    // validation via _initializeSamplerUniforms. Call it here so that
+    // the sampler-to-unit mapping is populated through our patched path.
+    if (typeof this._initializeSamplerUniforms === 'function') {
+      this._initializeSamplerUniforms();
+    }
+    gl.validateProgram(this.handle);
+    var validated = gl.getProgramParameter(this.handle, 0x8b83 /* VALIDATE_STATUS */);
+    if (!validated) {
+      var infoLog = gl.getProgramInfoLog(this.handle) || '';
+      if (!MIXED_SAMPLER_RE.test(infoLog)) {
+        this.linkStatus = 'error';
+        return 'validation-error';
+      }
+    }
+    this.linkStatus = 'success';
+    return 'success';
+  };
+}
+export function patchPipelineValidation() {
+  if (_patched) return;
+  _patched = true;
+
+  // Strategy 1: luma.gl <9.3 — _getLinkStatus on WEBGLRenderPipeline
+  if (WEBGLRenderPipeline !== null && WEBGLRenderPipeline !== void 0 && WEBGLRenderPipeline.prototype && typeof WEBGLRenderPipeline.prototype._getLinkStatus === 'function') {
+    var original = WEBGLRenderPipeline.prototype._getLinkStatus;
+    WEBGLRenderPipeline.prototype._getLinkStatus = createPatchedLinkStatus(original);
+    return;
+  }
+
+  // Strategy 2: luma.gl ≥9.3 — _getLinkStatus moved to WEBGLSharedRenderPipeline.
+  // That class is not publicly exported, so we hook the factory on WebGLDevice
+  // that creates shared pipelines. The first invocation discovers the class,
+  // patches its prototype, then re-validates the instance.
+  var deviceProto = WebGLDevice === null || WebGLDevice === void 0 ? void 0 : WebGLDevice.prototype;
+  var origFactory = deviceProto === null || deviceProto === void 0 ? void 0 : deviceProto._createSharedRenderPipelineWebGL;
+  if (typeof origFactory !== 'function') return;
+  deviceProto._createSharedRenderPipelineWebGL = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var instance = origFactory.apply(this, args);
+    var SharedCtor = Object.getPrototypeOf(instance).constructor;
+    if (SharedCtor && SharedCtor !== WEBGLRenderPipeline && typeof SharedCtor.prototype._getLinkStatus === 'function') {
+      var _original2 = SharedCtor.prototype._getLinkStatus;
+      SharedCtor.prototype._getLinkStatus = createPatchedLinkStatus(_original2);
+
+      // Re-validate this first instance since its _getLinkStatus already ran
+      // with the unpatched version during construction.
+      if (instance.linkStatus !== 'success') {
+        instance._getLinkStatus();
+      }
+    }
+
+    // Restore original factory — future instances will use the patched prototype
+    deviceProto._createSharedRenderPipelineWebGL = origFactory;
+    return instance;
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["WEBGLRenderPipeline","WebGLDevice","MIXED_SAMPLER_RE","_patched","createPatchedLinkStatus","_original","_patchedGetLinkStatus","gl","device","linked","getProgramParameter","handle","linkStatus","_initializeSamplerUniforms","validateProgram","validated","infoLog","getProgramInfoLog","test","patchPipelineValidation","prototype","_getLinkStatus","original","deviceProto","origFactory","_createSharedRenderPipelineWebGL","_len","arguments","length","args","Array","_key","instance","apply","SharedCtor","Object","getPrototypeOf","constructor"],"sources":["../../../src/raster/pipeline-validation-patch.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Patch luma.gl 9's pipeline validation to tolerate mixed-sampler-type\n * validation errors in _getLinkStatus().\n *\n * WebGL2's validateProgram checks that sampler uniforms of different types\n * (sampler2D, usampler2D, isampler2D) are not assigned to the same texture\n * unit. Programs that mix sampler types (e.g. raster band data as usampler2D +\n * shadow maps as sampler2D) may fail validation even though they linked\n * successfully and work correctly once texture units are assigned at draw time.\n *\n * In luma.gl ≥9.3 the _getLinkStatus method moved from WEBGLRenderPipeline to\n * WEBGLSharedRenderPipeline and now calls _initializeSamplerUniforms() before\n * validateProgram, which fixes most false positives. However, some WebGL\n * drivers still report errors even with unique units, so we keep suppressing\n * the known false-positive about mixed sampler types. We patch _getLinkStatus\n * on whichever pipeline class owns it.\n */\n\n// @ts-ignore resolution depends on moduleResolution setting\nimport {WEBGLRenderPipeline, WebGLDevice} from '@luma.gl/webgl';\n\nconst MIXED_SAMPLER_RE = /different type[s]? use the same sampler location/i;\n\nlet _patched = false;\n\nfunction createPatchedLinkStatus(_original: (...args: unknown[]) => unknown) {\n  return function _patchedGetLinkStatus(this: any) {\n    const {gl} = this.device;\n    const linked = gl.getProgramParameter(this.handle, 0x8b82 /* LINK_STATUS */);\n    if (!linked) {\n      this.linkStatus = 'error';\n      return 'link-error';\n    }\n\n    // luma.gl ≥9.3 assigns unique texture units to samplers before\n    // validation via _initializeSamplerUniforms. Call it here so that\n    // the sampler-to-unit mapping is populated through our patched path.\n    if (typeof this._initializeSamplerUniforms === 'function') {\n      this._initializeSamplerUniforms();\n    }\n\n    gl.validateProgram(this.handle);\n    const validated = gl.getProgramParameter(this.handle, 0x8b83 /* VALIDATE_STATUS */);\n    if (!validated) {\n      const infoLog = gl.getProgramInfoLog(this.handle) || '';\n      if (!MIXED_SAMPLER_RE.test(infoLog)) {\n        this.linkStatus = 'error';\n        return 'validation-error';\n      }\n    }\n\n    this.linkStatus = 'success';\n    return 'success';\n  };\n}\n\nexport function patchPipelineValidation(): void {\n  if (_patched) return;\n  _patched = true;\n\n  // Strategy 1: luma.gl <9.3 — _getLinkStatus on WEBGLRenderPipeline\n  if (\n    WEBGLRenderPipeline?.prototype &&\n    typeof (WEBGLRenderPipeline.prototype as any)._getLinkStatus === 'function'\n  ) {\n    const original = (WEBGLRenderPipeline.prototype as any)._getLinkStatus;\n    (WEBGLRenderPipeline.prototype as any)._getLinkStatus = createPatchedLinkStatus(original);\n    return;\n  }\n\n  // Strategy 2: luma.gl ≥9.3 — _getLinkStatus moved to WEBGLSharedRenderPipeline.\n  // That class is not publicly exported, so we hook the factory on WebGLDevice\n  // that creates shared pipelines. The first invocation discovers the class,\n  // patches its prototype, then re-validates the instance.\n  const deviceProto = WebGLDevice?.prototype as any;\n  const origFactory = deviceProto?._createSharedRenderPipelineWebGL;\n  if (typeof origFactory !== 'function') return;\n\n  deviceProto._createSharedRenderPipelineWebGL = function (this: any, ...args: any[]) {\n    const instance = origFactory.apply(this, args);\n    const SharedCtor = Object.getPrototypeOf(instance).constructor;\n\n    if (\n      SharedCtor &&\n      SharedCtor !== WEBGLRenderPipeline &&\n      typeof SharedCtor.prototype._getLinkStatus === 'function'\n    ) {\n      const original = SharedCtor.prototype._getLinkStatus;\n      SharedCtor.prototype._getLinkStatus = createPatchedLinkStatus(original);\n\n      // Re-validate this first instance since its _getLinkStatus already ran\n      // with the unpatched version during construction.\n      if (instance.linkStatus !== 'success') {\n        instance._getLinkStatus();\n      }\n    }\n\n    // Restore original factory — future instances will use the patched prototype\n    deviceProto._createSharedRenderPipelineWebGL = origFactory;\n    return instance;\n  };\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,153 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { ShaderAssembler } from '@luma.gl/shadertools';
+import { UNIFORM_NAME_MAP } from '../raster-processing-uniforms';
+
+/**
+ * UBO-based shader module for raster layer uniforms.
+ * Replaces the old standalone `uniform float desaturate` etc.
+ */
+var rasterUniformBlock = "uniform rasterUniforms {\n  vec4 bounds;\n  float coordinateConversion;\n  float desaturate;\n  float opacity;\n  vec3 tintColor;\n  vec4 transparentColor;\n} raster;\n";
+export var rasterUniforms = {
+  name: 'raster',
+  vs: rasterUniformBlock,
+  fs: rasterUniformBlock,
+  uniformTypes: {
+    bounds: 'vec4<f32>',
+    coordinateConversion: 'f32',
+    desaturate: 'f32',
+    opacity: 'f32',
+    tintColor: 'vec3<f32>',
+    transparentColor: 'vec4<f32>'
+  }
+};
+
+/**
+ * Register custom DECKGL_CREATE_COLOR and DECKGL_MUTATE_COLOR shader hooks
+ * with the default ShaderAssembler. These hooks are used by the raster layer's
+ * custom shader modules (rgbaImage, combineBands, colormap, etc.).
+ *
+ * In luma.gl 8.x these were registered via ProgramManager; in luma.gl 9.x
+ * we register them with the ShaderAssembler singleton.
+ *
+ * NOTE: We must check the assembler's hook list every time rather than using
+ * a module-level boolean guard, because deck.gl's getShaderAssembler() clears
+ * _hookFunctions when a new Deck instance is created (e.g. during image export).
+ */
+export function ensureRasterHooksRegistered() {
+  var assembler = ShaderAssembler.getDefaultShaderAssembler();
+  // @ts-expect-error _hookFunctions is private in ShaderAssembler
+  var existingHooks = assembler._hookFunctions || [];
+  var hookNames = existingHooks.map(function (h) {
+    return typeof h === 'string' ? h : h.hook;
+  });
+  if (!hookNames.some(function (h) {
+    return h === null || h === void 0 ? void 0 : h.includes('DECKGL_CREATE_COLOR');
+  })) {
+    assembler.addShaderHook('fs:DECKGL_CREATE_COLOR(inout vec4 image, vec2 coord)');
+  }
+  if (!hookNames.some(function (h) {
+    return h === null || h === void 0 ? void 0 : h.includes('DECKGL_MUTATE_COLOR');
+  })) {
+    assembler.addShaderHook('fs:DECKGL_MUTATE_COLOR(inout vec4 image, vec2 coord)');
+  }
+}
+
+/**
+ * Convert kepler.gl's custom raster shader modules into luma.gl 9 compatible
+ * format. Ensures fs2 (WebGL2) shaders are used and texture2D -> texture.
+ */
+
+export function prepareLumaModules(modules) {
+  return modules.map(function (mod) {
+    var fs = mod.fs2 || mod.fs || '';
+    // Replace texture2D with texture for GLSL 300 es
+    fs = fs.replace(/texture2D\(/g, 'texture(');
+    var nameMap = UNIFORM_NAME_MAP[mod.name];
+    var consolidate = Boolean(nameMap && mod.uniformTypes);
+    if (mod.uniformTypes && !nameMap) {
+      console.warn("[raster] Module \"".concat(mod.name, "\" has uniformTypes but no UNIFORM_NAME_MAP entry. ") + 'Its UBO will not be consolidated and may push the fragment uniform block count over the WebGL2 limit.');
+    }
+    if (consolidate) {
+      // Strip only this module's uniform block declaration so it doesn't
+      // create its own UBO.
+      var blockPattern = new RegExp("uniform\\s+".concat(mod.name, "Uniforms\\s*\\{[^}]*\\}\\s*").concat(mod.name, "\\s*;"), 'gs');
+      fs = fs.replace(blockPattern, '');
+
+      // Rewrite moduleName.fieldName references to the shared UBO aliases
+      for (var _i = 0, _Object$entries = Object.entries(nameMap); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          origField = _Object$entries$_i[0],
+          prefixedField = _Object$entries$_i[1];
+        var pattern = new RegExp("\\b".concat(mod.name, "\\.").concat(origField, "\\b"), 'g');
+        fs = fs.replace(pattern, "".concat(prefixedField, "_ALIAS"));
+      }
+    }
+    var result = {
+      name: mod.name,
+      fs: fs,
+      dependencies: mod.dependencies,
+      deprecations: mod.deprecations
+    };
+    if (mod.vs) {
+      result.vs = mod.vs.replace(/texture2D\(/g, 'texture(');
+    }
+    if (mod.defines) {
+      result.defines = mod.defines;
+    }
+    if (mod.getUniforms) {
+      result.getUniforms = mod.getUniforms;
+    }
+    if (mod.uniforms) {
+      result.uniforms = mod.uniforms;
+    }
+
+    // Only keep uniformTypes for modules NOT consolidated into the shared UBO
+    if (mod.uniformTypes && !consolidate) {
+      result.uniformTypes = mod.uniformTypes;
+    }
+
+    // Convert inject code, replacing texture2D -> texture and UBO references
+    if (mod.inject) {
+      result.inject = {};
+      for (var _i2 = 0, _Object$entries2 = Object.entries(mod.inject); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          hook = _Object$entries2$_i[0],
+          code = _Object$entries2$_i[1];
+        var codeStr = typeof code === 'string' ? code : code.injection || '';
+        codeStr = codeStr.replace(/texture2D\(/g, 'texture(');
+        if (consolidate && nameMap) {
+          for (var _i3 = 0, _Object$entries3 = Object.entries(nameMap); _i3 < _Object$entries3.length; _i3++) {
+            var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+              _origField = _Object$entries3$_i[0],
+              _prefixedField = _Object$entries3$_i[1];
+            var _pattern = new RegExp("\\b".concat(mod.name, "\\.").concat(_origField, "\\b"), 'g');
+            codeStr = codeStr.replace(_pattern, "".concat(_prefixedField, "_ALIAS"));
+          }
+        }
+        result.inject[hook] = codeStr;
+      }
+    }
+    return result;
+  });
+}
+
+/**
+ * Build the vertex shader for the raster layer.
+ * References raster.coordinateConversion from the UBO.
+ */
+export function buildRasterVertexShader() {
+  return "#version 300 es\n#define SHADER_NAME raster-layer-vertex-shader\n\nprecision mediump float;\n\nin vec2 texCoords;\nin vec3 positions;\nin vec3 positions64Low;\n\nout vec2 vTexCoord;\nout vec2 vTexPos;\n\nconst vec3 pickingColor = vec3(1.0, 0.0, 0.0);\n\nvoid main(void) {\n  geometry.worldPosition = positions;\n  geometry.uv = texCoords;\n  geometry.pickingColor = pickingColor;\n\n  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  vTexCoord = texCoords;\n\n  if (raster.coordinateConversion < -0.5) {\n    vTexPos = geometry.position.xy + project.commonOrigin.xy;\n  } else if (raster.coordinateConversion > 0.5) {\n    vTexPos = geometry.worldPosition.xy;\n  }\n\n  vec4 color = vec4(0.0);\n  DECKGL_FILTER_COLOR(color, geometry);\n}\n";
+}
+
+/**
+ * Build the fragment shader for the raster layer.
+ * Uses DECKGL_CREATE_COLOR and DECKGL_MUTATE_COLOR hooks which are now
+ * registered with the ShaderAssembler and populated by module injections.
+ */
+export function buildRasterFragmentShader() {
+  return "#version 300 es\n#define SHADER_NAME raster-layer-fragment-shader\n\nprecision mediump float;\nprecision mediump int;\nprecision mediump usampler2D;\n\nin vec2 vTexCoord;\nin vec2 vTexPos;\n\nout vec4 fragColor;\n\n/* projection utils */\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / PI / 2.0;\n\nvec2 lnglat_to_mercator(vec2 lnglat) {\n  float x = lnglat.x;\n  float y = clamp(lnglat.y, -89.9, 89.9);\n  return vec2(\n    radians(x) + PI,\n    PI + log(tan(PI * 0.25 + radians(y) * 0.5))\n  ) * WORLD_SCALE;\n}\n\nvec2 mercator_to_lnglat(vec2 xy) {\n  xy /= WORLD_SCALE;\n  return degrees(vec2(\n    xy.x - PI,\n    atan(exp(xy.y - PI)) * 2.0 - PI * 0.5\n  ));\n}\n\nvec3 color_desaturate(vec3 color) {\n  float luminance = (color.r + color.g + color.b) * 0.333333333;\n  return mix(color, vec3(luminance), raster.desaturate);\n}\n\nvec3 color_tint(vec3 color) {\n  return color * raster.tintColor;\n}\n\nvec4 apply_opacity(vec3 color, float alpha) {\n  if (raster.transparentColor.a == 0.0) {\n    return vec4(color, alpha);\n  }\n  float blendedAlpha = alpha + raster.transparentColor.a * (1.0 - alpha);\n  float highLightRatio = alpha / blendedAlpha;\n  vec3 blendedRGB = mix(raster.transparentColor.rgb, color, highLightRatio);\n  return vec4(blendedRGB, blendedAlpha);\n}\n\nvec2 getUV(vec2 pos) {\n  return vec2(\n    (pos.x - raster.bounds[0]) / (raster.bounds[2] - raster.bounds[0]),\n    (pos.y - raster.bounds[3]) / (raster.bounds[1] - raster.bounds[3])\n  );\n}\n\nvoid main(void) {\n  vec2 uv = vTexCoord;\n  if (raster.coordinateConversion < -0.5) {\n    vec2 lnglat = mercator_to_lnglat(vTexPos);\n    uv = getUV(lnglat);\n  } else if (raster.coordinateConversion > 0.5) {\n    vec2 commonPos = lnglat_to_mercator(vTexPos);\n    uv = getUV(commonPos);\n  }\n\n  vec4 image = vec4(0.0);\n  DECKGL_CREATE_COLOR(image, uv);\n\n  DECKGL_MUTATE_COLOR(image, uv);\n\n  fragColor = apply_opacity(color_tint(color_desaturate(image.rgb)), raster.opacity);\n\n  geometry.uv = uv;\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ShaderAssembler","UNIFORM_NAME_MAP","rasterUniformBlock","rasterUniforms","name","vs","fs","uniformTypes","bounds","coordinateConversion","desaturate","opacity","tintColor","transparentColor","ensureRasterHooksRegistered","assembler","getDefaultShaderAssembler","existingHooks","_hookFunctions","hookNames","map","h","hook","some","includes","addShaderHook","prepareLumaModules","modules","mod","fs2","replace","nameMap","consolidate","Boolean","console","warn","concat","blockPattern","RegExp","_i","_Object$entries","Object","entries","length","_Object$entries$_i","_slicedToArray","origField","prefixedField","pattern","result","dependencies","deprecations","defines","getUniforms","uniforms","inject","_i2","_Object$entries2","_Object$entries2$_i","code","codeStr","injection","_i3","_Object$entries3","_Object$entries3$_i","buildRasterVertexShader","buildRasterFragmentShader"],"sources":["../../../../src/raster/raster-layer/raster-layer-shaders.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {ShaderAssembler} from '@luma.gl/shadertools';\nimport type {ShaderModule as LumaShaderModule} from '../webgl/types';\nimport {UNIFORM_NAME_MAP} from '../raster-processing-uniforms';\n\n/**\n * UBO-based shader module for raster layer uniforms.\n * Replaces the old standalone `uniform float desaturate` etc.\n */\nconst rasterUniformBlock = `\\\nuniform rasterUniforms {\n  vec4 bounds;\n  float coordinateConversion;\n  float desaturate;\n  float opacity;\n  vec3 tintColor;\n  vec4 transparentColor;\n} raster;\n`;\n\nexport const rasterUniforms = {\n  name: 'raster',\n  vs: rasterUniformBlock,\n  fs: rasterUniformBlock,\n  uniformTypes: {\n    bounds: 'vec4<f32>',\n    coordinateConversion: 'f32',\n    desaturate: 'f32',\n    opacity: 'f32',\n    tintColor: 'vec3<f32>',\n    transparentColor: 'vec4<f32>'\n  }\n};\n\n/**\n * Register custom DECKGL_CREATE_COLOR and DECKGL_MUTATE_COLOR shader hooks\n * with the default ShaderAssembler. These hooks are used by the raster layer's\n * custom shader modules (rgbaImage, combineBands, colormap, etc.).\n *\n * In luma.gl 8.x these were registered via ProgramManager; in luma.gl 9.x\n * we register them with the ShaderAssembler singleton.\n *\n * NOTE: We must check the assembler's hook list every time rather than using\n * a module-level boolean guard, because deck.gl's getShaderAssembler() clears\n * _hookFunctions when a new Deck instance is created (e.g. during image export).\n */\nexport function ensureRasterHooksRegistered(): void {\n  const assembler = ShaderAssembler.getDefaultShaderAssembler();\n  // @ts-expect-error _hookFunctions is private in ShaderAssembler\n  const existingHooks = assembler._hookFunctions || [];\n  const hookNames = existingHooks.map(h => (typeof h === 'string' ? h : h.hook));\n\n  if (!hookNames.some(h => h?.includes('DECKGL_CREATE_COLOR'))) {\n    assembler.addShaderHook('fs:DECKGL_CREATE_COLOR(inout vec4 image, vec2 coord)');\n  }\n  if (!hookNames.some(h => h?.includes('DECKGL_MUTATE_COLOR'))) {\n    assembler.addShaderHook('fs:DECKGL_MUTATE_COLOR(inout vec4 image, vec2 coord)');\n  }\n}\n\n/**\n * Convert kepler.gl's custom raster shader modules into luma.gl 9 compatible\n * format. Ensures fs2 (WebGL2) shaders are used and texture2D -> texture.\n */\ninterface LumaModuleOutput {\n  name: string;\n  fs: string;\n  vs?: string;\n  defines?: Record<string, string>;\n  getUniforms?: (opts: object) => Record<string, unknown> | null;\n  uniforms?: Record<string, unknown>;\n  uniformTypes?: Record<string, string>;\n  inject?: Record<string, string>;\n  dependencies?: unknown[];\n  deprecations?: unknown[];\n}\n\nexport function prepareLumaModules(modules: LumaShaderModule[]): LumaModuleOutput[] {\n  return modules.map(mod => {\n    let fs = mod.fs2 || mod.fs || '';\n    // Replace texture2D with texture for GLSL 300 es\n    fs = fs.replace(/texture2D\\(/g, 'texture(');\n\n    const nameMap = UNIFORM_NAME_MAP[mod.name];\n    const consolidate = Boolean(nameMap && mod.uniformTypes);\n\n    if (mod.uniformTypes && !nameMap) {\n      console.warn(\n        `[raster] Module \"${mod.name}\" has uniformTypes but no UNIFORM_NAME_MAP entry. ` +\n          'Its UBO will not be consolidated and may push the fragment uniform block count over the WebGL2 limit.'\n      );\n    }\n\n    if (consolidate) {\n      // Strip only this module's uniform block declaration so it doesn't\n      // create its own UBO.\n      const blockPattern = new RegExp(\n        `uniform\\\\s+${mod.name}Uniforms\\\\s*\\\\{[^}]*\\\\}\\\\s*${mod.name}\\\\s*;`,\n        'gs'\n      );\n      fs = fs.replace(blockPattern, '');\n\n      // Rewrite moduleName.fieldName references to the shared UBO aliases\n      for (const [origField, prefixedField] of Object.entries(nameMap)) {\n        const pattern = new RegExp(`\\\\b${mod.name}\\\\.${origField}\\\\b`, 'g');\n        fs = fs.replace(pattern, `${prefixedField}_ALIAS`);\n      }\n    }\n\n    const result: LumaModuleOutput = {\n      name: mod.name,\n      fs,\n      dependencies: mod.dependencies,\n      deprecations: mod.deprecations\n    };\n\n    if (mod.vs) {\n      result.vs = mod.vs.replace(/texture2D\\(/g, 'texture(');\n    }\n\n    if (mod.defines) {\n      result.defines = mod.defines;\n    }\n\n    if (mod.getUniforms) {\n      result.getUniforms = mod.getUniforms;\n    }\n\n    if (mod.uniforms) {\n      result.uniforms = mod.uniforms;\n    }\n\n    // Only keep uniformTypes for modules NOT consolidated into the shared UBO\n    if (mod.uniformTypes && !consolidate) {\n      result.uniformTypes = mod.uniformTypes;\n    }\n\n    // Convert inject code, replacing texture2D -> texture and UBO references\n    if (mod.inject) {\n      result.inject = {};\n      for (const [hook, code] of Object.entries(mod.inject)) {\n        let codeStr =\n          typeof code === 'string' ? code : (code as {injection?: string}).injection || '';\n        codeStr = codeStr.replace(/texture2D\\(/g, 'texture(');\n\n        if (consolidate && nameMap) {\n          for (const [origField, prefixedField] of Object.entries(nameMap)) {\n            const pattern = new RegExp(`\\\\b${mod.name}\\\\.${origField}\\\\b`, 'g');\n            codeStr = codeStr.replace(pattern, `${prefixedField}_ALIAS`);\n          }\n        }\n\n        result.inject[hook] = codeStr;\n      }\n    }\n\n    return result;\n  });\n}\n\n/**\n * Build the vertex shader for the raster layer.\n * References raster.coordinateConversion from the UBO.\n */\nexport function buildRasterVertexShader(): string {\n  return `\\\n#version 300 es\n#define SHADER_NAME raster-layer-vertex-shader\n\nprecision mediump float;\n\nin vec2 texCoords;\nin vec3 positions;\nin vec3 positions64Low;\n\nout vec2 vTexCoord;\nout vec2 vTexPos;\n\nconst vec3 pickingColor = vec3(1.0, 0.0, 0.0);\n\nvoid main(void) {\n  geometry.worldPosition = positions;\n  geometry.uv = texCoords;\n  geometry.pickingColor = pickingColor;\n\n  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  vTexCoord = texCoords;\n\n  if (raster.coordinateConversion < -0.5) {\n    vTexPos = geometry.position.xy + project.commonOrigin.xy;\n  } else if (raster.coordinateConversion > 0.5) {\n    vTexPos = geometry.worldPosition.xy;\n  }\n\n  vec4 color = vec4(0.0);\n  DECKGL_FILTER_COLOR(color, geometry);\n}\n`;\n}\n\n/**\n * Build the fragment shader for the raster layer.\n * Uses DECKGL_CREATE_COLOR and DECKGL_MUTATE_COLOR hooks which are now\n * registered with the ShaderAssembler and populated by module injections.\n */\nexport function buildRasterFragmentShader(): string {\n  return `\\\n#version 300 es\n#define SHADER_NAME raster-layer-fragment-shader\n\nprecision mediump float;\nprecision mediump int;\nprecision mediump usampler2D;\n\nin vec2 vTexCoord;\nin vec2 vTexPos;\n\nout vec4 fragColor;\n\n/* projection utils */\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / PI / 2.0;\n\nvec2 lnglat_to_mercator(vec2 lnglat) {\n  float x = lnglat.x;\n  float y = clamp(lnglat.y, -89.9, 89.9);\n  return vec2(\n    radians(x) + PI,\n    PI + log(tan(PI * 0.25 + radians(y) * 0.5))\n  ) * WORLD_SCALE;\n}\n\nvec2 mercator_to_lnglat(vec2 xy) {\n  xy /= WORLD_SCALE;\n  return degrees(vec2(\n    xy.x - PI,\n    atan(exp(xy.y - PI)) * 2.0 - PI * 0.5\n  ));\n}\n\nvec3 color_desaturate(vec3 color) {\n  float luminance = (color.r + color.g + color.b) * 0.333333333;\n  return mix(color, vec3(luminance), raster.desaturate);\n}\n\nvec3 color_tint(vec3 color) {\n  return color * raster.tintColor;\n}\n\nvec4 apply_opacity(vec3 color, float alpha) {\n  if (raster.transparentColor.a == 0.0) {\n    return vec4(color, alpha);\n  }\n  float blendedAlpha = alpha + raster.transparentColor.a * (1.0 - alpha);\n  float highLightRatio = alpha / blendedAlpha;\n  vec3 blendedRGB = mix(raster.transparentColor.rgb, color, highLightRatio);\n  return vec4(blendedRGB, blendedAlpha);\n}\n\nvec2 getUV(vec2 pos) {\n  return vec2(\n    (pos.x - raster.bounds[0]) / (raster.bounds[2] - raster.bounds[0]),\n    (pos.y - raster.bounds[3]) / (raster.bounds[1] - raster.bounds[3])\n  );\n}\n\nvoid main(void) {\n  vec2 uv = vTexCoord;\n  if (raster.coordinateConversion < -0.5) {\n    vec2 lnglat = mercator_to_lnglat(vTexPos);\n    uv = getUV(lnglat);\n  } else if (raster.coordinateConversion > 0.5) {\n    vec2 commonPos = lnglat_to_mercator(vTexPos);\n    uv = getUV(commonPos);\n  }\n\n  vec4 image = vec4(0.0);\n  DECKGL_CREATE_COLOR(image, uv);\n\n  DECKGL_MUTATE_COLOR(image, uv);\n\n  fragColor = apply_opacity(color_tint(color_desaturate(image.rgb)), raster.opacity);\n\n  geometry.uv = uv;\n  DECKGL_FILTER_COLOR(fragColor, geometry);\n}\n`;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/raster/raster-layer/raster-layer-webgl1.fs.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+export default "#define SHADER_NAME raster-layer-fragment-shader\n\n#ifdef GL_ES\nprecision highp float;\n#endif\n\nvarying vec2 vTexCoord;\nvarying vec2 vTexPos;\n\nuniform float desaturate;\nuniform vec4 transparentColor;\nuniform vec3 tintColor;\nuniform float opacity;\n\nuniform float coordinateConversion;\nuniform vec4 bounds;\n\n/* projection utils */\nconst float TILE_SIZE = 512.0;\nconst float PI = 3.1415926536;\nconst float WORLD_SCALE = TILE_SIZE / PI / 2.0;\n\n// from degrees to Web Mercator\nvec2 lnglat_to_mercator(vec2 lnglat) {\n  float x = lnglat.x;\n  float y = clamp(lnglat.y, -89.9, 89.9);\n  return vec2(\n    radians(x) + PI,\n    PI + log(tan(PI * 0.25 + radians(y) * 0.5))\n  ) * WORLD_SCALE;\n}\n\n// from Web Mercator to degrees\nvec2 mercator_to_lnglat(vec2 xy) {\n  xy /= WORLD_SCALE;\n  return degrees(vec2(\n    xy.x - PI,\n    atan(exp(xy.y - PI)) * 2.0 - PI * 0.5\n  ));\n}\n/* End projection utils */\n\n// apply desaturation\nvec3 color_desaturate(vec3 color) {\n  float luminance = (color.r + color.g + color.b) * 0.333333333;\n  return mix(color, vec3(luminance), desaturate);\n}\n\n// apply tint\nvec3 color_tint(vec3 color) {\n  return color * tintColor;\n}\n\n// blend with background color\nvec4 apply_opacity(vec3 color, float alpha) {\n  if (transparentColor.a == 0.0) {\n    return vec4(color, alpha);\n  }\n  float blendedAlpha = alpha + transparentColor.a * (1.0 - alpha);\n  float highLightRatio = alpha / blendedAlpha;\n  vec3 blendedRGB = mix(transparentColor.rgb, color, highLightRatio);\n  return vec4(blendedRGB, blendedAlpha);\n}\n\nvec2 getUV(vec2 pos) {\n  return vec2(\n    (pos.x - bounds[0]) / (bounds[2] - bounds[0]),\n    (pos.y - bounds[3]) / (bounds[1] - bounds[3])\n  );\n}\n\nvoid main(void) {\n  vec2 uv = vTexCoord;\n  if (coordinateConversion < -0.5) {\n    vec2 lnglat = mercator_to_lnglat(vTexPos);\n    uv = getUV(lnglat);\n  } else if (coordinateConversion > 0.5) {\n    vec2 commonPos = lnglat_to_mercator(vTexPos);\n    uv = getUV(commonPos);\n  }\n\n  vec4 image;\n  DECKGL_CREATE_COLOR(image, vTexCoord);\n\n  DECKGL_MUTATE_COLOR(image, vTexCoord);\n\n  gl_FragColor = apply_opacity(color_tint(color_desaturate(image.rgb)), opacity);\n\n  geometry.uv = uv;\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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