@deck.gl/extensions 8.9.0-beta.2 → 8.9.0-beta.4

package/src/collide/shader-module.ts

@@ -1,113 +0,0 @@
-import {Framebuffer, Texture2D} from '@luma.gl/core';
-import {project} from '@deck.gl/core';
-import type {_ShaderModule as ShaderModule} from '@deck.gl/core';
-
-const vs = `
-#ifdef NON_INSTANCED_MODEL
-attribute float collidePriorities;
-#else
-attribute float instanceCollidePriorities;
-#endif
-
-uniform sampler2D collide_texture;
-uniform bool collide_sort;
-uniform bool collide_enabled;
-
-vec2 collide_getCoords(vec4 position) {
-  vec4 collide_clipspace = project_common_position_to_clipspace(position);
-  return (1.0 + collide_clipspace.xy / collide_clipspace.w) / 2.0;
-}
-
-float collide_match(vec2 tex, vec3 pickingColor) {
-  vec4 collide_pickingColor = texture2D(collide_texture, tex);
-  float delta = dot(abs(collide_pickingColor.rgb - pickingColor), vec3(1.0));
-  float e = 0.001;
-  return step(delta, e);
-}
-
-float collide_isVisible(vec2 texCoords, vec3 pickingColor) {
-  if (!collide_enabled) {
-    return 1.0;
-  }
-
-  // Visibility test, sample area of 5x5 pixels in order to fade in/out.
-  // Due to the locality, the lookups will be cached
-  // This reduces the flicker present when objects are shown/hidden
-  const int N = 2;
-  float accumulator = 0.0;
-  vec2 step = vec2(1.0 / project_uViewportSize);
-
-  const float floatN = float(N);
-  vec2 delta = -floatN * step;
-  for(int i = -N; i <= N; i++) {
-    delta.x = -step.x * floatN;
-    for(int j = -N; j <= N; j++) {
-      accumulator += collide_match(texCoords + delta, pickingColor);
-      delta.x += step.x;
-    }
-    delta.y += step.y;
-  }
-
-  float W = 2.0 * floatN + 1.0;
-  return pow(accumulator / (W * W), 2.2);
-}
-`;
-
-const inject = {
-  'vs:#decl': `
-  float collide_fade = 1.0;
-`,
-  'vs:DECKGL_FILTER_GL_POSITION': `
-  if (collide_sort) {
-    #ifdef NON_INSTANCED_MODEL
-    float collidePriority = collidePriorities;
-    #else
-    float collidePriority = instanceCollidePriorities;
-    #endif
-    position.z = -0.001 * collidePriority * position.w; // Support range -1000 -> 1000
-  }
-
-  if (collide_enabled) {
-    vec4 collide_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-    vec2 collide_texCoords = collide_getCoords(collide_common_position);
-    collide_fade = collide_isVisible(collide_texCoords, geometry.pickingColor / 255.0);
-    if (collide_fade < 0.0001) {
-      position = vec4(0.);
-    }
-  }
-  `,
-  'vs:DECKGL_FILTER_COLOR': `
-  color.a *= collide_fade;
-  `
-};
-
-type CollideModuleSettings = {
-  collideFBO?: Framebuffer;
-  drawToCollideMap?: boolean;
-  dummyCollideMap?: Texture2D;
-};
-
-/* eslint-disable camelcase */
-type CollideUniforms = {collide_sort?: boolean; collide_texture?: Framebuffer | Texture2D};
-
-const getCollideUniforms = (
-  opts: CollideModuleSettings | {},
-  uniforms: Record<string, any>
-): CollideUniforms => {
-  if (!opts || !('dummyCollideMap' in opts)) {
-    return {};
-  }
-  const {collideFBO, drawToCollideMap, dummyCollideMap} = opts;
-  return {
-    collide_sort: Boolean(drawToCollideMap),
-    collide_texture: !drawToCollideMap && collideFBO ? collideFBO : dummyCollideMap
-  };
-};
-
-export default {
-  name: 'collide',
-  dependencies: [project],
-  vs,
-  inject,
-  getUniforms: getCollideUniforms
-} as ShaderModule;

package/src/mask/utils.ts

@@ -1,148 +0,0 @@
-import {OrthographicView, WebMercatorViewport, log, Layer, Viewport} from '@deck.gl/core';
-import {fitBounds} from '@math.gl/web-mercator';
-
-export type MaskBounds = [number, number, number, number];
-
-/*
- * Compute the bounds of the mask in world space, such that it covers an
- * area currently visible (extended by a buffer) or the area of the masking
- * data, whichever is smaller
- */
-export function getMaskBounds({
-  layers,
-  viewport
-}: {
-  layers: Layer[];
-  viewport: Viewport;
-}): MaskBounds {
-  // Join the bounds of layer data
-  let bounds: MaskBounds | null = null;
-  for (const layer of layers) {
-    const subLayerBounds = layer.getBounds();
-    if (subLayerBounds) {
-      if (bounds) {
-        bounds[0] = Math.min(bounds[0], subLayerBounds[0][0]);
-        bounds[1] = Math.min(bounds[1], subLayerBounds[0][1]);
-        bounds[2] = Math.max(bounds[2], subLayerBounds[1][0]);
-        bounds[3] = Math.max(bounds[3], subLayerBounds[1][1]);
-      } else {
-        bounds = [
-          subLayerBounds[0][0],
-          subLayerBounds[0][1],
-          subLayerBounds[1][0],
-          subLayerBounds[1][1]
-        ];
-      }
-    }
-  }
-  const viewportBounds = viewport.getBounds();
-  if (!bounds) {
-    return viewportBounds;
-  }
-
-  // Expand viewport bounds by 2X. Heurestically chosen to avoid masking
-  // errors when mask is partially out of view
-  const paddedBounds = _doubleBounds(viewportBounds);
-
-  // When bounds of the mask are smaller than the viewport bounds simply use
-  // mask bounds, so as to maximize resolution & avoid mask rerenders
-  if (
-    bounds[2] - bounds[0] < paddedBounds[2] - paddedBounds[0] ||
-    bounds[3] - bounds[1] < paddedBounds[3] - paddedBounds[1]
-  ) {
-    return bounds;
-  }
-
-  // As viewport shrinks, to avoid pixelation along mask edges
-  // we need to reduce the bounds and only render the visible portion
-  // of the mask.
-  // We pad the viewport bounds to capture the section
-  // of the mask just outside the viewport to correctly maskByInstance.
-  // Intersect mask & padded viewport bounds
-  bounds[0] = Math.max(bounds[0], paddedBounds[0]);
-  bounds[1] = Math.max(bounds[1], paddedBounds[1]);
-  bounds[2] = Math.min(bounds[2], paddedBounds[2]);
-  bounds[3] = Math.min(bounds[3], paddedBounds[3]);
-  return bounds;
-}
-
-/*
- * Compute viewport to render the mask into, covering the given bounds
- */
-export function getMaskViewport({
-  bounds,
-  viewport,
-  width,
-  height
-}: {
-  bounds: MaskBounds;
-  viewport: Viewport;
-  width: number;
-  height: number;
-}): Viewport | null {
-  if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
-    return null;
-  }
-
-  if (viewport.resolution !== undefined) {
-    log.warn('MaskExtension is not supported in GlobeView')();
-    return null;
-  }
-
-  // Single pixel border to prevent mask bleeding at edge of texture
-  const padding = 1;
-  width -= padding * 2;
-  height -= padding * 2;
-
-  if (viewport.isGeospatial) {
-    const {longitude, latitude, zoom} = fitBounds({
-      width,
-      height,
-      bounds: [
-        [bounds[0], bounds[1]],
-        [bounds[2], bounds[3]]
-      ],
-      maxZoom: 20
-    });
-    return new WebMercatorViewport({
-      longitude,
-      latitude,
-      zoom,
-      x: padding,
-      y: padding,
-      width,
-      height
-    });
-  }
-
-  const center = [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, 0];
-  const scale = Math.min(
-    1048576, // maxZoom of 20: Math.pow(2, 20) = 1048576
-    width / (bounds[2] - bounds[0]),
-    height / (bounds[3] - bounds[1])
-  );
-
-  return new OrthographicView({
-    x: padding,
-    y: padding
-  }).makeViewport({
-    width,
-    height,
-    viewState: {
-      target: center,
-      zoom: Math.log2(scale)
-    }
-  });
-}
-
-function _doubleBounds(bounds: MaskBounds): MaskBounds {
-  const size = {
-    x: bounds[2] - bounds[0],
-    y: bounds[3] - bounds[1]
-  };
-  const center = {
-    x: bounds[0] + 0.5 * size.x,
-    y: bounds[1] + 0.5 * size.y
-  };
-  return [center.x - size.x, center.y - size.y, center.x + size.x, center.y + size.y];
-}