@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/modules/postprocessing/image-fun-filters/hexagonalpixelate.d.ts

@@ -9,12 +9,15 @@ export type HexagonalPixelateProps = {
     /** The width of an individual tile, in pixels. */
     scale?: number;
 };
+export type HexagonalPixelateUniforms = HexagonalPixelateProps;
 /**
  * Hexagonal Pixelate
  * Renders the image using a pattern of hexagonal tiles. Tile colors
  * are nearest-neighbor sampled from the centers of the tiles.
  */
 export declare const hexagonalPixelate: {
+    readonly props: HexagonalPixelateProps;
+    readonly uniforms: HexagonalPixelateUniforms;
     readonly name: "hexagonalPixelate";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
@@ -32,7 +35,7 @@ export declare const hexagonalPixelate: {
             readonly softMax: 50;
         };
     };
-    readonly fs: string;
+    readonly fs: "uniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n";
     readonly passes: [{
         readonly sampler: true;
     }];

package/dist/modules/postprocessing/image-fun-filters/hexagonalpixelate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;CAYiD,CAAC"}
+{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAmDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;oBACf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;CAaoC,CAAC"}

package/dist/modules/postprocessing/image-fun-filters/hexagonalpixelate.js

@@ -1,42 +1,48 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform hexagonalPixelateUniforms {
-vec2 center;
-float scale;
+  vec2 center;
+  float scale;
 } hexagonalPixelate;
+
 vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
-tex.y /= 0.866025404;
-tex.x -= tex.y * 0.5;
-vec2 a;
-if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
-a = vec2(floor(tex.x), floor(tex.y));
-}
-else a = vec2(ceil(tex.x), ceil(tex.y));
-vec2 b = vec2(ceil(tex.x), floor(tex.y));
-vec2 c = vec2(floor(tex.x), ceil(tex.y));
-vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
-vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
-vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
-vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
-float alen = length(TEX - A);
-float blen = length(TEX - B);
-float clen = length(TEX - C);
-vec2 choice;
-if (alen < blen) {
-if (alen < clen) choice = a;
-else choice = c;
-} else {
-if (blen < clen) choice = b;
-else choice = c;
-}
-choice.x += choice.y * 0.5;
-choice.y *= 0.866025404;
-choice *= hexagonalPixelate.scale / texSize;
-return texture(source, choice + hexagonalPixelate.center);
+  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
+  tex.y /= 0.866025404;
+  tex.x -= tex.y * 0.5;
+
+  vec2 a;
+  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
+    a = vec2(floor(tex.x), floor(tex.y));
+  }
+  else a = vec2(ceil(tex.x), ceil(tex.y));
+  vec2 b = vec2(ceil(tex.x), floor(tex.y));
+  vec2 c = vec2(floor(tex.x), ceil(tex.y));
+
+  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
+  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
+  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
+
+  float alen = length(TEX - A);
+  float blen = length(TEX - B);
+  float clen = length(TEX - C);
+
+  vec2 choice;
+  if (alen < blen) {
+    if (alen < clen) choice = a;
+    else choice = c;
+  } else {
+    if (blen < clen) choice = b;
+    else choice = c;
+  }
+
+  choice.x += choice.y * 0.5;
+  choice.y *= 0.866025404;
+  choice *= hexagonalPixelate.scale / texSize;
+
+  return texture(source, choice + hexagonalPixelate.center);
 }
 `;
 /**
@@ -45,6 +51,8 @@ return texture(source, choice + hexagonalPixelate.center);
  * are nearest-neighbor sampled from the centers of the tiles.
  */
 export const hexagonalPixelate = {
+    props: {},
+    uniforms: {},
     name: 'hexagonalPixelate',
     uniformTypes: {
         center: 'vec2<f32>',

package/dist/modules/postprocessing/image-fun-filters/ink.d.ts

@@ -11,6 +11,7 @@ export type InkProps = {
      */
     strength?: number;
 };
+export type InkUniforms = InkProps;
 /**
  * Ink -
  * Simulates outlining the image in ink by darkening edges stronger than a
@@ -18,7 +19,10 @@ export type InkProps = {
  * copies of the image, each blurred using a blur of a different radius.
  */
 export declare const ink: {
+    readonly props: InkProps;
+    readonly uniforms: InkUniforms;
     readonly name: "ink";
+    readonly fs: "uniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n";
     readonly uniformTypes: {
         readonly strength: "f32";
     };
@@ -29,7 +33,6 @@ export declare const ink: {
             readonly softMax: 1;
         };
     };
-    readonly fs: string;
     readonly passes: [{
         readonly sampler: true;
     }];

package/dist/modules/postprocessing/image-fun-filters/ink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/ink.ts"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;CAUmC,CAAC"}
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/ink.ts"],"names":[],"mappings":"AAoCA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,GAAG;oBACD,QAAQ;uBACL,WAAW;;;;;;;;;;;;;;;;CAYsB,CAAC"}

package/dist/modules/postprocessing/image-fun-filters/ink.js

@@ -1,33 +1,33 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform inkUniforms {
-float strength;
+  float strength;
 } ink;
+
 vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 dx = vec2(1.0 / texSize.x, 0.0);
-vec2 dy = vec2(0.0, 1.0 / texSize.y);
-vec4 color = texture(source, texCoord);
-float bigTotal = 0.0;
-float smallTotal = 0.0;
-vec3 bigAverage = vec3(0.0);
-vec3 smallAverage = vec3(0.0);
-for (float x = -2.0; x <= 2.0; x += 1.0) {
-for (float y = -2.0; y <= 2.0; y += 1.0) {
-vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
-bigAverage += offsetColor;
-bigTotal += 1.0;
-if (abs(x) + abs(y) < 2.0) {
-smallAverage += offsetColor;
-smallTotal += 1.0;
-}
-}
-}
-vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
-float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
-return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
+  vec2 dx = vec2(1.0 / texSize.x, 0.0);
+  vec2 dy = vec2(0.0, 1.0 / texSize.y);
+  vec4 color = texture(source, texCoord);
+  float bigTotal = 0.0;
+  float smallTotal = 0.0;
+  vec3 bigAverage = vec3(0.0);
+  vec3 smallAverage = vec3(0.0);
+  for (float x = -2.0; x <= 2.0; x += 1.0) {
+    for (float y = -2.0; y <= 2.0; y += 1.0) {
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
+      bigTotal += 1.0;
+      if (abs(x) + abs(y) < 2.0) {
+        smallAverage += offsetColor;
+        smallTotal += 1.0;
+      }
+    }
+  }
+  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
+  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
 }
 `;
 /**
@@ -37,13 +37,15 @@ return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
  * copies of the image, each blurred using a blur of a different radius.
  */
 export const ink = {
+    props: {},
+    uniforms: {},
     name: 'ink',
+    fs,
     uniformTypes: {
         strength: 'f32'
     },
     uniformPropTypes: {
         strength: { value: 0.25, min: 0, softMax: 1 }
     },
-    fs,
     passes: [{ sampler: true }]
 };

package/dist/modules/postprocessing/image-fun-filters/magnify.d.ts

@@ -13,6 +13,7 @@ export type MagnifyProps = {
     /** border color of the effect circle. Default value is `[255, 255, 255, 255]`. */
     borderColor?: number[];
 };
+export type MagnifyUniforms = MagnifyProps;
 /**
  * Magnify - display a circle with magnify effect applied to surrounding the pixels given position
  */
@@ -36,7 +37,7 @@ export declare const magnify: {
             readonly value: readonly [255, 255, 255, 255];
         };
     };
-    readonly fs: string;
+    readonly fs: "uniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n";
     readonly passes: [{
         readonly sampler: true;
     }];

package/dist/modules/postprocessing/image-fun-filters/magnify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AA8BA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAmBuC,CAAC"}
+{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAmBuC,CAAC"}

package/dist/modules/postprocessing/image-fun-filters/magnify.js

@@ -1,25 +1,26 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform magnifyUniforms {
-vec2 screenXY;
-float radiusPixels;
-float zoom;
-float borderWidthPixels;
-vec4 borderColor;
+  vec2 screenXY;
+  float radiusPixels;
+  float zoom;
+  float borderWidthPixels;
+  vec4 borderColor;
 } magnify;
+
 vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
-float dist = distance(texCoord * texSize, pos * texSize);
-if (dist < magnify.radiusPixels) {
-return texture(source, (texCoord - pos) / magnify.zoom + pos);
-}
-if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
-return magnify.borderColor;
-}
-return texture(source, texCoord);
+  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
+  float dist = distance(texCoord * texSize, pos * texSize);
+  if (dist < magnify.radiusPixels) {
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
+  }
+
+  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
+    return magnify.borderColor;
+  }
+  return texture(source, texCoord);
 }
 `;
 /**

package/dist/modules/postprocessing/image-warp-filters/bulgepinch.d.ts

@@ -7,18 +7,21 @@ export type BulgePinchProps = {
     /** strength -1 to 1 (-1 is strong pinch, 0 is no effect, 1 is strong bulge) */
     strength?: number;
 };
+export type BulgePinchUniforms = BulgePinchProps;
 /**
  * Bulge / Pinch -
  * Bulges or pinches the image in a circle.
  */
 export declare const bulgePinch: {
+    readonly props: BulgePinchProps;
+    readonly uniforms: BulgePinchUniforms;
     readonly name: "bulgePinch";
     readonly dependencies: [{
         readonly name: "warp";
         readonly passes: [];
-        readonly fs: string;
+        readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n";
     }];
-    readonly fs: string;
+    readonly fs: "uniform bulgePinchUniforms {\n  float radius;\n  float strength;\n  vec2 center;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
         readonly radius: "f32";

package/dist/modules/postprocessing/image-warp-filters/bulgepinch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAsCA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe0C,CAAC"}
+{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAqCA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU;oBACR,eAAe;uBACZ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB6B,CAAC"}

package/dist/modules/postprocessing/image-warp-filters/bulgepinch.js

@@ -1,32 +1,34 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 import { warp } from "./warp.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform bulgePinchUniforms {
-float radius;
-float strength;
-vec2 center;
+  float radius;
+  float strength;
+  vec2 center;
 } bulgePinch;
+
 vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
-coord -= texCenter;
-float distance = length(coord);
-if (distance < bulgePinch.radius) {
-float percent = distance / bulgePinch.radius;
-if (bulgePinch.strength > 0.0) {
-coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
-} else {
-coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
-}
-}
-coord += texCenter;
-return coord;
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < bulgePinch.radius) {
+    float percent = distance / bulgePinch.radius;
+    if (bulgePinch.strength > 0.0) {
+      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
+    } else {
+      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
+    }
+  }
+  coord += texCenter;
+  return coord;
 }
+
 vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 coord = texCoord * texSize;
-coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
-return warp_sampleColor(source, texSize, coord);
+  vec2 coord = texCoord * texSize;
+  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
+
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
 /**
@@ -34,6 +36,8 @@ return warp_sampleColor(source, texSize, coord);
  * Bulges or pinches the image in a circle.
  */
 export const bulgePinch = {
+    props: {},
+    uniforms: {},
     name: 'bulgePinch',
     dependencies: [warp],
     fs,

package/dist/modules/postprocessing/image-warp-filters/swirl.d.ts

@@ -9,17 +9,20 @@ export type SwirlProps = {
     /** The angle in radians that the pixels in the center of the circular region will be rotated by. */
     angle?: number;
 };
+export type SwirlUniforms = SwirlProps;
 /**
  * Warps a circular region of the image in a swirl.
  */
 export declare const swirl: {
+    readonly props: SwirlProps;
+    readonly uniforms: SwirlProps;
     readonly name: "swirl";
     readonly dependencies: [{
         readonly name: "warp";
         readonly passes: [];
-        readonly fs: string;
+        readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n";
     }];
-    readonly fs: string;
+    readonly fs: "uniform swirlUniforms {\n  float radius;\n  float angle;\n  vec2 center;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
         readonly radius: "f32";

package/dist/modules/postprocessing/image-warp-filters/swirl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeqC,CAAC"}
+{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AAuCA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,KAAK;oBACH,UAAU;uBACP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB2B,CAAC"}

package/dist/modules/postprocessing/image-warp-filters/swirl.js

@@ -1,40 +1,44 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 import { warp } from "./warp.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform swirlUniforms {
-float radius;
-float angle;
-vec2 center;
+  float radius;
+  float angle;
+  vec2 center;
 } swirl;
+
 vec2 swirl_warp(vec2 coord, vec2 texCenter) {
-coord -= texCenter;
-float distance = length(coord);
-if (distance < swirl.radius) {
-float percent = (swirl.radius - distance) / swirl.radius;
-float theta = percent * percent * swirl.angle;
-float s = sin(theta);
-float c = cos(theta);
-coord = vec2(
-coord.x * c - coord.y * s,
-coord.x * s + coord.y * c
-);
-}
-coord += texCenter;
-return coord;
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < swirl.radius) {
+    float percent = (swirl.radius - distance) / swirl.radius;
+    float theta = percent * percent * swirl.angle;
+    float s = sin(theta);
+    float c = cos(theta);
+    coord = vec2(
+      coord.x * c - coord.y * s,
+      coord.x * s + coord.y * c
+    );
+  }
+  coord += texCenter;
+  return coord;
 }
+
 vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 coord = texCoord * texSize;
-coord = swirl_warp(coord, swirl.center * texSize);
-return warp_sampleColor(source, texSize, coord);
+  vec2 coord = texCoord * texSize;
+  coord = swirl_warp(coord, swirl.center * texSize);
+
+  return warp_sampleColor(source, texSize, coord);
 }
 `;
 /**
  * Warps a circular region of the image in a swirl.
  */
 export const swirl = {
+    props: {},
+    uniforms: {},
     name: 'swirl',
     dependencies: [warp],
     fs,

package/dist/modules/postprocessing/image-warp-filters/warp.d.ts

@@ -1,7 +1,8 @@
 export type WarpProps = {};
+export type WarpUniforms = WarpProps;
 export declare const warp: {
     readonly name: "warp";
     readonly passes: [];
-    readonly fs: string;
+    readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n";
 };
 //# sourceMappingURL=warp.d.ts.map

package/dist/modules/postprocessing/image-warp-filters/warp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AAoBA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,eAAO,MAAM,IAAI;;;;CAIoC,CAAC"}
+{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAErC,eAAO,MAAM,IAAI;;;;CAIoC,CAAC"}

package/dist/modules/postprocessing/image-warp-filters/warp.js

@@ -1,15 +1,16 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
-vec4 color = texture(source, coord / texSize);
-vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
-if (coord != clampedCoord) {
-color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
-}
-return color;
+  vec4 color = texture(source, coord / texSize);
+  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
+  if (coord != clampedCoord) {
+    /* fade to transparent if we are outside the image */
+    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
+  }
+
+  return color;
 }
 `;
 export const warp = {

package/dist/modules-webgl1/geometry/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../src/modules-webgl1/geometry/geometry.ts"],"names":[],"mappings":"AAkCA;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../src/modules-webgl1/geometry/geometry.ts"],"names":[],"mappings":"AAiCA;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

package/dist/modules-webgl1/geometry/geometry.js

@@ -1,27 +1,31 @@
 // import {ShaderModule} from '../../types';
-import { glsl } from "../../lib/glsl-utils/highlight.js";
 // TODO - reuse normal from geometry module
-const vs = `\
+const vs = /* glsl */ `\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
+
 void geometry_setNormal(vec3 normal) {
-geometry_vNormal = normal;
+  geometry_vNormal = normal;
 }
+
 void geometry_setPosition(vec4 position) {
-geometry_vPosition = position;
+  geometry_vPosition = position;
 }
+
 void geometry_setPosition(vec3 position) {
-geometry_vPosition = vec4(position, 1.);
+  geometry_vPosition = vec4(position, 1.);
 }
 `;
-const fs = `\
+const fs = /* glsl */ `\
 varying vec4 geometry_vPosition;
 varying vec3 geometry_vNormal;
+
 vec4 geometry_getPosition() {
-return geometry_vPosition;
+  return geometry_vPosition;
 }
+
 vec3 geometry_getNormal() {
-return geometry_vNormal;
+  return geometry_vNormal;
 }
 `;
 /**

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts

@@ -1,7 +1,7 @@
 import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
-import type { NumberArray } from "../../../types.js";
+import type { NumericArray } from "../../../types.js";
 export type DirlightOptions = {
-    lightDirection?: NumberArray;
+    lightDirection?: NumericArray;
 };
 /**
  * Cheap lighting - single directional light, single dot product, one uniform

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,KAAK,EAAC,WAAW,EAAC,0BAAuB;AAKhD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,WAAW,CAAC;CAC9B,CAAC;AA4BF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC"}
+{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AACtE,OAAO,KAAK,EAAC,YAAY,EAAC,0BAAuB;AAKjD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B,CAAC;AA4BF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC"}

package/dist/modules-webgl1/lighting/dirlight/dirlight.js

@@ -1,7 +1,6 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 import { project } from "../../project/project.js";
 const DEFAULT_MODULE_OPTIONS = {
     lightDirection: new Float32Array([1, 1, 2])
@@ -14,12 +13,16 @@ function getUniforms(opts = DEFAULT_MODULE_OPTIONS) {
     }
     return uniforms;
 }
-const fs = `\
+const fs = /* glsl */ `\
 uniform vec3 dirlight_uLightDirection;
+
+/*
+ * Returns color attenuated by angle from light source
+ */
 vec4 dirlight_filterColor(vec4 color) {
-vec3 normal = project_getNormal_World();
-float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
-return vec4(color.rgb * d, color.a);
+  vec3 normal = project_getNormal_World();
+  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
+  return vec4(color.rgb * d, color.a);
 }
 `;
 /**

package/dist/modules-webgl1/lighting/lights/lights-glsl.d.ts

@@ -1,2 +1,2 @@
-export declare const lightingShader: string;
+export declare const lightingShader = "#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n\n // Constant-Linear-Exponential\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n";
 //# sourceMappingURL=lights-glsl.d.ts.map

package/dist/modules-webgl1/lighting/lights/lights-glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lights-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights-glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,QAmC1B,CAAC"}
+{"version":3,"file":"lights-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,w2BAmC1B,CAAC"}