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

package/src/modules/geometry/point-glow/point-glow.ts

@@ -0,0 +1,87 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type PointGlowUniforms = {
+  coreRadius: number;
+  coreIntensity: number;
+  haloIntensity: number;
+  falloff: number;
+};
+export type PointGlowProps = Partial<PointGlowUniforms>;
+
+const DEFAULT_UNIFORMS: PointGlowUniforms = {
+  coreRadius: 0.12,
+  coreIntensity: 1,
+  haloIntensity: 0.6,
+  falloff: 5
+};
+
+/** Linear radiance for a bounded point sprite. Blend additively or composite into an HDR target. */
+export const pointGlow: ShaderModule<PointGlowProps, PointGlowUniforms> = {
+  name: 'pointGlow',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'pointGlow', group: 3}],
+  uniformTypes: {
+    coreRadius: 'f32',
+    coreIntensity: 'f32',
+    haloIntensity: 'f32',
+    falloff: 'f32'
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = {...DEFAULT_UNIFORMS, ...previousUniforms};
+    if (props.coreRadius !== undefined)
+      uniforms.coreRadius = Math.min(1, Math.max(0, props.coreRadius));
+    if (props.coreIntensity !== undefined)
+      uniforms.coreIntensity = Math.max(0, props.coreIntensity);
+    if (props.haloIntensity !== undefined)
+      uniforms.haloIntensity = Math.max(0, props.haloIntensity);
+    if (props.falloff !== undefined) uniforms.falloff = Math.max(0.01, props.falloff);
+    return uniforms;
+  },
+  fs: /* glsl */ `
+layout(std140) uniform pointGlowUniforms {
+  float coreRadius;
+  float coreIntensity;
+  float haloIntensity;
+  float falloff;
+} pointGlow;
+
+// Coordinates span [-1, 1] across the sprite; tint is linear RGB.
+vec3 pointGlow_getColor(vec2 coordinates, vec3 tint) {
+  float radius = length(coordinates);
+  float edgeWidth = max(fwidth(radius), 0.0001);
+  float envelope = 1.0 - smoothstep(1.0 - edgeWidth, 1.0, radius);
+  float core = 1.0 - smoothstep(pointGlow.coreRadius - edgeWidth * 0.5,
+    pointGlow.coreRadius + edgeWidth * 0.5, radius);
+  if (pointGlow.coreRadius <= 0.0) core = 0.0;
+  float outer = exp(-pointGlow.falloff);
+  float halo = max(0.0, (exp(-pointGlow.falloff * radius * radius) - outer) / (1.0 - outer));
+  return (vec3(core * pointGlow.coreIntensity) + tint * halo * pointGlow.haloIntensity) * envelope;
+}
+`,
+  source: /* wgsl */ `
+struct pointGlowUniforms {
+  coreRadius: f32,
+  coreIntensity: f32,
+  haloIntensity: f32,
+  falloff: f32,
+};
+@group(3) @binding(auto) var<uniform> pointGlow: pointGlowUniforms;
+
+fn pointGlow_getColor(coordinates: vec2<f32>, tint: vec3<f32>) -> vec3<f32> {
+  let radius = length(coordinates);
+  let edgeWidth = max(fwidth(radius), 0.0001);
+  let envelope = 1.0 - smoothstep(1.0 - edgeWidth, 1.0, radius);
+  var core = 1.0 - smoothstep(pointGlow.coreRadius - edgeWidth * 0.5,
+    pointGlow.coreRadius + edgeWidth * 0.5, radius);
+  if (pointGlow.coreRadius <= 0.0) { core = 0.0; }
+  let outer = exp(-pointGlow.falloff);
+  let halo = max(0.0, (exp(-pointGlow.falloff * radius * radius) - outer) / (1.0 - outer));
+  return (vec3<f32>(core * pointGlow.coreIntensity) + tint * halo * pointGlow.haloIntensity) * envelope;
+}
+`
+};

package/src/modules/geometry/precipitation/README.md

@@ -0,0 +1,19 @@
+# precipitation
+
+GLSL vertex and WGSL shader helpers for deterministic falling particles.
+`precipitation_getPosition(identifier)` returns a local east/north/up metre position.
+`precipitation_getFade(position)` fades recycling at the boundaries of the volume.
+
+Uniforms include `time` in seconds, `fallSpeed` in metres/second downward, east/north
+`wind` in metres/second, `turbulence` amplitude in metres, an integer `seed` from 0 to
+16,777,215, and `volumeCenter` / positive `volumeSize` in metres. Time must be finite and
+non-negative; all other inputs must be finite. Callers own the clock, particle count,
+projection, appearance, surface exclusion, and animation scheduling.
+
+Positions are evaluated analytically from seed and identifier with periodic wrapping.
+Pausing requires only keeping time constant. Moving the center of a fixed-size volume
+preserves overlapping particles' world positions; new particles wrap in at its boundaries.
+Changing size, seed, or velocity changes trajectories immediately. Turbulence adds gentle
+horizontal swaying, suitable for snow. There is no persistent simulation state or collision
+response. Long-running applications should reset between sessions before float time loses
+needed precision.

package/src/modules/geometry/precipitation/precipitation.ts

@@ -0,0 +1,108 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type PrecipitationUniforms = {
+  time: number;
+  fallSpeed: number;
+  turbulence: number;
+  seed: number;
+  volumeCenter: [number, number, number];
+  volumeSize: [number, number, number];
+  wind: [number, number];
+};
+export type PrecipitationProps = Partial<PrecipitationUniforms>;
+
+/** Stateless, seeded falling particles in a movable volume. Coordinates are local metres. */
+export const precipitation = {
+  name: 'precipitation',
+  bindingLayout: [{name: 'precipitation', group: 3}],
+  uniformTypes: {
+    time: 'f32',
+    fallSpeed: 'f32',
+    turbulence: 'f32',
+    seed: 'f32',
+    volumeCenter: 'vec3<f32>',
+    volumeSize: 'vec3<f32>',
+    wind: 'vec2<f32>'
+  },
+  defaultUniforms: {
+    time: 0,
+    fallSpeed: 20,
+    turbulence: 0,
+    seed: 29,
+    volumeCenter: [0, 0, 150],
+    volumeSize: [1200, 1600, 300],
+    wind: [2, 0]
+  },
+  getUniforms(props: PrecipitationProps = {}) {
+    return props;
+  },
+  vs: /* glsl */ `
+layout(std140) uniform precipitationUniforms {
+  float time;
+  float fallSpeed;
+  float turbulence;
+  float seed;
+  vec3 volumeCenter;
+  vec3 volumeSize;
+  vec2 wind;
+} precipitation;
+float precipitation_random(uint identifier) {
+  uint value = identifier + uint(precipitation.seed) * 747796405u;
+  value = (value ^ (value >> 16u)) * 2246822519u;
+  value = (value ^ (value >> 13u)) * 3266489917u;
+  value = value ^ (value >> 16u);
+  return float(value & 16777215u) / 16777216.0;
+}
+vec3 precipitation_getPosition(uint identifier) {
+  vec3 randomPosition = vec3(precipitation_random(identifier * 3u), precipitation_random(identifier * 3u + 1u), precipitation_random(identifier * 3u + 2u));
+  vec3 volumeSize = max(precipitation.volumeSize, vec3(0.001));
+  vec3 minimum = precipitation.volumeCenter - volumeSize * 0.5;
+  vec3 drift = vec3(precipitation.wind, -precipitation.fallSpeed) * precipitation.time;
+  vec3 position = mod(randomPosition * volumeSize + drift - minimum, volumeSize) + minimum;
+  position.xy += precipitation.turbulence * vec2(sin(precipitation.time * 0.9 + randomPosition.z * 31.0), cos(precipitation.time * 0.7 + randomPosition.x * 23.0));
+  return position;
+}
+float precipitation_getFade(vec3 position) {
+  vec3 edge = 0.5 - abs((position - precipitation.volumeCenter) / max(precipitation.volumeSize, vec3(0.001)));
+  return smoothstep(0.0, 0.08, min(edge.x, min(edge.y, edge.z)));
+}
+`,
+  source: /* wgsl */ `
+struct precipitationUniforms {
+  time: f32,
+  fallSpeed: f32,
+  turbulence: f32,
+  seed: f32,
+  volumeCenter: vec3<f32>,
+  volumeSize: vec3<f32>,
+  wind: vec2<f32>,
+};
+@group(3) @binding(auto) var<uniform> precipitation: precipitationUniforms;
+fn precipitation_random(identifier: u32) -> f32 {
+  var value = identifier + u32(precipitation.seed) * 747796405u;
+  value = (value ^ (value >> 16u)) * 2246822519u;
+  value = (value ^ (value >> 13u)) * 3266489917u;
+  value = value ^ (value >> 16u);
+  return f32(value & 16777215u) / 16777216.0;
+}
+fn precipitation_getPosition(identifier: u32) -> vec3<f32> {
+  let randomPosition = vec3<f32>(precipitation_random(identifier * 3u), precipitation_random(identifier * 3u + 1u), precipitation_random(identifier * 3u + 2u));
+  let volumeSize = max(precipitation.volumeSize, vec3<f32>(0.001));
+  let minimum = precipitation.volumeCenter - volumeSize * 0.5;
+  let drift = vec3<f32>(precipitation.wind, -precipitation.fallSpeed) * precipitation.time;
+  let unwrapped = randomPosition * volumeSize + drift - minimum;
+  var position = unwrapped - floor(unwrapped / volumeSize) * volumeSize + minimum;
+  position.x += precipitation.turbulence * sin(precipitation.time * 0.9 + randomPosition.z * 31.0);
+  position.y += precipitation.turbulence * cos(precipitation.time * 0.7 + randomPosition.x * 23.0);
+  return position;
+}
+fn precipitation_getFade(position: vec3<f32>) -> f32 {
+  let edge = 0.5 - abs((position - precipitation.volumeCenter) / max(precipitation.volumeSize, vec3<f32>(0.001)));
+  return smoothstep(0.0, 0.08, min(edge.x, min(edge.y, edge.z)));
+}
+`
+} as const satisfies ShaderModule<PrecipitationProps, PrecipitationUniforms>;

package/src/modules/geometry/sketch-stroke/sketch-stroke.ts

@@ -0,0 +1,160 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type SketchStrokeProps = {
+  /** Full stroke width in the same units as the transverse coordinate. */
+  width?: number;
+  /** Maximum centerline displacement in transverse-coordinate units. */
+  jitter?: number;
+  /** Fractional width variation, from zero to one. */
+  variation?: number;
+  /** Strength of pencil grain, from zero to one. */
+  grain?: number;
+  /** Transverse screen-space displacement for a secondary hand-drawn pass. */
+  offset?: number;
+  /** Endpoint overshoot in stroke units; geometry must reserve this space. */
+  extension?: number;
+  /** Zero gives a solid stroke; one enables sketch shading. */
+  sketch?: number;
+  /** Minimum edge smoothing in stroke units. Defaults to 0.7 for pixel-sized strokes. */
+  minimumAntialias?: number;
+};
+
+const defaults = {
+  width: 2,
+  jitter: 0.7,
+  variation: 0.35,
+  grain: 0.45,
+  offset: 0,
+  extension: 3,
+  sketch: 1,
+  minimumAntialias: 0.7
+};
+const uniformBlock = `
+layout(std140) uniform sketchStrokeUniforms {
+  float width;
+  float jitter;
+  float variation;
+  float grain;
+  float offset;
+  float extension;
+  float sketch;
+  float minimumAntialias;
+} sketchStroke;
+`;
+const functions = `
+float sketchStroke_noise(float coordinate) {
+  float cell = floor(coordinate);
+  float fraction = fract(coordinate);
+  float first = fract(sin(cell * 127.1) * 43758.5453);
+  float second = fract(sin((cell + 1.0) * 127.1) * 43758.5453);
+  return mix(first, second, fraction * fraction * (3.0 - 2.0 * fraction));
+}
+float sketchStroke_noise2(vec2 coordinate) {
+  vec2 cell = floor(coordinate);
+  vec2 fraction = fract(coordinate);
+  fraction = fraction * fraction * (3.0 - 2.0 * fraction);
+  float first = fract(sin(dot(cell, vec2(127.1, 311.7))) * 43758.5453);
+  float second = fract(sin(dot(cell + vec2(1.0, 0.0), vec2(127.1, 311.7))) * 43758.5453);
+  float third = fract(sin(dot(cell + vec2(0.0, 1.0), vec2(127.1, 311.7))) * 43758.5453);
+  float fourth = fract(sin(dot(cell + vec2(1.0, 1.0), vec2(127.1, 311.7))) * 43758.5453);
+  return mix(mix(first, second, fraction.x), mix(third, fourth, fraction.x), fraction.y);
+}
+// coordinates.x is normalized distance along a segment, y is signed transverse distance. All distances use the same units.
+// Seeds belong to the geometry; neither camera position nor time changes the grain.
+float sketchStroke_getCoverage(vec2 coordinates, float strokeLength, float seed) {
+  float along = coordinates.x;
+  float side = sketchStroke_noise(seed * 29.0) < 0.5 ? -1.0 : 1.0;
+  float center = (sketchStroke_noise(along * strokeLength / 36.0 + seed * 19.0) * 2.0 - 1.0) * sketchStroke.jitter * sketchStroke.sketch + side * sketchStroke.offset * sketchStroke.sketch;
+  float variation = mix(1.0, 0.55 + sketchStroke_noise(along * 31.0 + seed * 7.0) * 0.75, sketchStroke.variation * sketchStroke.sketch);
+  vec2 grainCoordinates = vec2(along * strokeLength, coordinates.y) + vec2(seed * 17.0, seed * 53.0);
+  float coarseGrain = sketchStroke_noise2(grainCoordinates * 0.55);
+  float fineGrain = sketchStroke_noise2(grainCoordinates * 2.8);
+  float toothGrain = sketchStroke_noise2(grainCoordinates * 6.5);
+  float grainTexture = coarseGrain * 0.35 + fineGrain * 0.4 + toothGrain * 0.25;
+  float edgeRoughness = (grainTexture - 0.5) * sketchStroke.grain * sketchStroke.sketch * 0.7;
+  float radius = sketchStroke.width * 0.5 * variation + edgeRoughness;
+  float endDistance = max(-along, along - 1.0) * strokeLength - sketchStroke.extension;
+  float distance = max(abs(coordinates.y - center) - radius, endDistance);
+  float antialias = max(fwidth(distance), max(sketchStroke.minimumAntialias, 0.0001));
+  float coverage = 1.0 - smoothstep(-antialias * 0.5, antialias * 0.5, distance);
+  // Keep the pigment opaque; grain changes the stroke edge so the paper does not show through as white flecks.
+  return coverage;
+}
+`;
+
+const source = `
+struct sketchStrokeUniforms {
+  width: f32,
+  jitter: f32,
+  variation: f32,
+  grain: f32,
+  offset: f32,
+  extension: f32,
+  sketch: f32,
+  minimumAntialias: f32,
+};
+@group(3) @binding(auto) var<uniform> sketchStroke: sketchStrokeUniforms;
+fn sketchStroke_noise(coordinate: f32) -> f32 {
+  let cell = floor(coordinate);
+  let fraction = fract(coordinate);
+  let first = fract(sin(cell * 127.1) * 43758.5453);
+  let second = fract(sin((cell + 1.0) * 127.1) * 43758.5453);
+  return mix(first, second, fraction * fraction * (3.0 - 2.0 * fraction));
+}
+fn sketchStroke_noise2(coordinate: vec2<f32>) -> f32 {
+  let cell = floor(coordinate);
+  var fraction = fract(coordinate);
+  fraction = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);
+  let first = fract(sin(dot(cell, vec2<f32>(127.1, 311.7))) * 43758.5453);
+  let second = fract(sin(dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7))) * 43758.5453);
+  let third = fract(sin(dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);
+  let fourth = fract(sin(dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);
+  return mix(mix(first, second, fraction.x), mix(third, fourth, fraction.x), fraction.y);
+}
+fn sketchStroke_getCoverage(coordinates: vec2<f32>, strokeLength: f32, seed: f32) -> f32 {
+  let along = coordinates.x;
+  let side = select(1.0, -1.0, sketchStroke_noise(seed * 29.0) < 0.5);
+  let center = (sketchStroke_noise(along * strokeLength / 36.0 + seed * 19.0) * 2.0 - 1.0) * sketchStroke.jitter * sketchStroke.sketch + side * sketchStroke.offset * sketchStroke.sketch;
+  let variation = mix(1.0, 0.55 + sketchStroke_noise(along * 31.0 + seed * 7.0) * 0.75, sketchStroke.variation * sketchStroke.sketch);
+  let grainCoordinates = vec2<f32>(along * strokeLength, coordinates.y) + vec2<f32>(seed * 17.0, seed * 53.0);
+  let coarseGrain = sketchStroke_noise2(grainCoordinates * 0.55);
+  let fineGrain = sketchStroke_noise2(grainCoordinates * 2.8);
+  let toothGrain = sketchStroke_noise2(grainCoordinates * 6.5);
+  let grainTexture = coarseGrain * 0.35 + fineGrain * 0.4 + toothGrain * 0.25;
+  let edgeRoughness = (grainTexture - 0.5) * sketchStroke.grain * sketchStroke.sketch * 0.7;
+  let radius = sketchStroke.width * 0.5 * variation + edgeRoughness;
+  let endDistance = max(-along, along - 1.0) * strokeLength - sketchStroke.extension;
+  let distance = max(abs(coordinates.y - center) - radius, endDistance);
+  let antialias = max(fwidth(distance), max(sketchStroke.minimumAntialias, 0.0001));
+  let coverage = 1.0 - smoothstep(-antialias * 0.5, antialias * 0.5, distance);
+  // Keep the pigment opaque; grain changes the stroke edge so the paper does not show through as white flecks.
+  return coverage;
+}
+`;
+
+/** Fragment coverage for geometry-anchored pencil strokes and solid architectural lines. */
+export const sketchStroke = {
+  name: 'sketchStroke',
+  bindingLayout: [{name: 'sketchStroke', group: 3}],
+  source,
+  vs: uniformBlock,
+  fs: uniformBlock + functions,
+  uniformTypes: {
+    width: 'f32',
+    jitter: 'f32',
+    variation: 'f32',
+    grain: 'f32',
+    offset: 'f32',
+    extension: 'f32',
+    sketch: 'f32',
+    minimumAntialias: 'f32'
+  },
+  defaultUniforms: defaults,
+  getUniforms(props: SketchStrokeProps = {}) {
+    return {...defaults, ...props};
+  }
+} as const satisfies ShaderModule<SketchStrokeProps, SketchStrokeProps>;