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

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

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patchPipelineValidation = patchPipelineValidation;
+var _webgl = require("@luma.gl/webgl");
+// 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
+
+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';
+  };
+}
+function patchPipelineValidation() {
+  if (_patched) return;
+  _patched = true;
+
+  // Strategy 1: luma.gl <9.3 — _getLinkStatus on WEBGLRenderPipeline
+  if (_webgl.WEBGLRenderPipeline !== null && _webgl.WEBGLRenderPipeline !== void 0 && _webgl.WEBGLRenderPipeline.prototype && typeof _webgl.WEBGLRenderPipeline.prototype._getLinkStatus === 'function') {
+    var original = _webgl.WEBGLRenderPipeline.prototype._getLinkStatus;
+    _webgl.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 = _webgl.WebGLDevice === null || _webgl.WebGLDevice === void 0 ? void 0 : _webgl.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 !== _webgl.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":["_webgl","require","MIXED_SAMPLER_RE","_patched","createPatchedLinkStatus","_original","_patchedGetLinkStatus","gl","device","linked","getProgramParameter","handle","linkStatus","_initializeSamplerUniforms","validateProgram","validated","infoLog","getProgramInfoLog","test","patchPipelineValidation","WEBGLRenderPipeline","prototype","_getLinkStatus","original","deviceProto","WebGLDevice","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/raster/raster-layer/raster-layer-shaders.d.ts

@@ -0,0 +1,56 @@
+import type { ShaderModule as LumaShaderModule } from '../webgl/types';
+export declare const rasterUniforms: {
+    name: string;
+    vs: string;
+    fs: string;
+    uniformTypes: {
+        bounds: string;
+        coordinateConversion: string;
+        desaturate: string;
+        opacity: string;
+        tintColor: string;
+        transparentColor: string;
+    };
+};
+/**
+ * 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 declare function ensureRasterHooksRegistered(): void;
+/**
+ * Convert kepler.gl's custom raster shader modules into luma.gl 9 compatible
+ * format. Ensures fs2 (WebGL2) shaders are used and texture2D -> texture.
+ */
+interface LumaModuleOutput {
+    name: string;
+    fs: string;
+    vs?: string;
+    defines?: Record<string, string>;
+    getUniforms?: (opts: object) => Record<string, unknown> | null;
+    uniforms?: Record<string, unknown>;
+    uniformTypes?: Record<string, string>;
+    inject?: Record<string, string>;
+    dependencies?: unknown[];
+    deprecations?: unknown[];
+}
+export declare function prepareLumaModules(modules: LumaShaderModule[]): LumaModuleOutput[];
+/**
+ * Build the vertex shader for the raster layer.
+ * References raster.coordinateConversion from the UBO.
+ */
+export declare function buildRasterVertexShader(): string;
+/**
+ * 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 declare function buildRasterFragmentShader(): string;
+export {};

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

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildRasterFragmentShader = buildRasterFragmentShader;
+exports.buildRasterVertexShader = buildRasterVertexShader;
+exports.ensureRasterHooksRegistered = ensureRasterHooksRegistered;
+exports.prepareLumaModules = prepareLumaModules;
+exports.rasterUniforms = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _shadertools = require("@luma.gl/shadertools");
+var _rasterProcessingUniforms = require("../raster-processing-uniforms");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * 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";
+var rasterUniforms = exports.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).
+ */
+function ensureRasterHooksRegistered() {
+  var assembler = _shadertools.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.
+ */
+
+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 = _rasterProcessingUniforms.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 = (0, _slicedToArray2["default"])(_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 = (0, _slicedToArray2["default"])(_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 = (0, _slicedToArray2["default"])(_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.
+ */
+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.
+ */
+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":["_shadertools","require","_rasterProcessingUniforms","rasterUniformBlock","rasterUniforms","exports","name","vs","fs","uniformTypes","bounds","coordinateConversion","desaturate","opacity","tintColor","transparentColor","ensureRasterHooksRegistered","assembler","ShaderAssembler","getDefaultShaderAssembler","existingHooks","_hookFunctions","hookNames","map","h","hook","some","includes","addShaderHook","prepareLumaModules","modules","mod","fs2","replace","nameMap","UNIFORM_NAME_MAP","consolidate","Boolean","console","warn","concat","blockPattern","RegExp","_i","_Object$entries","Object","entries","length","_Object$entries$_i","_slicedToArray2","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/raster/raster-layer/raster-layer.d.ts

@@ -1,16 +1,16 @@
-import { UpdateParameters } from '@deck.gl/core/typed';
-import { BitmapLayer } from '@deck.gl/layers/typed';
+import { UpdateParameters } from '@deck.gl/core';
+import { BitmapLayer } from '@deck.gl/layers';
 import type { RasterLayerAddedProps, ImageState } from '../types';
 export default class RasterLayer extends BitmapLayer<RasterLayerAddedProps> {
     state: BitmapLayer<RasterLayerAddedProps>['state'] & {
         images: ImageState;
     };
+    _redrawScheduled: boolean;
     initializeState(): void;
-    draw({ uniforms }: {
-        uniforms: {
-            [key: string]: any;
-        };
+    draw(_opts: {
+        shaderModuleProps: Record<string, unknown>;
     }): void;
+    _scheduleRedraw(): void;
     getShaders(): any;
     updateState(params: UpdateParameters<BitmapLayer<RasterLayerAddedProps>>): void;
     updateImages({ props, oldProps }: {