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

package/dist/modules/geometry/point-glow/point-glow.js

@@ -0,0 +1,77 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const DEFAULT_UNIFORMS = {
+    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 = {
+    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;
+}
+`
+};
+//# sourceMappingURL=point-glow.js.map

package/dist/modules/geometry/point-glow/point-glow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"point-glow.js","sourceRoot":"","sources":["../../../../src/modules/geometry/point-glow/point-glow.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAY5D,MAAM,gBAAgB,GAAsB;IAC1C,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,CAAC;IAChB,aAAa,EAAE,GAAG;IAClB,OAAO,EAAE,CAAC;CACX,CAAC;AAEF,oGAAoG;AACpG,MAAM,CAAC,MAAM,SAAS,GAAoD;IACxE,IAAI,EAAE,WAAW;IACjB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC9C,YAAY,EAAE;QACZ,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,KAAK;QACpB,aAAa,EAAE,KAAK;QACpB,OAAO,EAAE,KAAK;KACf;IACD,eAAe,EAAE,gBAAgB;IACjC,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;QACzD,MAAM,QAAQ,GAAG,EAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,EAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS;YAChC,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QACnE,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS;YACnC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS;YACnC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QAClF,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBpB;CACA,CAAC"}

package/dist/modules/geometry/precipitation/precipitation.cjs

@@ -0,0 +1,122 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var precipitation_exports = {};
+__export(precipitation_exports, {
+  precipitation: () => precipitation
+});
+module.exports = __toCommonJS(precipitation_exports);
+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 = {}) {
+    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)));
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  precipitation
+});

package/dist/modules/geometry/precipitation/precipitation.d.ts

@@ -0,0 +1,40 @@
+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 declare const precipitation: {
+    readonly name: "precipitation";
+    readonly bindingLayout: readonly [{
+        readonly name: "precipitation";
+        readonly group: 3;
+    }];
+    readonly uniformTypes: {
+        readonly time: "f32";
+        readonly fallSpeed: "f32";
+        readonly turbulence: "f32";
+        readonly seed: "f32";
+        readonly volumeCenter: "vec3<f32>";
+        readonly volumeSize: "vec3<f32>";
+        readonly wind: "vec2<f32>";
+    };
+    readonly defaultUniforms: {
+        readonly time: 0;
+        readonly fallSpeed: 20;
+        readonly turbulence: 0;
+        readonly seed: 29;
+        readonly volumeCenter: [0, 0, 150];
+        readonly volumeSize: [1200, 1600, 300];
+        readonly wind: [2, 0];
+    };
+    readonly getUniforms: (props?: PrecipitationProps) => Partial<PrecipitationUniforms>;
+    readonly vs: "\nlayout(std140) uniform precipitationUniforms {\n  float time;\n  float fallSpeed;\n  float turbulence;\n  float seed;\n  vec3 volumeCenter;\n  vec3 volumeSize;\n  vec2 wind;\n} precipitation;\nfloat precipitation_random(uint identifier) {\n  uint value = identifier + uint(precipitation.seed) * 747796405u;\n  value = (value ^ (value >> 16u)) * 2246822519u;\n  value = (value ^ (value >> 13u)) * 3266489917u;\n  value = value ^ (value >> 16u);\n  return float(value & 16777215u) / 16777216.0;\n}\nvec3 precipitation_getPosition(uint identifier) {\n  vec3 randomPosition = vec3(precipitation_random(identifier * 3u), precipitation_random(identifier * 3u + 1u), precipitation_random(identifier * 3u + 2u));\n  vec3 volumeSize = max(precipitation.volumeSize, vec3(0.001));\n  vec3 minimum = precipitation.volumeCenter - volumeSize * 0.5;\n  vec3 drift = vec3(precipitation.wind, -precipitation.fallSpeed) * precipitation.time;\n  vec3 position = mod(randomPosition * volumeSize + drift - minimum, volumeSize) + minimum;\n  position.xy += precipitation.turbulence * vec2(sin(precipitation.time * 0.9 + randomPosition.z * 31.0), cos(precipitation.time * 0.7 + randomPosition.x * 23.0));\n  return position;\n}\nfloat precipitation_getFade(vec3 position) {\n  vec3 edge = 0.5 - abs((position - precipitation.volumeCenter) / max(precipitation.volumeSize, vec3(0.001)));\n  return smoothstep(0.0, 0.08, min(edge.x, min(edge.y, edge.z)));\n}\n";
+    readonly source: "\nstruct precipitationUniforms {\n  time: f32,\n  fallSpeed: f32,\n  turbulence: f32,\n  seed: f32,\n  volumeCenter: vec3<f32>,\n  volumeSize: vec3<f32>,\n  wind: vec2<f32>,\n};\n@group(3) @binding(auto) var<uniform> precipitation: precipitationUniforms;\nfn precipitation_random(identifier: u32) -> f32 {\n  var value = identifier + u32(precipitation.seed) * 747796405u;\n  value = (value ^ (value >> 16u)) * 2246822519u;\n  value = (value ^ (value >> 13u)) * 3266489917u;\n  value = value ^ (value >> 16u);\n  return f32(value & 16777215u) / 16777216.0;\n}\nfn precipitation_getPosition(identifier: u32) -> vec3<f32> {\n  let randomPosition = vec3<f32>(precipitation_random(identifier * 3u), precipitation_random(identifier * 3u + 1u), precipitation_random(identifier * 3u + 2u));\n  let volumeSize = max(precipitation.volumeSize, vec3<f32>(0.001));\n  let minimum = precipitation.volumeCenter - volumeSize * 0.5;\n  let drift = vec3<f32>(precipitation.wind, -precipitation.fallSpeed) * precipitation.time;\n  let unwrapped = randomPosition * volumeSize + drift - minimum;\n  var position = unwrapped - floor(unwrapped / volumeSize) * volumeSize + minimum;\n  position.x += precipitation.turbulence * sin(precipitation.time * 0.9 + randomPosition.z * 31.0);\n  position.y += precipitation.turbulence * cos(precipitation.time * 0.7 + randomPosition.x * 23.0);\n  return position;\n}\nfn precipitation_getFade(position: vec3<f32>) -> f32 {\n  let edge = 0.5 - abs((position - precipitation.volumeCenter) / max(precipitation.volumeSize, vec3<f32>(0.001)));\n  return smoothstep(0.0, 0.08, min(edge.x, min(edge.y, edge.z)));\n}\n";
+};
+//# sourceMappingURL=precipitation.d.ts.map

package/dist/modules/geometry/precipitation/precipitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precipitation.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/precipitation/precipitation.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAEhE,6FAA6F;AAC7F,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;mCAqBL,kBAAkB;;;CAoEqC,CAAC"}

package/dist/modules/geometry/precipitation/precipitation.js

@@ -0,0 +1,95 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** 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 = {}) {
+        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)));
+}
+`
+};
+//# sourceMappingURL=precipitation.js.map

package/dist/modules/geometry/precipitation/precipitation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precipitation.js","sourceRoot":"","sources":["../../../../src/modules/geometry/precipitation/precipitation.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAe5D,6FAA6F;AAC7F,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAClD,YAAY,EAAE;QACZ,IAAI,EAAE,KAAK;QACX,SAAS,EAAE,KAAK;QAChB,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE,KAAK;QACX,YAAY,EAAE,WAAW;QACzB,UAAU,EAAE,WAAW;QACvB,IAAI,EAAE,WAAW;KAClB;IACD,eAAe,EAAE;QACf,IAAI,EAAE,CAAC;QACP,SAAS,EAAE,EAAE;QACb,UAAU,EAAE,CAAC;QACb,IAAI,EAAE,EAAE;QACR,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC;QACzB,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC;QAC7B,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;KACb;IACD,WAAW,CAAC,QAA4B,EAAE;QACxC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCpB;CAC2E,CAAC"}

package/dist/modules/geometry/sketch-stroke/sketch-stroke.cjs

@@ -0,0 +1,158 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sketch_stroke_exports = {};
+__export(sketch_stroke_exports, {
+  sketchStroke: () => sketchStroke
+});
+module.exports = __toCommonJS(sketch_stroke_exports);
+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;
+}
+`;
+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 = {}) {
+    return { ...defaults, ...props };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sketchStroke
+});

package/dist/modules/geometry/sketch-stroke/sketch-stroke.d.ts

@@ -0,0 +1,60 @@
+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;
+};
+/** Fragment coverage for geometry-anchored pencil strokes and solid architectural lines. */
+export declare const sketchStroke: {
+    readonly name: "sketchStroke";
+    readonly bindingLayout: readonly [{
+        readonly name: "sketchStroke";
+        readonly group: 3;
+    }];
+    readonly source: "\nstruct sketchStrokeUniforms {\n  width: f32,\n  jitter: f32,\n  variation: f32,\n  grain: f32,\n  offset: f32,\n  extension: f32,\n  sketch: f32,\n  minimumAntialias: f32,\n};\n@group(3) @binding(auto) var<uniform> sketchStroke: sketchStrokeUniforms;\nfn sketchStroke_noise(coordinate: f32) -> f32 {\n  let cell = floor(coordinate);\n  let fraction = fract(coordinate);\n  let first = fract(sin(cell * 127.1) * 43758.5453);\n  let second = fract(sin((cell + 1.0) * 127.1) * 43758.5453);\n  return mix(first, second, fraction * fraction * (3.0 - 2.0 * fraction));\n}\nfn sketchStroke_noise2(coordinate: vec2<f32>) -> f32 {\n  let cell = floor(coordinate);\n  var fraction = fract(coordinate);\n  fraction = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);\n  let first = fract(sin(dot(cell, vec2<f32>(127.1, 311.7))) * 43758.5453);\n  let second = fract(sin(dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n  let third = fract(sin(dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n  let fourth = fract(sin(dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n  return mix(mix(first, second, fraction.x), mix(third, fourth, fraction.x), fraction.y);\n}\nfn sketchStroke_getCoverage(coordinates: vec2<f32>, strokeLength: f32, seed: f32) -> f32 {\n  let along = coordinates.x;\n  let side = select(1.0, -1.0, sketchStroke_noise(seed * 29.0) < 0.5);\n  let center = (sketchStroke_noise(along * strokeLength / 36.0 + seed * 19.0) * 2.0 - 1.0) * sketchStroke.jitter * sketchStroke.sketch + side * sketchStroke.offset * sketchStroke.sketch;\n  let variation = mix(1.0, 0.55 + sketchStroke_noise(along * 31.0 + seed * 7.0) * 0.75, sketchStroke.variation * sketchStroke.sketch);\n  let grainCoordinates = vec2<f32>(along * strokeLength, coordinates.y) + vec2<f32>(seed * 17.0, seed * 53.0);\n  let coarseGrain = sketchStroke_noise2(grainCoordinates * 0.55);\n  let fineGrain = sketchStroke_noise2(grainCoordinates * 2.8);\n  let toothGrain = sketchStroke_noise2(grainCoordinates * 6.5);\n  let grainTexture = coarseGrain * 0.35 + fineGrain * 0.4 + toothGrain * 0.25;\n  let edgeRoughness = (grainTexture - 0.5) * sketchStroke.grain * sketchStroke.sketch * 0.7;\n  let radius = sketchStroke.width * 0.5 * variation + edgeRoughness;\n  let endDistance = max(-along, along - 1.0) * strokeLength - sketchStroke.extension;\n  let distance = max(abs(coordinates.y - center) - radius, endDistance);\n  let antialias = max(fwidth(distance), max(sketchStroke.minimumAntialias, 0.0001));\n  let coverage = 1.0 - smoothstep(-antialias * 0.5, antialias * 0.5, distance);\n  // Keep the pigment opaque; grain changes the stroke edge so the paper does not show through as white flecks.\n  return coverage;\n}\n";
+    readonly vs: "\nlayout(std140) uniform sketchStrokeUniforms {\n  float width;\n  float jitter;\n  float variation;\n  float grain;\n  float offset;\n  float extension;\n  float sketch;\n  float minimumAntialias;\n} sketchStroke;\n";
+    readonly fs: string;
+    readonly uniformTypes: {
+        readonly width: "f32";
+        readonly jitter: "f32";
+        readonly variation: "f32";
+        readonly grain: "f32";
+        readonly offset: "f32";
+        readonly extension: "f32";
+        readonly sketch: "f32";
+        readonly minimumAntialias: "f32";
+    };
+    readonly defaultUniforms: {
+        width: number;
+        jitter: number;
+        variation: number;
+        grain: number;
+        offset: number;
+        extension: number;
+        sketch: number;
+        minimumAntialias: number;
+    };
+    readonly getUniforms: (props?: SketchStrokeProps) => {
+        width: number;
+        jitter: number;
+        variation: number;
+        grain: number;
+        offset: number;
+        extension: number;
+        sketch: number;
+        minimumAntialias: number;
+    };
+};
+//# sourceMappingURL=sketch-stroke.d.ts.map

package/dist/modules/geometry/sketch-stroke/sketch-stroke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketch-stroke.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/sketch-stroke/sketch-stroke.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAmHF,4FAA4F;AAC5F,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAiBJ,iBAAiB;eApJ5B,MAAM;gBAEL,MAAM;mBAEH,MAAM;eAEV,MAAM;gBAEL,MAAM;mBAEH,MAAM;gBAET,MAAM;0BAEI,MAAM;;CAyI4C,CAAC"}