@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

package/src/modules/engine/project/project.ts

@@ -0,0 +1,166 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {Matrix4, Vector3} from '@math.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import type {NumberArray3, NumberArray16} from '@math.gl/core';
+
+const IDENTITY_MATRIX: Readonly<NumberArray16> = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+
+/**
+ * @note Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ */
+export type ProjectionProps = {
+  viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+  projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
+};
+
+/**
+ * @note Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ */
+export type ProjectionUniforms = {
+  viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+  projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  viewProjectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
+};
+
+const DEFAULT_MODULE_OPTIONS: Required<ProjectionUniforms> = {
+  viewMatrix: IDENTITY_MATRIX,
+  projectionMatrix: IDENTITY_MATRIX,
+  viewProjectionMatrix: IDENTITY_MATRIX,
+  cameraPositionWorld: [0, 0, 0]
+};
+
+function getUniforms(
+  opts: ProjectionProps = DEFAULT_MODULE_OPTIONS,
+  prevUniforms: ProjectionUniforms = {}
+): ProjectionUniforms {
+  // const viewProjectionInverse = viewProjection.invert();
+  // viewInverseMatrix: view.invert(),
+  // viewProjectionInverseMatrix: viewProjectionInverse
+
+  const uniforms: ProjectionUniforms = {};
+  if (opts.viewMatrix !== undefined) {
+    uniforms.viewMatrix = opts.viewMatrix;
+  }
+  if (opts.projectionMatrix !== undefined) {
+    uniforms.projectionMatrix = opts.projectionMatrix;
+  }
+  if (opts.cameraPositionWorld !== undefined) {
+    uniforms.cameraPositionWorld = opts.cameraPositionWorld;
+  }
+
+  // COMPOSITE UNIFORMS
+  if (opts.projectionMatrix !== undefined) {
+    if (opts.viewMatrix !== undefined) {
+      uniforms.viewProjectionMatrix = new Matrix4(uniforms.projectionMatrix).multiplyRight(
+        opts.viewMatrix
+      );
+    }
+  }
+
+  return uniforms;
+}
+
+/**
+ * Projection uniforms are normally constant across draw calls,
+ * at least for each view.
+ * @note varyings must match vertex shader
+ * @note project module uses unprefixed uniforms to match conventions
+ */
+const vs = /* glsl */ `\
+varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+// Project uniform block
+layout(std140) uniform Project {
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+  mat4 viewProjectionMatrix;
+  vec3 cameraPositionWorld;
+} project;
+
+struct World {
+  vec3 position;
+  vec3 normal;
+};
+
+World world;
+
+void project_setPosition(vec4 position) {
+  project_vPositionWorld = position;
+}
+
+void project_setNormal(vec3 normal) {
+  project_vNormalWorld = normal;
+}
+
+void project_setPositionAndNormal_World(vec3 position, vec3 normal) {
+  world.position = position;
+  world.normal = normal;
+}
+
+void project_setPositionAndNormal_Model(vec3 position, vec3 normal, mat4 modelMatrix) {
+  world.position = (modelMatrix * vec4(position, 1.)).xyz;
+  world.normal = mat3(modelMatrix) * normal;
+}
+
+vec4 project_model_to_clipspace(vec4 position) {
+  return project.viewProjectionMatrix * position;
+}
+
+vec4 project_model_to_clipspace_Model(vec3 position, mat4 modelMatrix) {
+  return project.viewProjectionMatrix * modelMatrix * vec4(position, 1.);
+}
+
+vec4 project_world_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_view_to_clipspace(vec3 position) {
+  return project.projectionMatrix * vec4(position, 1.);
+}
+
+vec4 project_to_clipspace(vec3 position) {
+  return project.viewProjectionMatrix * vec4(position, 1.);
+}
+`;
+
+/**
+ * Functions to get the position and normal from the vertex shader
+ * @note varyings must match vertex shader
+ */
+const fs = /* glsl */ `\
+varying vec4 project_vPositionWorld;
+varying vec3 project_vNormalWorld;
+
+vec4 project_getPosition_World() {
+  return project_vPositionWorld;
+}
+
+vec3 project_getNormal_World() {
+  return project_vNormalWorld;
+}
+`;
+
+/**
+ * Projects coordinates
+ */
+export const projection = {
+  name: 'projection',
+  // Note: order and types MUST match declarations in shader
+  uniformTypes: {
+    viewMatrix: 'mat4x4<f32>',
+    projectionMatrix: 'mat4x4<f32>',
+    viewProjectionMatrix: 'mat4x4<f32>',
+    cameraPositionWorld: 'vec3<f32>'
+  },
+  getUniforms,
+  vs,
+  fs
+} as const satisfies ShaderModule<ProjectionProps, ProjectionUniforms>;

package/src/modules/engine/skin/skin.ts

@@ -0,0 +1,233 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderBinding as Binding} from '../../../types';
+import {Matrix4} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+/** Fits comfortably inside the minimum portable WebGL uniform-block limit. */
+export const SKIN_MAX_JOINTS = 64;
+
+export const source = /* wgsl */ `
+struct skinUniforms {
+  jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
+};
+
+@group(0) @binding(auto) var<uniform> skin: skinUniforms;
+
+#ifdef HAS_INSTANCED_SKIN
+@group(0) @binding(auto) var<storage, read> skinJointMatrices: array<mat4x4<f32>>;
+
+fn getInstancedSkinMatrix(
+  weights: vec4f,
+  joints: vec4u,
+  instanceIndex: u32,
+  jointsPerInstance: u32
+) -> mat4x4<f32> {
+  let firstJoint = instanceIndex * jointsPerInstance;
+  return (weights.x * skinJointMatrices[firstJoint + joints.x])
+       + (weights.y * skinJointMatrices[firstJoint + joints.y])
+       + (weights.z * skinJointMatrices[firstJoint + joints.z])
+       + (weights.w * skinJointMatrices[firstJoint + joints.w]);
+}
+#else
+#ifdef HAS_LARGE_SKIN
+@group(0) @binding(auto) var<storage, read> skinJointMatrices: array<mat4x4<f32>>;
+#endif
+#endif
+
+fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
+#ifdef HAS_LARGE_SKIN
+  return (weights.x * skinJointMatrices[joints.x])
+       + (weights.y * skinJointMatrices[joints.y])
+       + (weights.z * skinJointMatrices[joints.z])
+       + (weights.w * skinJointMatrices[joints.w]);
+#else
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+#endif
+}
+`;
+
+export const vs = /* glsl */ `\
+
+layout(std140) uniform skinUniforms {
+  mat4 jointMatrix[SKIN_MAX_JOINTS];
+} skin;
+
+#ifdef HAS_INSTANCED_SKIN
+uniform highp sampler2D skinJointMatrices;
+
+mat4 getInstancedJointMatrix(uint jointIndex, uint instanceIndex) {
+  int firstColumn = int(jointIndex * 4u);
+  int row = int(instanceIndex);
+  return mat4(
+    texelFetch(skinJointMatrices, ivec2(firstColumn, row), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 1, row), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 2, row), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 3, row), 0)
+  );
+}
+
+mat4 getInstancedSkinMatrix(
+  vec4 weights,
+  uvec4 joints,
+  uint instanceIndex,
+  uint jointsPerInstance
+) {
+  return (weights.x * getInstancedJointMatrix(joints.x, instanceIndex))
+       + (weights.y * getInstancedJointMatrix(joints.y, instanceIndex))
+       + (weights.z * getInstancedJointMatrix(joints.z, instanceIndex))
+       + (weights.w * getInstancedJointMatrix(joints.w, instanceIndex));
+}
+#else
+#ifdef HAS_LARGE_SKIN
+uniform highp sampler2D skinJointMatrices;
+
+mat4 getSkinJointMatrix(uint jointIndex) {
+  int firstColumn = int(jointIndex * 4u);
+  return mat4(
+    texelFetch(skinJointMatrices, ivec2(firstColumn, 0), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 1, 0), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 2, 0), 0),
+    texelFetch(skinJointMatrices, ivec2(firstColumn + 3, 0), 0)
+  );
+}
+#endif
+#endif
+
+mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
+#ifdef HAS_LARGE_SKIN
+  return (weights.x * getSkinJointMatrix(joints.x))
+       + (weights.y * getSkinJointMatrix(joints.y))
+       + (weights.z * getSkinJointMatrix(joints.z))
+       + (weights.w * getSkinJointMatrix(joints.w));
+#else
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+#endif
+}
+
+`;
+
+export const fs = /* glsl */ `\
+`;
+
+export type SkinProps = {
+  /** Existing glTF scenegraph input retained for backwards compatibility. */
+  scenegraphsFromGLTF?: any;
+  /** Source skin selected when the scene contains more than one skeleton. */
+  skinIndex?: number;
+  /** Adapter-owned joint palette, already expressed in the skinned mesh's local space. */
+  jointMatrices?: Float32Array | readonly number[];
+  /** Instance-packed joint palettes: WebGPU storage buffer or WebGL float texture. */
+  skinJointMatrices?: Binding;
+  /** Optional mesh transform used to convert world-space joints into mesh-local space. */
+  meshWorldMatrix?: readonly number[];
+};
+
+export type SkinUniforms = {
+  jointMatrix?: any;
+};
+
+type SkinBindings = {
+  /** WebGPU read-only storage or WebGL vertex-sampled float texture. */
+  skinJointMatrices?: Binding;
+};
+
+export const skin = {
+  props: {} as SkinProps,
+  uniforms: {} as SkinUniforms,
+  bindings: {} as SkinBindings,
+
+  name: 'skin',
+  bindingLayout: [
+    {name: 'skin', group: 0},
+    {name: 'skinJointMatrices', group: 0, visibility: 1}
+  ],
+  dependencies: [],
+  source,
+  vs,
+  fs,
+
+  defines: {
+    SKIN_MAX_JOINTS
+  },
+
+  getUniforms: (
+    props: SkinProps = {},
+    _previousUniforms?: SkinUniforms
+  ): SkinUniforms & SkinBindings => {
+    const {
+      jointMatrices,
+      skinJointMatrices,
+      scenegraphsFromGLTF,
+      skinIndex = 0,
+      meshWorldMatrix
+    } = props;
+    const bindings = skinJointMatrices ? {skinJointMatrices} : {};
+    if (jointMatrices) {
+      return {jointMatrix: makeJointPalette(jointMatrices), ...bindings};
+    }
+
+    const sourceSkin = scenegraphsFromGLTF?.gltf?.skins?.[skinIndex];
+    if (!sourceSkin) {
+      return {jointMatrix: [], ...bindings};
+    }
+
+    const {inverseBindMatrices, joints, skeleton} = sourceSkin;
+    const nodeMap = scenegraphsFromGLTF.gltfNodeIndexToNodeMap;
+    const matrices = new Map<string, Matrix4>();
+    const root = skeleton === undefined ? undefined : nodeMap?.get(skeleton);
+    const roots = root ? [root] : scenegraphsFromGLTF.scenes || [];
+    for (const sceneRoot of roots) {
+      sceneRoot.preorderTraversal((node: {id: string}, {worldMatrix}: {worldMatrix: Matrix4}) => {
+        matrices.set(node.id, worldMatrix);
+      });
+    }
+
+    const inverseMeshMatrix = meshWorldMatrix ? new Matrix4(meshWorldMatrix).invert() : null;
+    const jointPalette = new Float32Array(SKIN_MAX_JOINTS * 16);
+    const inverseBindValues = inverseBindMatrices?.value;
+
+    for (let jointIndex = 0; jointIndex < Math.min(joints.length, SKIN_MAX_JOINTS); jointIndex++) {
+      const jointNode = nodeMap?.get(joints[jointIndex]);
+      if (!jointNode) {
+        continue;
+      }
+
+      const worldMatrix = matrices.get(jointNode.id) || jointNode.matrix;
+      const jointMatrix = inverseMeshMatrix
+        ? new Matrix4(inverseMeshMatrix).multiplyRight(worldMatrix)
+        : new Matrix4(worldMatrix);
+      if (inverseBindValues && inverseBindValues.length >= (jointIndex + 1) * 16) {
+        jointMatrix.multiplyRight(
+          new Matrix4(Array.from(inverseBindValues.slice(jointIndex * 16, (jointIndex + 1) * 16)))
+        );
+      }
+      jointPalette.set(jointMatrix, jointIndex * 16);
+    }
+
+    return {jointMatrix: jointPalette, ...bindings};
+  },
+
+  uniformTypes: {
+    jointMatrix: ['mat4x4<f32>', SKIN_MAX_JOINTS]
+  }
+} as const satisfies ShaderModule<SkinProps, SkinUniforms, SkinBindings>;
+
+function makeJointPalette(jointMatrices: Float32Array | readonly number[]): Float32Array {
+  const jointPalette = new Float32Array(SKIN_MAX_JOINTS * 16);
+  jointPalette.set(
+    jointMatrices instanceof Float32Array
+      ? jointMatrices.subarray(0, jointPalette.length)
+      : jointMatrices.slice(0, jointPalette.length)
+  );
+  return jointPalette;
+}

package/src/modules/engine/transform/transform.ts

@@ -0,0 +1,50 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+const vs = /* glsl */ `\
+attribute float transform_elementID;
+
+// returns half of pixel size, used to move the pixel position to center of the pixel.
+vec2 transform_getPixelSizeHalf(vec2 size) {
+  return vec2(1.) / (2. * size);
+}
+
+// returns current elements pixel indeces [x, y],
+// where x ranges in [0 to texSize-1] and y ranges in [0 to texSize-1]
+vec2 transform_getPixelIndices(vec2 texSize, vec2 pixelSizeHalf) {
+  // Add safe offset (half of pixel height) before doing floor
+  float yIndex = floor((transform_elementID / texSize[0]) + pixelSizeHalf[1]);
+  float xIndex = transform_elementID - (yIndex * texSize[0]);
+  return vec2(xIndex, yIndex);
+}
+
+// returns current elementID's texture co-ordianate
+vec2 transform_getTexCoord(vec2 size) {
+  vec2 pixelSizeHalf = transform_getPixelSizeHalf(size);
+  vec2 indices = transform_getPixelIndices(size, pixelSizeHalf);
+  vec2 coord = indices / size + pixelSizeHalf;
+  return coord;
+}
+
+// returns current elementID's position
+vec2 transform_getPos(vec2 size) {
+  vec2 texCoord = transform_getTexCoord(size);
+  // Change from [0 1] range to [-1 1]
+  vec2 pos = (texCoord * (2.0, 2.0)) - (1., 1.);
+  return pos;
+}
+
+// returns current elementID's pixel value
+vec4 transform_getInput(sampler2D texSampler, vec2 size) {
+  vec2 texCoord = transform_getTexCoord(size);
+  vec4 textureColor = texture2D(texSampler, texCoord);
+  return textureColor;
+}
+`;
+
+/** Private shader module used by `Transform` */
+export const transform = {
+  name: 'transform',
+  vs
+};

package/src/modules/geometry/path-dash/path-dash.ts

@@ -0,0 +1,68 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type PathDashUniforms = {dashLength: number; gapLength: number; offset: number};
+export type PathDashProps = Partial<PathDashUniforms>;
+const DEFAULT_UNIFORMS: PathDashUniforms = {dashLength: 12, gapLength: 8, offset: 0};
+
+/** Filtered dash coverage from cumulative path distance, independent of coordinate units. */
+export const pathDash: ShaderModule<PathDashProps, PathDashUniforms> = {
+  name: 'pathDash',
+  bindingLayout: [{name: 'pathDash', group: 3}],
+  firstBindingSlot: 0,
+  uniformTypes: {dashLength: 'f32', gapLength: 'f32', offset: 'f32'},
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = {...DEFAULT_UNIFORMS, ...previousUniforms};
+    if (props.dashLength !== undefined) uniforms.dashLength = Math.max(0, props.dashLength);
+    if (props.gapLength !== undefined) uniforms.gapLength = Math.max(0, props.gapLength);
+    if (props.offset !== undefined) uniforms.offset = props.offset;
+    return uniforms;
+  },
+  fs: /* glsl */ `
+layout(std140) uniform pathDashUniforms {
+  float dashLength;
+  float gapLength;
+  float offset;
+} pathDash;
+float pathDash_integral(float coordinate, float fraction) {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+float pathDash_getCoverage(float distanceAlongPath) {
+  float period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  float coordinate = (distanceAlongPath + pathDash.offset) / period;
+  float extent = max(fwidth(coordinate), 0.0001);
+  float center = fract(coordinate);
+  float fraction = pathDash.dashLength / period;
+  float coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) return 1.0;
+  if (pathDash.dashLength <= 0.0) return 0.0;
+  return clamp(coverage, 0.0, 1.0);
+}
+`,
+  source: /* wgsl */ `
+struct pathDashUniforms {
+  dashLength: f32,
+  gapLength: f32,
+  offset: f32,
+};
+@group(3) @binding(auto) var<uniform> pathDash: pathDashUniforms;
+fn pathDash_integral(coordinate: f32, fraction: f32) -> f32 {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+fn pathDash_getCoverage(distanceAlongPath: f32) -> f32 {
+  let period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  let coordinate = (distanceAlongPath + pathDash.offset) / period;
+  let extent = max(fwidth(coordinate), 0.0001);
+  let center = fract(coordinate);
+  let fraction = pathDash.dashLength / period;
+  let coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) { return 1.0; }
+  if (pathDash.dashLength <= 0.0) { return 0.0; }
+  return clamp(coverage, 0.0, 1.0);
+}
+`
+};

package/src/modules/geometry/pattern-fill/pattern-fill-shaders.ts

@@ -0,0 +1,88 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const PATTERN_FILL_GLSL = /* glsl */ `
+layout(std140) uniform patternFillUniforms {
+  int patternType;
+  float spacing;
+  float width;
+  float angle;
+  vec2 offset;
+} patternFill;
+
+// Integral of a unit-period pulse. Filtering the integral preserves mean coverage at distance.
+float patternFill_integral(float coordinate, float width) {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+float patternFill_stripe(float coordinate, float footprint, float width) {
+  float extent = max(footprint, 0.0001);
+  float center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+float patternFill_getCoverage(vec2 coordinates) {
+  float cosine = cos(patternFill.angle);
+  float sine = sin(patternFill.angle);
+  vec2 local = coordinates - patternFill.offset;
+  vec2 rotated = vec2(dot(local, vec2(cosine, sine)), dot(local, vec2(-sine, cosine)));
+  vec2 phase = rotated / max(patternFill.spacing, 0.0001);
+  // Evaluate derivatives before pattern selection so WGSL and GLSL use the same footprint.
+  vec2 footprint = fwidth(phase);
+  float width = clamp(patternFill.width, 0.0, 1.0);
+  float first = patternFill_stripe(phase.x, footprint.x, width);
+  float second = patternFill_stripe(phase.y, footprint.y, width);
+  vec2 cell = fract(phase + 0.5) - 0.5;
+  float radius = width * 0.5;
+  float dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  float dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) return 0.0;
+  if (patternFill.patternType == 2) return dots;
+  if (patternFill.patternType == 1) return first + second - first * second;
+  return first;
+}
+`;
+
+export const PATTERN_FILL_WGSL = /* wgsl */ `
+struct patternFillUniforms {
+  patternType: i32,
+  spacing: f32,
+  width: f32,
+  angle: f32,
+  offset: vec2<f32>,
+};
+@group(3) @binding(auto) var<uniform> patternFill: patternFillUniforms;
+
+fn patternFill_integral(coordinate: f32, width: f32) -> f32 {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+fn patternFill_stripe(coordinate: f32, footprint: f32, width: f32) -> f32 {
+  let extent = max(footprint, 0.0001);
+  let center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+fn patternFill_getCoverage(coordinates: vec2<f32>) -> f32 {
+  let cosine = cos(patternFill.angle);
+  let sine = sin(patternFill.angle);
+  let local = coordinates - patternFill.offset;
+  let rotated = vec2<f32>(dot(local, vec2<f32>(cosine, sine)), dot(local, vec2<f32>(-sine, cosine)));
+  let phase = rotated / max(patternFill.spacing, 0.0001);
+  let footprint = fwidth(phase);
+  let width = clamp(patternFill.width, 0.0, 1.0);
+  let first = patternFill_stripe(phase.x, footprint.x, width);
+  let second = patternFill_stripe(phase.y, footprint.y, width);
+  let cell = fract(phase + 0.5) - 0.5;
+  let radius = width * 0.5;
+  var dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  let dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) { return 0.0; }
+  if (patternFill.patternType == 2) { return dots; }
+  if (patternFill.patternType == 1) { return first + second - first * second; }
+  return first;
+}
+`;

package/src/modules/geometry/pattern-fill/pattern-fill.ts

@@ -0,0 +1,54 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {PATTERN_FILL_GLSL, PATTERN_FILL_WGSL} from './pattern-fill-shaders';
+
+export type PatternFillUniforms = {
+  patternType: number;
+  spacing: number;
+  width: number;
+  angle: number;
+  offset: readonly [number, number];
+};
+
+export type PatternFillProps = Partial<Omit<PatternFillUniforms, 'patternType'>> & {
+  pattern?: 'hatch' | 'crosshatch' | 'dots';
+};
+
+const DEFAULT_UNIFORMS: PatternFillUniforms = {
+  patternType: 0,
+  spacing: 8,
+  width: 0.12,
+  angle: Math.PI / 4,
+  offset: [0, 0]
+};
+
+/** Fragment coverage for coordinate-anchored, filtered hatch and dot fills. */
+export const patternFill: ShaderModule<PatternFillProps, PatternFillUniforms> = {
+  name: 'patternFill',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'patternFill', group: 3}],
+  source: PATTERN_FILL_WGSL,
+  fs: PATTERN_FILL_GLSL,
+  uniformTypes: {
+    patternType: 'i32',
+    spacing: 'f32',
+    width: 'f32',
+    angle: 'f32',
+    offset: 'vec2<f32>'
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = {...DEFAULT_UNIFORMS, ...previousUniforms};
+    if (props.pattern !== undefined) {
+      uniforms.patternType = {hatch: 0, crosshatch: 1, dots: 2}[props.pattern];
+    }
+    if (props.spacing !== undefined) uniforms.spacing = Math.max(props.spacing, 0.0001);
+    if (props.width !== undefined) uniforms.width = Math.min(1, Math.max(0, props.width));
+    if (props.angle !== undefined) uniforms.angle = props.angle;
+    if (props.offset !== undefined) uniforms.offset = props.offset;
+    return uniforms;
+  }
+};