webgl2-sdf 0.0.3 → 0.0.5

package/src/utils/clip-line-segment-to-grid.ts

@@ -20,21 +20,17 @@ function clipLineSegmentToGrid(
         grid: Cell[][],
         width: number,
         height: number,
-        colCount: number,
         cellSize: number,
         seg: number[][],
         padCount: number): void {
     
-    /** `cellSize` *must* be a power of two */
-    // const cellSize = width/ROW_COUNT;
-
     const padding = cellSize*padCount;
 
     const [[x0,y0],[x1,y1]] = seg;
 
     const paddedWidth = width + padding;
     const paddedHeight = height + padding;
-    // TODO - investigate lines on edge and corners - ps could be length 4!!
+
     const ps = segBoxX(seg, [[-padding,-padding],[paddedWidth,paddedHeight]]);
 
     const p0IsInBox = x0 > -padding && x0 < paddedWidth && y0 > -padding && y0 < paddedHeight;

package/src/utils/clip-line-segment-to-strips.ts

@@ -1,4 +1,3 @@
-import type { Strip } from "../types/strip.js";
 import { segStripX } from "./seg-strip-x.js";
 
 
@@ -11,12 +10,12 @@ const { floor, ceil } = Math;
  * * modifies strips by adding line segments to each strip
  * * size/count *must* be a power of 2
  * 
- * @param count the number of strips
+ * @param strips array of strips - each contains an array line segments
  * @param height the height of a strip
  * @param seg the line segment (array of 2 points)
  */
 function clipLineSegmentToStrips(
-        strips: Strip[],
+        strips: number[][][][],
         height: number,
         seg: number[][]): void {
     
@@ -93,7 +92,7 @@ function clipLineSegmentToStrips(
         // if we're past the line endpoint
         if ((tX > 1 || dX === 0) && tY > 1) {
             const v = floor(p1[1]/cellSize);
-            strips[v]?.lineSegs.push([[x,y],p1]);
+            strips[v]?.push([[x,y],p1]);
             break;
         }
 
@@ -109,7 +108,7 @@ function clipLineSegmentToStrips(
             } else {
                 const v = fY(y/cellSize) - (btt ? 0 : 1);  // previous v
                 const seg_ = [[x,y],ps[i]];
-                strips[v]?.lineSegs.push(seg_);
+                strips[v]?.push(seg_);
                 break;
             }
         }
@@ -117,7 +116,7 @@ function clipLineSegmentToStrips(
         // previous v
         const v = fY(y/cellSize) - (btt ? 0 : 1);
 
-        strips[v]?.lineSegs.push([[x,y], [xX,xY]]);
+        strips[v]?.push([[x,y], [xX,xY]]);
 
         // update current position
         x = xX;
@@ -127,70 +126,4 @@ function clipLineSegmentToStrips(
 
 
 export { clipLineSegmentToStrips }
-
-
-// Quokka tests - https://www.desmos.com/calculator/uyqsdkviih
-// import { createEmptyStrips } from "./create-empty-strips";
-
-// {
-//     const strips = createEmptyStrips(8);
-//     const seg = [[0, 100], [0, 400]];
-
-//     toDesmosStr(seg);
-//     clipLineSegmentToStrips(strips, 512, seg);
-//     testAllEmptyExcept(strips,[1,2,3,4,5,6]);
-// }
-
-
-// {
-//     const strips = createEmptyStrips(8);
-//     const seg = [[83, 166], [-90, 440]];
-
-//     toDesmosStr(seg);
-//     clipLineSegmentToStrips(strips, 512, seg);
-//     testAllEmptyExcept(strips,[4,5,6]);
-// }
-
-// {
-//     const strips = createEmptyStrips(8);
-//     const seg = [[-570, 236], [-392, 546]];
-
-//     toDesmosStr(seg);
-//     clipLineSegmentToStrips(strips, 512, seg);
-//     testAllEmptyExcept(strips,[3,4,5,6,7]);
-// }
-
-// {
-//     const strips = createEmptyStrips(8);
-//     const seg = [[-462, 632], [-152, 611]];
-
-//     toDesmosStr(seg);
-//     clipLineSegmentToStrips(strips, 512, seg);
-//     testAllEmptyExcept(strips,[]);
-// }
-
-
-// function toDesmosStr(seg: number[][]) {
-//     const [[x0,y0],[x1,y1]] = seg;
-//     return `\\left(\\left(1-t\\right)\\cdot${x0.toFixed(2)}+t\\cdot\\left(${x1.toFixed(2)}\\right),\\left(1-t\\right)\\cdot${y0.toFixed(2)}+t\\cdot${y1.toFixed(2)}\\right)`;
-// }
-// function testAllEmptyExcept(
-//         strips: Strip[],
-//         exceptions: number[]) {
-
-//     for (let i=0; i<strips.length; i++) {
-//         const strip = strips[i];
-//         const idx = exceptions.findIndex(v => v === i);
-//         const exception = exceptions[idx];
-//         const len = strip.lineSegs.length;
-//         if (exception === undefined) {
-//             if (len !== 0) {
-//                 throw new Error(`Strip ${i} must be empty`);
-//             }
-//         } else {
-//             if (len !== 1) {
-//                 throw new Error(`Strip ${i} must contain 1 segments, found ${len}`);
-//             }
-//         }
-//     }
-// }
+var a = [[1,1], [1,1]]

package/src/utils/find-close-cells.ts

@@ -1,11 +1,10 @@
 import type { Cell } from "../types/cell.js";
 import { ROW_COUNT } from "../row-count.js";
 import { circsCache } from "./calc-circs.js";
-import { distanceSegToP } from "./distance-seg-to-p.js";
 import { jumpIdx } from "./jump-idx.js";
 
 
-const { min, SQRT2 } = Math;
+const { min, max, SQRT2 } = Math;
 
 
 function findCloseCells(
@@ -44,57 +43,47 @@ function findCloseCellsFor(
         // reduce current circle search range since we moved one square
         let k = jumpIdx((_minD - SQRT2*cellSize) / cellSize);
         let minD = Number.POSITIVE_INFINITY;
-        while (k < circsCache.length) {
-            const from = circsCache[k].from;
+        while (true) {
+            if (k >= circsCache.length) {
+                minD = cellSize*(circsCache[circsCache.length - 1].from - SQRT2);
+                break;
+            }
+
+            const { u, v, from } = circsCache[k];
 
             // `SQRT2` to account for diagonal
             if (cellSize*from > maxDistance + SQRT2*cellSize) {
+                minD = cellSize*(from - 2*SQRT2);
                 break;
             }
 
-            // uncomment loop below to search all equidistant squares
-            // while (circsCache?.[k].from === from) {
-                const { u, v } = circsCache[k];
-                const u_ = u + i;
-                const v_ = v + j;
-                if (u_ < 0 || u_ >= colCount + 2*padCount ||
-                    v_ < 0 || v_ >= ROW_COUNT + 2*padCount) {
-
-                    k++; continue;
-                }
-
-                const { lineSegs } = grid[u_][v_];
-                for (let l=0; l<lineSegs.length; l++) {
-                    // center of square
-                    const c = [(i - padCount + 0.5)*cellSize, (j - padCount + 0.5)*cellSize];
-                    const d = distanceSegToP(lineSegs[l], c);
-                    if (d < minD) {
-                        minD = d;
-                    }
-                }
-
-                k++;
-            // }
-
-            if (minD !== Number.POSITIVE_INFINITY) {
+            const u_ = u + i;
+            const v_ = v + j;
+            if (u_ < 0 || u_ >= colCount + 2*padCount ||
+                v_ < 0 || v_ >= ROW_COUNT + 2*padCount) {
+
+                k++; continue;
+            }
+
+            const { lineSegs } = grid[u_][v_];
+
+            if (lineSegs.length > 0) {
+                minD = cellSize*(from - SQRT2);
                 break;
             }
-        }
 
-        if (minD === Number.POSITIVE_INFINITY) {
-            return min(
-                maxDistance + SQRT2*cellSize,
-                cellSize * circsCache[circsCache.length - 1].from
-            );
+            k++;
         }
 
+
         const { closeCells } = grid[i][j];
-        let l = jumpIdx((_minD - 2*SQRT2*cellSize) / cellSize);
+
+        let l = max(0, k - 1);
         while (l < circsCache.length) {
             const { from, u, v } = circsCache[l];
 
-            // `SQRT2` to account for diagonal
-            if (cellSize*from > min(minD, maxDistance) + SQRT2*cellSize) {
+            // `SQRT2` to account for diagonal (times 2 since we minused it off earlier)
+            if (cellSize*from > min(minD, maxDistance) + 2*SQRT2*cellSize) {
                 break;
             }
 
@@ -120,52 +109,3 @@ function findCloseCellsFor(
 
 
 export { findCloseCells }
-
-
-// Quokka tests
-// const grid: Cell[][] = [
-//     [
-//         { u: 0, v: 0, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 0, v: 1, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 0, v: 2, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 0, v: 3, lineSegs: [], closeCells: [], crossingCells: [] }
-//     ],
-//     [
-//         { u: 1, v: 0, lineSegs: [], closeCells: [], crossingCells: [] },
-//         {
-//             u: 1, v: 1,
-//             lineSegs: [[[175, 163], [175, 355]]],
-//             closeCells: [], crossingCells: []
-//         },
-//         {
-//             u: 1, v: 2,
-//             lineSegs: [[[175, 355], [335, 355]]],
-//             closeCells: [], crossingCells: []
-//         },
-//         { u: 1, v: 3, lineSegs: [], closeCells: [], crossingCells: [] }
-//     ],
-//     [
-//         { u: 2, v: 0, lineSegs: [], closeCells: [], crossingCells: [] },
-//         {
-//             u: 2, v: 1,
-//             lineSegs: [[[335, 163], [175, 163]]],
-//             closeCells: [], crossingCells: []
-//         },
-//         {
-//             u: 2, v: 2,
-//             lineSegs: [[[335, 355], [335, 163]]],
-//             closeCells: [], crossingCells: []
-//         },
-//         { u: 2, v: 3, lineSegs: [], closeCells: [], crossingCells: [] }
-//     ],
-//     [
-//         { u: 3, v: 0, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 3, v: 1, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 3, v: 2, lineSegs: [], closeCells: [], crossingCells: [] },
-//         { u: 3, v: 3, lineSegs: [], closeCells: [], crossingCells: [] }
-//     ]
-// ];
-
-// findCloseCells(grid);
-// const v = grid.map(cells => cells.map(c => ({ u: c.u, v: c.v, closeCells: c.closeCells })));
-// v;//?

package/src/utils/find-crossing-cells.ts

@@ -1,10 +1,7 @@
-import { ROW_COUNT } from "../row-count.js";
 import type { Cell } from "../types/cell.js";
+import { ROW_COUNT } from "../row-count.js";
 
 
-// TODO - simplify?
-// TODO - could be made much faster by also checking intersections here
-// and passing the result to the next cell
 function findCrossingCells(
         grid: Cell[][],
         colCount: number,
@@ -24,17 +21,3 @@ function findCrossingCells(
 
 
 export { findCrossingCells }
-
-
-// Quokka tests
-// import { createEmptyGrid } from "./create-empty-grid";
-// // const g = createEmptyGrid(0);
-// const g = createEmptyGrid(0);
-// // g[0][0].lineSegs.push([[]]);
-// g[2][0].lineSegs.push([[]]);
-// g[2][2].lineSegs.push([[]]);
-// findCrossingCells(g);
-// let r = 2;
-// // g.map(r => r.map(c => c.crossingCells))[r].map(v => v);//?
-// g.map(r => r.map(c => c.crossingCells))[r].map(v => v.map(r => r[1]));//?
-// g;//?

package/src/utils/jump-idx.ts

@@ -1,6 +1,6 @@
 import { circsCache } from "./calc-circs.js";
 
-const { trunc, max, E } = Math;
+const { max, E } = Math;
 
 
 /**
@@ -14,10 +14,9 @@ function binarySearchRange<T>(
 
     let mid = 0;
     while (min <= max) {
-        mid = (min + max) >>> 1;//?
+        mid = (min + max) >>> 1;
         const midVal = circsCache[mid].from;
         if (midVal === v) {
-            // return [min,mid,max];
             return mid;
         } else if (v > midVal) {
             min = mid + 1;
@@ -26,11 +25,26 @@ function binarySearchRange<T>(
         }
     }
 
-    // return [min,mid,max];
     return mid;
 }
 
 
+function jumpIdx(
+        c: number) {
+
+    let idx = binarySearchRange(c);
+
+    c = max(0, c);
+    if (idx === 0) { return 0; }
+
+    while (circsCache[idx].from === circsCache[idx - 1].from) {
+        idx--;
+    }
+
+    return idx;
+}
+
+
 // const [Q,R] = [10.606601717798213, 35.531676008879735];
 // const [A1,B1,F1] = [102.42126, 0.153169, -117.56077];
 // const [A2,B2,C2,D2,F2] = [-0.000660087, 0.388148, 841.25744, -0.0529616, -1089.49916];
@@ -55,30 +69,21 @@ function binarySearchRange<T>(
 // }
 
 
-function jumpIdx(
-        c: number) {
-
-    let idx = binarySearchRange(c);
-
-    c = max(0, c);
-    while (idx !== 0 && circsCache[idx].from >= c) { idx--; }
-    while (idx < circsCache.length - 2 && circsCache[idx + 1].from < c) { idx++; }
-
-    return idx;
-}
-
-
 export { jumpIdx }
 
 
 // Quokka tests
-// // circsCache.slice(0,30).map(c => c.from);//?
+// circsCache.slice(0,10);//?
+// circsCache.slice(0,30).map(c => c.from);//?
+// circsCache[5].from;//?
 // circsCache[12].from;//?
 // circsCache[15].from;//?
 // // circsCache.length;//?
 
-// // jumpIdxOld(1.5811388300841898);//?
-// jumpIdx(0.5);//?
+// jumpIdxOld(1.5811388300841898);//?
+// const v = (53.08771209782213 - Math.SQRT2*24.09375)/24.09375;//?
+// jumpIdx(v);//?
+// circsCache[8].from;//?
 // binarySearchRange(1.5811388300841898);//?
 
 

package/src/utils/seg-box-x.ts

@@ -23,8 +23,12 @@ function segBoxX(
     
     // Parametric line equation: P(t) = P1 + t*(P2-P1), where 0 <= t <= 1
     
-    const ts: number[] = [];
-    const ps: number[][] = [];
+    // const ts: number[] = [];
+    // const ps: number[][] = [];
+    const xs: {
+        t: number,
+        p: number[]
+    }[] = [];
 
     if (dx !== 0) {
         // Check intersection with left edge (x = minX)
@@ -32,8 +36,9 @@ function segBoxX(
         if (tL >= 0 && tL <= 1) {
             const y = y0 + tL*dy;
             if (y >= minY && y <= maxY) {
-                ts.push(tL);
-                ps.push([minX, y]);
+                // ts.push(tL);
+                // ps.push([minX, y]);
+                xs.push({ t: tL, p: [minX, y] });
             }
         }
         
@@ -42,8 +47,9 @@ function segBoxX(
         if (tR >= 0 && tR <= 1) {
             const y = y0 + tR*dy;
             if (y >= minY && y <= maxY) {
-                ts.push(tR);
-                ps.push([maxX, y]);
+                // ts.push(tR);
+                // ps.push([maxX, y]);
+                xs.push({ t: tR, p: [maxX, y] });
             }
         }
     }
@@ -54,8 +60,9 @@ function segBoxX(
         if (tT >= 0 && tT <= 1) {
             const x = x0 + tT*dx;
             if (x >= minX && x <= maxX) {
-                ts.push(tT);
-                ps.push([x, minY]);
+                // ts.push(tT);
+                // ps.push([x, minY]);
+                xs.push({ t: tT, p: [x, minY] });
             }
         }
 
@@ -64,20 +71,26 @@ function segBoxX(
         if (tB >= 0 && tB <= 1) {
             const x = x0 + tB*dx;
             if (x >= minX && x <= maxX) {
-                ts.push(tB);
-                ps.push([x, maxY]);
+                // ts.push(tB);
+                // ps.push([x, maxY]);
+                xs.push({ t: tB, p: [x, maxY] });
             }
         }
     }
     
-    // TODO might be more than 2!!
-    if (ts.length === 2) {
-        return ts[0] < ts[1]
-            ? ps
-            : [ps[1],ps[0]];
-    }
 
-    return ps;
+    const seen = new Set<number>();  // Store unique t values
+    const xs_ = xs.filter(x => {
+        const { t } = x;
+        if (seen.has(t)) {
+            return false;
+        } else {
+            seen.add(t);
+            return true;
+        }
+    });
+
+    return xs_.sort((a,b) => a.t - b.t).map(x => x.p);
 }
 
 

package/src/webgl-utils/free-gl-context.ts

@@ -0,0 +1,35 @@
+import { GlContext } from '../types/gl-context.js';
+
+
+function freeGlContext(
+        glContext: GlContext | undefined) {
+
+    if (glContext === undefined) { return; }
+
+    const { gl, programs, textures } = glContext;
+
+    for (let key in programs) {
+        const { attributes, fragmentShader, vertexShader, uniformBlocks, program } = programs[key];
+
+        for (let key in uniformBlocks) {
+            const { buf } = uniformBlocks[key];
+            gl.deleteBuffer(buf);
+        }
+        for (let key in attributes) {
+            const { buf } = attributes[key];
+            gl.deleteBuffer(buf);
+        }
+        gl.deleteShader(fragmentShader);
+        gl.deleteShader(vertexShader);
+        gl.deleteProgram(program);
+    }
+
+    for (let key in textures) {
+        const { tex } = textures[key];
+        gl.deleteTexture(tex);
+
+    }
+}
+
+
+export { freeGlContext }

package/src/webgl-utils/{get-gl-context.ts → get-web-gl-context.ts}

@@ -13,7 +13,7 @@ const cache = new WeakMap<WebGL2RenderingContext, GlContext>();
  * @param gl the `WebGL2RenderingContext` context to wrap
  * @param callback
  */
-function getWebGLContext<T>(
+function getWebGlContext(
         gl: WebGL2RenderingContext): GlContext {
 
     {
@@ -23,19 +23,17 @@ function getWebGLContext<T>(
 
     const programs: { [index:string]: Program } = {};
     const textures: { [index:string]: Texture } = {};
-    const framebufferStack: WebGLFramebuffer[] = [];
 
     gl.canvas.addEventListener('webglcontextlost', e => {
-        handleContextLoss();
+        onContextLoss();
         e.preventDefault();
     }, false);
 
     const glContext: GlContext = {
         gl,
-        onContextLoss: handleContextLoss,
+        onContextLoss,
         textures,
-        programs,
-        framebufferStack
+        programs
     };
 
     cache.set(gl, glContext);
@@ -45,10 +43,9 @@ function getWebGLContext<T>(
 
     ////////////////////////
 
-    function handleContextLoss() {
+    function onContextLoss() {
         deleteAllProps(programs);
         deleteAllProps(textures);
-        framebufferStack.length = 0;
     }
 }
 
@@ -58,4 +55,4 @@ function deleteAllProps(o: { [key:string] : unknown }) {
 }
 
 
-export { getWebGLContext }
+export { getWebGlContext }

package/src/webgl-utils/set-attribute.ts

@@ -45,7 +45,7 @@ function setAttribute(
         const { gl, attributes } = program;
 
         const attr = attributes[name] = attributes[name] ?? {
-            buf: gl.createBuffer(), // TODO should we destroy our buffers?
+            buf: gl.createBuffer(),
             loc: gl.getAttribLocation(program.program, name),
             data: null
         }

package/src/webgl-utils/set-uniform-block.ts

@@ -34,10 +34,8 @@ function setUniformBlock(
 
         const { buf } = uniformBlock;
         
-        gl.bufferData(gl.UNIFORM_BUFFER, buffer, gl.DYNAMIC_DRAW);
-        // gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        gl.bufferData(gl.UNIFORM_BUFFER, buffer, gl.STATIC_DRAW);
         gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, buf);
-        // gl.bindBufferRange(gl.UNIFORM_BUFFER, bindingPoint, ubo, 0, sizeInBytes);
     }
 }
 

package/src/webgl-utils/use-program.ts

@@ -35,11 +35,22 @@ function initProgram(
     const uniformBlocks: { [index:string]: UniformBlock } = {};
 
     const program = gl.createProgram();
-    gl.attachShader(program, compileShader(gl, vert, gl.VERTEX_SHADER));
-    gl.attachShader(program, compileShader(gl, frag, gl.FRAGMENT_SHADER));
+    const vertexShader = compileShader(gl, vert, gl.VERTEX_SHADER);
+    const fragmentShader = compileShader(gl, frag, gl.FRAGMENT_SHADER);
+
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
     gl.linkProgram(program);
 
-    programs[name] = { gl, program, attributes, uniforms, uniformBlocks };
+    programs[name] = {
+        gl,
+        program,
+        attributes,
+        uniforms,
+        uniformBlocks,
+        vertexShader,
+        fragmentShader
+    };
 
     return programs[name];
 }

package/node/debug-shaders.d.ts

@@ -1,9 +0,0 @@
-/**
- *
- * @param gl
- * @param type `gl.VERTEX_SHADER | gl.FRAGMENT_SHADER`
- * @param shaderStr
- */
-declare function debugGlsl(gl: WebGL2RenderingContext, type: typeof gl.VERTEX_SHADER | typeof gl.FRAGMENT_SHADER, shaderStr: string): void;
-declare function debugShaders(gl: WebGL2RenderingContext): void;
-export { debugShaders, debugGlsl };

package/node/shaders/main.fragment.d.ts

@@ -1,2 +0,0 @@
-declare function getMainFragment(colCount: number, padCount: number): string;
-export { getMainFragment };

package/node/shaders/main.fragment.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"main.fragment.js","sourceRoot":"","sources":["../../src/shaders/main.fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,MAAM,KAAK,GAAkD,EAAE,CAAC;AAGhE,SAAS,eAAe,CAChB,QAAgB,EAChB,QAAgB;IAEpB,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,GAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC;IACjD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAAC,OAAO,QAAQ,CAAC;IAAC,CAAC;IAEpD,MAAM,aAAa;IACnB,QAAQ,CAAA;;;;;;;;;;;;gCAYwB,CAAC,SAAS,GAAG,CAAC,GAAC,QAAQ,CAAC,GAAC,CAAC,QAAQ,GAAG,CAAC,GAAC,QAAQ,CAAC,GAAG,CAAC;;;iCAGnD,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAuDR,SAAS;;kEAEmB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAsD7B,SAAS;;;;;;;;;CAStD,CAAA;IAEG,KAAK,CAAC,IAAI,GAAC,QAAQ,GAAG,QAAQ,CAAC,GAAG,aAAa,CAAC;IAChD,OAAO,aAAa,CAAC;AACzB,CAAC;AAGD,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/node/shaders/main.vertex.d.ts

@@ -1,2 +0,0 @@
-declare const main_Vertex = "#version 300 es\n\nprecision highp float;\n\nuniform vec2 uWidthHeight;\nuniform float uStretch;\nin vec2 aUV;\nin ivec2 aCloseCellIdxRangePerCell;\nin ivec2 aCrossIdxRangePerCell;\nout vec2 vXY;\nflat out int instanceId;\nflat out ivec2 closeCellIdxRange;\nflat out ivec2 crossCellIdxRange;\n\n\nvoid main() {\n    instanceId = gl_InstanceID;\n    closeCellIdxRange = aCloseCellIdxRangePerCell;\n    crossCellIdxRange = aCrossIdxRangePerCell;\n\n    // drawn column-by-column\n    float i = float(instanceId / 32);  // column index\n    float j = float(instanceId % 32);  // row index\n\n    vec2 trans = vec2(\n        i / float(32),\n        j / float(32)\n    );\n\n    vec2 uv = aUV + trans;\n\n    float width = uWidthHeight.x;\n    float height = uWidthHeight.y;\n\n    vXY = vec2(\n        height * uv.x,\n        height * uv.y\n    );\n\n    float aspectRatio = width / height;\n\n    gl_Position = vec4(\n        vec2(\n            (2.0*(uv.x / aspectRatio) - 1.0),\n            2.0*uv.y - 1.0\n        ),\n        0.0, 1.0\n    );\n}\n";
-export { main_Vertex };

package/node/shaders/main.vertex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"main.vertex.js","sourceRoot":"","sources":["../../src/shaders/main.vertex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,MAAM,WAAW,GAAG,QAAQ,CAAA;;;;;;;;;;;;;;;;;;;;;mCAqBO,SAAS;mCACT,SAAS;;;oBAGxB,SAAS;oBACT,SAAS;;;;;;;;;;;;;;;;;;;;;;;CAuB5B,CAAC;AAGF,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/node/types/strip.d.ts

@@ -1,8 +0,0 @@
-/**
- * A single strip within strips
- */
-interface Strip {
-    /** line segments contained within the strip */
-    readonly lineSegs: number[][][];
-}
-export type { Strip };

package/node/types/strip.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=strip.js.map

package/node/types/strip.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strip.js","sourceRoot":"","sources":["../../src/types/strip.ts"],"names":[],"mappings":""}