@matboks/utilities 0.0.1

package/dist/shader-modules/modules/sdf/index.js

@@ -0,0 +1,183 @@
+export const sdfDefinition = /*glsl*/ `
+
+import { barycentric, transformToZAxis, rotate } from "@/geometry";
+import { lerp, signed, dot2 } from "@/utils";
+import { PI } from "@/constants";
+
+export {
+  sphere, box, rectangularCylinder, 
+  discoBall, donut, boxFrame,
+  triangleSDFSquared, meshSDF, regularPolygon,
+  polygon, lineSegment
+}
+
+float sphere(vec3 p, vec3 center, float radius) {
+  return length(p - center) - radius;
+}
+
+float box(vec3 p, vec3 center, vec3 direction, vec3 size) {
+  p = transformToZAxis(p, center, direction, 0.0);
+  p = abs(p) - size/2.0;
+
+  // First part gives distance inside box, second part outside
+  return min(max(max(p.x, p.y), p.z), 0.0) + length(max(p, vec3(0)));
+}
+
+float rectangularCylinder(vec3 p, vec3 center, vec3 direction, vec2 size, float height, bool offsetCenter, float rotation) {
+  if (offsetCenter) center += 0.5*height*normalize(direction);
+  p = transformToZAxis(p, center, direction, rotation);
+  return box(p, vec3(0), vec3(0, 0, 1), vec3(size, height));
+}
+
+float discoBall(vec3 p, vec3 center, float radius, float n, float o) {
+  p -= center;
+  float phi = -PI + 2.0*PI*(round(lerp(atan(p.y, p.x), -PI, PI)*n)/n + o);
+  float theta = PI*(round(lerp(acos(p.z/length(p)), 0.0, PI)*n)/n + o);
+
+  vec3 bp = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));
+
+  return dot(bp, p - radius*bp);
+}
+
+float discoBall(vec3 p, vec3 center, float radius, float n) {
+  return discoBall(p, center, radius, n, 0.0);
+}
+
+float regularPolygon(vec2 p, float radius, float n) {
+  float theta = PI*signed((floor(lerp(atan(p.y, p.x), -PI, PI)*n) + .5)/n);
+  vec2 pp = vec2(cos(theta), sin(theta));
+  return dot(pp, p - radius*pp);
+}
+
+float polygon(vec2 p, sampler2D vertices, int startIndex, int endIndex, int total) {
+  float nf = float(total);
+  float sf = float(startIndex);
+  float ef = float(endIndex);
+  float minDistSquared = 1e9;
+  float textureStep = 1.0 / nf;
+  float winding = 0.0;   // >0 → inside for CCW, <0 → inside for CW
+
+  vec2 start = texture(vertices, vec2((sf + 0.5) * textureStep, 0.5)).xy;
+
+  for (float i = sf + 1.0; i <= ef; i++) {
+    float idx = mod(i + 0.5, nf); 
+    vec2 end = texture(vertices, vec2(idx * textureStep, 0.5)).xy;
+
+    // Distance to segment (start to end)
+    vec2 seg = end - start;
+    vec2 rel = p - start;
+    float t = clamp(dot(rel, seg) / dot(seg, seg), 0.0, 1.0);
+    float d2 = dot2(rel - seg*t);
+    minDistSquared = min(minDistSquared, d2);
+
+    // Portion for finding out if point is inside polygon
+    // Equivalent to classic point-in-polygon test:
+    // Does segment cross horizontal ray to the right of p?
+    bool aboveA = start.y > p.y;
+    bool aboveB = end.y > p.y;
+    // Sign: +1 when edge crosses in one direction, -1 in the opposite
+    if (aboveA != aboveB) {
+      float xCross = (end.x - start.x) * (p.y - start.y) / (end.y - start.y) + start.x;
+      if (xCross > p.x) {
+        winding += aboveB ? -1.0 : 1.0;
+      }
+    }
+
+    start = end;
+  }
+
+  float signValue = (winding == 0.0 ? 1.0 : -1.0);
+  return signValue * sqrt(minDistSquared);
+}
+
+
+float donut(vec3 p, vec3 center, vec3 direction, float innerRadius, float outerRadius, float rotation, float sections, float sides) {
+  p = transformToZAxis(p, center, direction, 0.0);
+
+  vec3 xy = normalize(vec3(p.xy, 0));
+  float angle = mod(atan(xy.y, xy.x), 2.*PI);
+
+  angle = 2.*PI*round(sections*angle/(2.*PI))/sections;
+  innerRadius *= sqrt(PI/(sections*tan(PI/sections)));
+  outerRadius *= sqrt(PI/(sides*tan(PI/sides)));
+  return regularPolygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + 0.25*PI), outerRadius, sides);
+}
+
+float boxFrame(vec3 p, vec3 center, vec3 direction, vec3 size, float thickness) {
+  float dBox = box(p, center, direction, size);
+
+  p = transformToZAxis(p, center, direction, 0.0);
+
+  vec3 o = 2.0*vec3(thickness, thickness, -1e9);
+  float dX = box(p, vec3(0), vec3(1, 0, 0), size.yzx - o);
+  float dY = box(p, vec3(0), vec3(0, 1, 0), size.zxy - o);
+  float dZ = box(p, vec3(0), vec3(0, 0, 1), size.xyz - o);
+
+  float dInner = min(dX, min(dY, dZ));
+  return max(dBox, -dInner);
+}
+
+// x is distance squared, y indicates which side of triangle p is on 
+// (relative to normal: positive if p is above, negative if below)
+vec2 triangleSDFSquared(vec3 p, vec3 a, vec3 b, vec3 c) {
+  vec3 ab = b - a;
+  vec3 ca = a - c;
+  vec3 bc = c - b;
+
+  vec3 ap = p - a;
+  vec3 bp = p - b;
+  vec3 cp = p - c;
+
+  vec3 normal = normalize(cross(ab, -ca)); // Negate to make cross(ab, ac), follows right-hand rule assuming abc is CCW
+  
+  bool isInsideTriangle = all(greaterThan(barycentric(p, a, b, c), vec3(0)));
+  bool isInsideXYProjection = abs(normal.z) > 1e-5 && all(greaterThan(barycentric(p.xy, a.xy, b.xy, c.xy), vec3(0)));
+
+  float distSquared;
+  bool isAboveXYProjection;
+
+  // If p is above XY projection, then dist = dot(ap, normal) > 0 when normal points upwards
+  // and dist < 0 when it points downwards. sign(normal.z)*dist > 0.0 then tells us if p is above 
+  if (isInsideTriangle) {
+    float dist = dot(ap, normal);
+    distSquared = dist*dist;
+    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dist > 0.0;
+  } else {
+    distSquared = min(min(
+      dot2(ap - ab*clamp(dot(ap, ab) / dot2(ab), 0.0, 1.0)),
+      dot2(bp - bc*clamp(dot(bp, bc) / dot2(bc), 0.0, 1.0))),
+      dot2(cp - ca*clamp(dot(cp, ca) / dot2(ca), 0.0, 1.0))
+    );
+    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dot(ap, normal) > 0.0;
+  }
+
+  return vec2(distSquared, isAboveXYProjection ? -1.0 : 1.0);
+}
+
+float lineSegment(vec2 p, vec2 a, vec2 b, float o) {
+  vec2 ap = p - a;
+  vec2 ab = b - a;
+  
+  float t = clamp(dot(ap, ab)/dot(ab, ab), 0.0, 1.0);
+
+  return length(ap - ab*t) - o;
+}
+
+float lineSegment(vec2 p, vec2 a, vec2 b) {
+  return lineSegment(p, a, b, 0.0);
+}
+
+float lineSegment(vec3 p, vec2 a, vec2 b, float o) {
+  vec3 ap = p - a;
+  vec3 ab = b - a;
+  
+  float t = clamp(dot(ap, ab)/dot(ab, ab), 0.0, 1.0);
+
+  return length(ap - ab*t) - o;
+}
+
+float lineSegment(vec3 p, vec2 a, vec2 b) {
+  return lineSegment(p, a, b, 0.0);
+}
+
+`;

package/dist/shader-modules/modules/sdf/operations.d.ts

@@ -0,0 +1 @@
+export declare const operationsDefinition = "\nimport { tile } from \"@/utils\";\n\nexport {\n  sdfNormal,\n  combine, intersect, subtract, xor,\n  smoothCombine, smoothIntersect, smoothSubtract, smoothXOR,\n  repeatGrid\n}\n\nconst float DEFAULT_SMOOTH = 0.2;\n\nvec3 sdfNormal(vec3 p, float sdf(vec3), float h) {\n  vec2 o = vec2(1, -1)*h;\n  return normalize( \n    o.xyy*sdf(p + o.xyy) +                     \n    o.yyx*sdf(p + o.yyx) + \n    o.yxy*sdf(p + o.yxy) + \n    o.xxx*sdf(p + o.xxx)\n  );\n}\n\nfloat combine(float a, float b) {\n  return min(a, b);\n}\n\nfloat intersect(float a, float b) {\n  return max(a, b);\n}\n\nfloat subtract(float a, float b) {\n  return max(a, -b);\n}\n\nfloat xor(float a, float b) {\n  return subtract(combine(a, b), intersect(a, b));\n}\n\n\nfloat smoothCombine(float d1, float d2, float k) {\n  float h = clamp(0.5 + 0.5*(d2 - d1)/k, 0.0, 1.0);\n  return mix(d2, d1, h) - k*h*(1.0 - h);\n}\n\nfloat smoothCombine(float d1, float d2) {\n  return smoothCombine(d1, d2, DEFAULT_SMOOTH);\n}\n\nfloat smoothIntersect(float d1, float d2, float k) {\n  return -smoothCombine(-d1, -d2, k);\n}\n\nfloat smoothIntersect(float d1, float d2) {\n  return smoothIntersect(d1, d2, DEFAULT_SMOOTH);\n}\n\nfloat smoothSubtract(float d1, float d2, float k) {\n  return -smoothCombine(-d1, d2, k);\n}\n\nfloat smoothSubtract(float d1, float d2) {\n  return smoothSubtract(d1, d2, DEFAULT_SMOOTH);\n}\n\nfloat smoothXOR(float d1, float d2, float k) {\n  return smoothSubtract(smoothCombine(d1, d2, k), smoothIntersect(d1, d2, k), k);\n}\n\nfloat smoothXOR(float d1, float d2) {\n  return smoothXOR(d1, d2, DEFAULT_SMOOTH);\n}\n\nfloat repeatGrid(vec3 p, float size, float sdf(vec3)) {\n  return size*sdf(tile(p, size)/size);\n}\n\n";

package/dist/shader-modules/modules/sdf/operations.js

@@ -0,0 +1,77 @@
+export const operationsDefinition = /*glsl*/ `
+import { tile } from "@/utils";
+
+export {
+  sdfNormal,
+  combine, intersect, subtract, xor,
+  smoothCombine, smoothIntersect, smoothSubtract, smoothXOR,
+  repeatGrid
+}
+
+const float DEFAULT_SMOOTH = 0.2;
+
+vec3 sdfNormal(vec3 p, float sdf(vec3), float h) {
+  vec2 o = vec2(1, -1)*h;
+  return normalize( 
+    o.xyy*sdf(p + o.xyy) +                     
+    o.yyx*sdf(p + o.yyx) + 
+    o.yxy*sdf(p + o.yxy) + 
+    o.xxx*sdf(p + o.xxx)
+  );
+}
+
+float combine(float a, float b) {
+  return min(a, b);
+}
+
+float intersect(float a, float b) {
+  return max(a, b);
+}
+
+float subtract(float a, float b) {
+  return max(a, -b);
+}
+
+float xor(float a, float b) {
+  return subtract(combine(a, b), intersect(a, b));
+}
+
+
+float smoothCombine(float d1, float d2, float k) {
+  float h = clamp(0.5 + 0.5*(d2 - d1)/k, 0.0, 1.0);
+  return mix(d2, d1, h) - k*h*(1.0 - h);
+}
+
+float smoothCombine(float d1, float d2) {
+  return smoothCombine(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothIntersect(float d1, float d2, float k) {
+  return -smoothCombine(-d1, -d2, k);
+}
+
+float smoothIntersect(float d1, float d2) {
+  return smoothIntersect(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothSubtract(float d1, float d2, float k) {
+  return -smoothCombine(-d1, d2, k);
+}
+
+float smoothSubtract(float d1, float d2) {
+  return smoothSubtract(d1, d2, DEFAULT_SMOOTH);
+}
+
+float smoothXOR(float d1, float d2, float k) {
+  return smoothSubtract(smoothCombine(d1, d2, k), smoothIntersect(d1, d2, k), k);
+}
+
+float smoothXOR(float d1, float d2) {
+  return smoothXOR(d1, d2, DEFAULT_SMOOTH);
+}
+
+float repeatGrid(vec3 p, float size, float sdf(vec3)) {
+  return size*sdf(tile(p, size)/size);
+}
+
+`;

package/dist/shader-modules/modules/utils.d.ts

@@ -0,0 +1 @@
+export declare const utilsDefinition = "\n\nimport { EPS } from \"@/constants\";\nimport { rotate } from \"@/geometry\";\n\nexport {\n  aastep,\n  triangleWave,\n  lerp,\n  signed,\n  tile,\n  dot2,\n  smoothsteps,\n  triplanarTexture\n}\n\nfloat aastep(float threshold, float value) {\n  float d = length(vec2(dFdx(value), dFdy(value))) * 0.707;\n  return smoothstep(-d, d, value - threshold);\n}\n\nfloat triangleWave(float p) {\n  return 2.*abs(p - floor(p + .5));\n}\n\nfloat triangleWave(vec2 p) {\n  return triangleWave(p.x);\n}\n\nfloat triangleWave(vec2 p, float o) {\n  return triangleWave(rotate(p, o));\n}\n\nfloat lerp(float x, float a, float b) {\n  return clamp((x - a)/(b - a), 0.0, 1.0);\n}\n\nfloat signed(float t) {\n  return -1.0 + 2.0*t;\n}\n\nvec2 signed(vec2 t) {\n  return -1.0 + 2.0*t;\n}\n\nvec3 signed(vec3 t) {\n  return -1.0 + 2.0*t;\n}\n\nvec4 signed(vec4 t) {\n  return -1.0 + 2.0*t;\n}\n\nfloat tile(float p, float s) {\n  return mod(p, 2.0*s) - s;\n}\n\nvec2 tile(vec2 p, vec2 s) {\n  return mod(p, 2.0*s) - s;\n}\n\nvec2 tile(vec2 p, float s) {\n  return tile(p, vec2(s));\n}\n\nvec3 tile(vec3 p, vec3 s) {\n  return mod(p, 2.0*s) - s;\n}\n\nvec3 tile(vec3 p, float s) {\n  return tile(p, vec3(s));\n}\n\nvec4 tile(vec4 p, vec4 s) {\n  return mod(p, 2.0*s) - s;\n}\n\nvec4 tile(vec4 p, float s) {\n  return tile(p, vec4(s));\n}\n\nfloat dot2(vec2 v) {\n  return dot(v, v);\n}\n\nfloat dot2(vec3 v) {\n  return dot(v, v);\n}\n\nfloat dot2(vec4 v) {\n  return dot(v, v);\n}\n\nfloat smoothsteps(float t, int steps, float flatness) {\n  if (t < 0.0) return 0.0;\n  if (t > 1.0) return 1.0;\n\n  float sf = float(steps);\n  float value;\n  if (flatness == 1.0) {\n    value = floor(t*(sf + 1.0))/sf;\n  } else {\n    float l = 1.0/sf*(1.0 - flatness/(sf + 1.0));\n    value = (floor(t/l) + smoothstep(flatness, 1.0, fract(t/l)))/sf;\n  }\n  return clamp(value, 0.0, 1.0); \n}\n\nfloat triplanarTexture(vec3 p, vec3 normal, float power, float texture(vec2)) {\n  vec3 w = pow(abs(normal), vec3(power));\n  vec3 v = vec3(texture(p.yz), texture(p.xz), texture(p.xy));\n  return dot(w, v) / dot(w, vec3(1));\n}\n\n";

package/dist/shader-modules/modules/utils.js

@@ -0,0 +1,115 @@
+export const utilsDefinition = /*glsl*/ `
+
+import { EPS } from "@/constants";
+import { rotate } from "@/geometry";
+
+export {
+  aastep,
+  triangleWave,
+  lerp,
+  signed,
+  tile,
+  dot2,
+  smoothsteps,
+  triplanarTexture
+}
+
+float aastep(float threshold, float value) {
+  float d = length(vec2(dFdx(value), dFdy(value))) * 0.707;
+  return smoothstep(-d, d, value - threshold);
+}
+
+float triangleWave(float p) {
+  return 2.*abs(p - floor(p + .5));
+}
+
+float triangleWave(vec2 p) {
+  return triangleWave(p.x);
+}
+
+float triangleWave(vec2 p, float o) {
+  return triangleWave(rotate(p, o));
+}
+
+float lerp(float x, float a, float b) {
+  return clamp((x - a)/(b - a), 0.0, 1.0);
+}
+
+float signed(float t) {
+  return -1.0 + 2.0*t;
+}
+
+vec2 signed(vec2 t) {
+  return -1.0 + 2.0*t;
+}
+
+vec3 signed(vec3 t) {
+  return -1.0 + 2.0*t;
+}
+
+vec4 signed(vec4 t) {
+  return -1.0 + 2.0*t;
+}
+
+float tile(float p, float s) {
+  return mod(p, 2.0*s) - s;
+}
+
+vec2 tile(vec2 p, vec2 s) {
+  return mod(p, 2.0*s) - s;
+}
+
+vec2 tile(vec2 p, float s) {
+  return tile(p, vec2(s));
+}
+
+vec3 tile(vec3 p, vec3 s) {
+  return mod(p, 2.0*s) - s;
+}
+
+vec3 tile(vec3 p, float s) {
+  return tile(p, vec3(s));
+}
+
+vec4 tile(vec4 p, vec4 s) {
+  return mod(p, 2.0*s) - s;
+}
+
+vec4 tile(vec4 p, float s) {
+  return tile(p, vec4(s));
+}
+
+float dot2(vec2 v) {
+  return dot(v, v);
+}
+
+float dot2(vec3 v) {
+  return dot(v, v);
+}
+
+float dot2(vec4 v) {
+  return dot(v, v);
+}
+
+float smoothsteps(float t, int steps, float flatness) {
+  if (t < 0.0) return 0.0;
+  if (t > 1.0) return 1.0;
+
+  float sf = float(steps);
+  float value;
+  if (flatness == 1.0) {
+    value = floor(t*(sf + 1.0))/sf;
+  } else {
+    float l = 1.0/sf*(1.0 - flatness/(sf + 1.0));
+    value = (floor(t/l) + smoothstep(flatness, 1.0, fract(t/l)))/sf;
+  }
+  return clamp(value, 0.0, 1.0); 
+}
+
+float triplanarTexture(vec3 p, vec3 normal, float power, float texture(vec2)) {
+  vec3 w = pow(abs(normal), vec3(power));
+  vec3 v = vec3(texture(p.yz), texture(p.xz), texture(p.xy));
+  return dot(w, v) / dot(w, vec3(1));
+}
+
+`;

package/dist/shader-modules/registry.d.ts

@@ -0,0 +1,2 @@
+import { GLSLRegistry } from "glsl-modules";
+export declare const glslRegistry: GLSLRegistry;

package/dist/shader-modules/registry.js

@@ -0,0 +1,7 @@
+import { GLSLRegistry } from "glsl-modules";
+import { glslkitLibrary } from "./library.js";
+import { arrowFunctionsPlugin, cssColorsPlugin, functionAsArgumentPlugin, namedArgumentsPlugin, namespacedImportsPlugin } from "glsl-modules/plugins";
+export const glslRegistry = new GLSLRegistry({
+    libraries: [glslkitLibrary],
+    plugins: [namespacedImportsPlugin(), cssColorsPlugin(), namedArgumentsPlugin(), arrowFunctionsPlugin(), functionAsArgumentPlugin()]
+});

package/dist/shader-modules/shaders.d.ts

@@ -0,0 +1 @@
+export declare const testFragmentShaderDefinition: string;

package/dist/shader-modules/shaders.js

@@ -0,0 +1,109 @@
+import { glslRegistry } from "./registry.js";
+export const testFragmentShaderDefinition = glslRegistry.resolve(/*glsl*/ `
+#version 300 es
+
+import { meshSDF, sdfNormal, discoBall } from "glslkit/sdf";
+import { rayMarch, RayMarchResult as RMR, Ray } from "glslkit/ray-marching";
+import { orthographic } from "glslkit/camera";
+import { axisAngle, create2DBasisVectors, rotate } from "glslkit/geometry";
+import { PI } from "glslkit/constants";
+import { aastep, signed } from "glslkit/utils";
+import { perlinNoise, valueNoise } from "glslkit/noise";
+
+precision highp float;
+
+in vec2 uv;
+out vec4 color;
+
+struct Camera {
+  vec3 position;
+  vec3 lookAt;
+  float viewport;
+  float rotation;
+};
+
+uniform int u_id;
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform sampler2D u_vertices;
+uniform int u_numVertices;
+uniform vec3 u_cameraPosition;
+uniform vec3 u_lookAt;
+uniform float u_viewport;
+uniform float u_rotation;
+uniform float u_values[10];
+
+void main() {
+  Camera;
+  float aspectRatio = u_resolution.x / u_resolution.y;
+  vec2 p = 2.0*vec2(aspectRatio, 1)*(uv - 0.5);
+  
+  Ray ray = orthographic({ 
+    uv, 
+    cameraPosition: u_cameraPosition,
+    lookAt: u_lookAt,
+    viewport: u_viewport,
+    aspectRatio,
+    rotation: u_rotation
+  });
+
+  // float sdf = (vec3 p) => length(p) - 0.5;
+
+  float sdf = (vec3 p) => {
+    // p += 0.01*signed(valueNoise(p, 100.0, 0.0));
+    // p = axisAngle(p, vec3(0, 1, 0), 0.);
+    float d0 = meshSDF(p, u_vertices, u_numVertices);
+    // float d0 = length(p) - 20.0;
+    // float d1 = length(p.xy) - 0.5;
+
+    // float d1 = min(min(length(p.xz), length(p.yz)), length(p.xy)) - 0.5;
+    float d1 = discoBall(p, vec3(0, 0, 1), 0.25, 8.0, 0.);
+    // float d1 = length(p - vec3(0, 0, 1)) - 1.;
+
+    float d = d0;
+    // d = max(d, -d1);
+    // d = min(d, d1);
+    // d = min(d, length(p) - 0.3);
+    // d = min(d, length(p.xy) - 0.25);
+    // d = d0;
+    return d;
+  };
+
+  RMR rmr = rayMarch(ray, sdf);
+
+  if (!rmr.hit) {
+    color = vec4(0, 0, 0, 0);
+    return;
+  }
+
+  vec3 position = rmr.position;
+
+  vec3 normal = sdfNormal(position + vec3(0, 0, 0.000), sdf, 0.0005);
+
+  mat2x3 basis2D = create2DBasisVectors(normal);
+  vec2 pn = position*basis2D;
+
+  vec3 lightDirection = normalize(vec3(1, -1, -1));
+  // vec3 lightDirection = ray.direction;
+  float light = clamp(-dot(normal, lightDirection), 0.0, 1.0);
+
+  // float value = smoothstep(0.45, 0.55, light);
+  float value;
+  
+  // value = light;
+  value = aastep(1.0 - (-0.1 + 1.2*light), 0.5 + 0.5*sin(20.0*2.*PI*pn.x));
+    // value = aastep(1.0 - light, perlinNoise(pn, 0.01, 0.0));
+  // if (p.y > 0.0) {
+  // } else {
+  // }
+
+  // vec3 c = vec3(value);
+  vec3 c = mix(vec3(0, 0, 0), vec3(1, 1, 1), value);
+
+  // c = texture(u_vertices, uv).rgb;
+
+  // color = vec4(1, 0, 0, 1);
+  color = vec4(c, 1);
+}
+
+`.trim());

package/dist/shader-renderer/helpers.d.ts

@@ -0,0 +1,10 @@
+export type ParsedUniform = {
+    type: string;
+    name: string;
+} & ({
+    isArray: true;
+    arraySize: number;
+} | {
+    isArray: false;
+});
+export declare function parseShaderUniforms(shader: string): ParsedUniform[];

package/dist/shader-renderer/helpers.js

@@ -0,0 +1,19 @@
+const uniformRegex = /uniform\s+([0-9a-z_]+)\s+([0-9a-z_]+)(\[(.*)\])?\s*;/i;
+export function parseShaderUniforms(shader) {
+    let index = 0;
+    let uniforms = [];
+    while (true) {
+        const match = shader.slice(index).match(uniformRegex);
+        if (!match)
+            break;
+        const [, type, name, array, arraySize] = match;
+        uniforms.push({
+            type, name,
+            ...array ?
+                { isArray: true, arraySize: parseInt(arraySize) } :
+                { isArray: false }
+        });
+        index += match.index + 1;
+    }
+    return uniforms;
+}

package/dist/shader-renderer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./pixel-shader.js";
+export * from "./texture.js";

package/dist/shader-renderer/index.js

@@ -0,0 +1,2 @@
+export * from "./pixel-shader.js";
+export * from "./texture.js";

package/dist/shader-renderer/pixel-shader.d.ts

@@ -0,0 +1,32 @@
+import { Resolution } from "../utilities/resolution.js";
+import { ShaderTexture, TextureData, TextureSpec } from "./texture.js";
+import { ProgramData, UniformData, UniformValue } from "./types.js";
+import { UniformHandler } from "./uniform.js";
+export type PixelShaderOptions = {
+    fragmentShader: string;
+    resolution?: Resolution;
+    attributes?: WebGLContextAttributes;
+    gl?: WebGL2RenderingContext;
+};
+export declare class PixelShader {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    resolution: Resolution;
+    gl: WebGL2RenderingContext;
+    programData: ProgramData;
+    uniforms: UniformHandler;
+    textures: Record<string, ShaderTexture>;
+    textureUnitCounter: number;
+    constructor(options: PixelShaderOptions);
+    setUniform(data: UniformData): PixelShader;
+    setUniform(name: string, value: UniformValue): PixelShader;
+    createTexture(name: string, spec: TextureSpec): ShaderTexture;
+    setTextureData(name: string, width: number, height: number, data: TextureData): void;
+    updateTextureSpec(name: string, partial: Partial<TextureSpec>): void;
+    private ensureCurrentProgram;
+    render(target?: HTMLCanvasElement | OffscreenCanvas | CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    resize(resolution: Resolution): void;
+}
+export declare function setupWebGL(target: HTMLCanvasElement | OffscreenCanvas | WebGL2RenderingContext, vertexShaderDefinition: string, fragmentShaderDefinition: string, attributes?: WebGLContextAttributes): {
+    gl: WebGL2RenderingContext;
+    programData: ProgramData;
+};