npm - webgl2-sdf - Versions diffs - 0.0.1 - Mend

webgl2-sdf 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (156) hide show

package/README.md +100 -0
package/node/bezier/bezier-curves-to-line-segs.d.ts +10 -0
package/node/bezier/eval-de-casteljau.d.ts +17 -0
package/node/bezier/from-to/from-to-2.d.ts +12 -0
package/node/bezier/from-to/from-to-3.d.ts +12 -0
package/node/bezier/from-to/from-to.d.ts +10 -0
package/node/bezier/is-cubic-obtuse.d.ts +11 -0
package/node/bezier/is-quad-obtuse.d.ts +11 -0
package/node/bezier/is-really-point.d.ts +9 -0
package/node/bezier/split-by-deviation-from-straight-line-cubic.d.ts +20 -0
package/node/bezier/split-by-deviation-from-straight-line-quad.d.ts +11 -0
package/node/bezier/split-into-line-segments.d.ts +10 -0
package/node/debug-shaders.d.ts +9 -0
package/node/generate-sdf.d.ts +18 -0
package/node/helpers/calc-circs.d.ts +11 -0
package/node/helpers/clip-line-segment-to-grid.d.ts +14 -0
package/node/helpers/clip-line-segment-to-strips.d.ts +13 -0
package/node/helpers/create-empty-grid.d.ts +8 -0
package/node/helpers/create-empty-strips.d.ts +7 -0
package/node/helpers/distance-seg-to-p.d.ts +5 -0
package/node/helpers/find-close-cells.d.ts +3 -0
package/node/helpers/find-crossing-cells.d.ts +3 -0
package/node/helpers/get-distance-to-line-function.d.ts +10 -0
package/node/helpers/jump-idx.d.ts +2 -0
package/node/helpers/map-to-viewbox.d.ts +2 -0
package/node/helpers/seg-box-x.d.ts +10 -0
package/node/helpers/seg-strip-x.d.ts +9 -0
package/node/index.d.ts +1 -0
package/node/main-program.d.ts +4 -0
package/node/max-aspect-ratio-before-stretch.d.ts +2 -0
package/node/prepare-buffers.d.ts +10 -0
package/node/row-count.d.ts +2 -0
package/node/shaders/main.fragment.d.ts +2 -0
package/node/shaders/main.vertex.d.ts +2 -0
package/node/svg/get-beziers-from-raw-paths.d.ts +12 -0
package/node/svg/get-paths-from-str.d.ts +9 -0
package/node/svg/path-data-polyfill/parse-number.d.ts +10 -0
package/node/svg/path-data-polyfill/parse-path-data-string.d.ts +9 -0
package/node/svg/path-data-polyfill/source.d.ts +19 -0
package/node/svg/path-segment/c.d.ts +19 -0
package/node/svg/path-segment/h.d.ts +15 -0
package/node/svg/path-segment/l.d.ts +16 -0
package/node/svg/path-segment/q.d.ts +16 -0
package/node/svg/path-segment/s.d.ts +20 -0
package/node/svg/path-segment/t.d.ts +18 -0
package/node/svg/path-segment/v.d.ts +15 -0
package/node/svg/path-segment/z.d.ts +13 -0
package/node/svg/path-state.d.ts +11 -0
package/node/tex-width.d.ts +11 -0
package/node/types/attribute.d.ts +6 -0
package/node/types/cell.d.ts +18 -0
package/node/types/gl-context.d.ts +28 -0
package/node/types/gl-type.d.ts +2 -0
package/node/types/gl-usage.d.ts +2 -0
package/node/types/program.d.ts +16 -0
package/node/types/strip.d.ts +8 -0
package/node/types/texture.d.ts +4 -0
package/node/utils/calc-circs.d.ts +11 -0
package/node/utils/clip-line-segment-to-grid.d.ts +14 -0
package/node/utils/clip-line-segment-to-strips.d.ts +13 -0
package/node/utils/create-empty-grid.d.ts +8 -0
package/node/utils/create-empty-strips.d.ts +7 -0
package/node/utils/distance-seg-to-p.d.ts +5 -0
package/node/utils/find-close-cells.d.ts +3 -0
package/node/utils/find-crossing-cells.d.ts +3 -0
package/node/utils/get-distance-to-line-function.d.ts +10 -0
package/node/utils/jump-idx.d.ts +2 -0
package/node/utils/map-to-viewbox.d.ts +2 -0
package/node/utils/seg-box-x.d.ts +10 -0
package/node/utils/seg-strip-x.d.ts +9 -0
package/node/vector/dot.d.ts +8 -0
package/node/vector/from-to-vec.d.ts +8 -0
package/node/vector/len.d.ts +6 -0
package/node/webgl-utils/compile-shader.d.ts +2 -0
package/node/webgl-utils/get-gl-context.d.ts +10 -0
package/node/webgl-utils/set-attribute.d.ts +15 -0
package/node/webgl-utils/set-uniform-block.d.ts +9 -0
package/node/webgl-utils/set-uniform.d.ts +4 -0
package/node/webgl-utils/uniform-block.d.ts +6 -0
package/node/webgl-utils/uniform-type.d.ts +2 -0
package/node/webgl-utils/use-program.d.ts +17 -0
package/node/webgl-utils/use-texture.d.ts +9 -0
package/node/webgl2.d.ts +2 -0
package/package.json +56 -0
package/src/bezier/bezier-curves-to-line-segs.ts +39 -0
package/src/bezier/eval-de-casteljau.ts +78 -0
package/src/bezier/from-to/from-to-2.ts +159 -0
package/src/bezier/from-to/from-to-3.ts +176 -0
package/src/bezier/from-to/from-to.ts +30 -0
package/src/bezier/is-cubic-obtuse.ts +31 -0
package/src/bezier/is-quad-obtuse.ts +26 -0
package/src/bezier/is-really-point.ts +25 -0
package/src/bezier/split-by-deviation-from-straight-line-cubic.ts +109 -0
package/src/bezier/split-by-deviation-from-straight-line-quad.ts +66 -0
package/src/bezier/split-into-line-segments.ts +39 -0
package/src/debug-shaders.ts +38 -0
package/src/generate-sdf.ts +91 -0
package/src/index.ts +2 -0
package/src/main-program.ts +160 -0
package/src/max-aspect-ratio-before-stretch.ts +5 -0
package/src/prepare-buffers.ts +149 -0
package/src/row-count.ts +6 -0
package/src/shaders/main.fragment.ts +157 -0
package/src/shaders/main.vertex.ts +55 -0
package/src/svg/get-beziers-from-raw-paths.ts +112 -0
package/src/svg/get-paths-from-str.ts +19 -0
package/src/svg/path-data-polyfill/parse-number.ts +138 -0
package/src/svg/path-data-polyfill/parse-path-data-string.ts +26 -0
package/src/svg/path-data-polyfill/source.ts +176 -0
package/src/svg/path-segment/c.ts +34 -0
package/src/svg/path-segment/h.ts +28 -0
package/src/svg/path-segment/l.ts +30 -0
package/src/svg/path-segment/q.ts +30 -0
package/src/svg/path-segment/s.ts +40 -0
package/src/svg/path-segment/t.ts +35 -0
package/src/svg/path-segment/v.ts +28 -0
package/src/svg/path-segment/z.ts +27 -0
package/src/svg/path-state.ts +15 -0
package/src/tex-width.ts +14 -0
package/src/types/attribute.ts +9 -0
package/src/types/cell.ts +21 -0
package/src/types/gl-context.ts +28 -0
package/src/types/gl-type.ts +16 -0
package/src/types/gl-usage.ts +14 -0
package/src/types/program.ts +14 -0
package/src/types/strip.ts +11 -0
package/src/types/texture.ts +7 -0
package/src/types/typed-array.ts +16 -0
package/src/utils/calc-circs.ts +129 -0
package/src/utils/clip-line-segment-to-grid.ts +133 -0
package/src/utils/clip-line-segment-to-strips.ts +196 -0
package/src/utils/create-empty-grid.ts +32 -0
package/src/utils/create-empty-strips.ts +21 -0
package/src/utils/distance-seg-to-p.ts +50 -0
package/src/utils/find-close-cells.ts +171 -0
package/src/utils/find-crossing-cells.ts +40 -0
package/src/utils/get-distance-to-line-function.ts +59 -0
package/src/utils/is-point-in-box.ts +16 -0
package/src/utils/jump-idx.ts +107 -0
package/src/utils/map-to-viewbox.ts +41 -0
package/src/utils/path.ts +137 -0
package/src/utils/seg-box-x.ts +84 -0
package/src/utils/seg-strip-x.ts +72 -0
package/src/utils/sum.ts +13 -0
package/src/vector/dot.ts +13 -0
package/src/vector/from-to-vec.ts +13 -0
package/src/vector/len.ts +11 -0
package/src/webgl-utils/compile-shader.ts +15 -0
package/src/webgl-utils/get-gl-context.ts +61 -0
package/src/webgl-utils/set-attribute.ts +74 -0
package/src/webgl-utils/set-uniform-block.ts +45 -0
package/src/webgl-utils/set-uniform.ts +24 -0
package/src/webgl-utils/uniform-block.ts +9 -0
package/src/webgl-utils/uniform-type.ts +10 -0
package/src/webgl-utils/use-program.ts +48 -0
package/src/webgl-utils/use-texture.ts +34 -0

package/README.md ADDED Viewed

@@ -0,0 +1,100 @@
+WORK IN PROGRESS!!
+## Overview
+A library to generate the signed distance transform (sdf) of an array of bezier
+curves, typically some some closed shape(s).
+* *dozens of times faster* than ()[webgl-sdf-generator] for real-time (60 fps)
+applications
+* drop-in replacement for ()[webgl-sdf-generator] with some additional options
+The bezier curves can be given in raw form or as an svg string (except arcs are
+not supported)
+```typescript
+```
+Bug reports, pull requests and ⭐⭐⭐⭐⭐s are welcome and appreciated!
+## Features
+* **Fast** Special care has been taken to ensure each function performs well not
+only in theory but also in practice.
+## Installation
+```cli
+npm install flo-bezier3
+```
+This package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
+It can be used in `Node.js` or in a browser.
+Additionally, self-contained `ECMAScript Module` (ESM) files `index.js` and
+`index.min.js` in the `./browser` folder are provided.
+## Usage
+Below are usage examples for some common environments.
+Please see the [docs](https://florissteenkamp.github.io/FloBezier) for a complete
+list of available functions.
+### Node.js
+```js
+import { fitQuadsToCubic } from 'flo-bezier3';
+```
+### Browsers - directly, without a bundler, using the pre-bundled minified .js file
+```html
+<!doctype html>
+<html lang="en">
+<head>
+    <script type="module">
+        import { fitQuadsToCubic } from "./node_modules/flo-bezier3/browser/index.min.js";
+        // some cubic bezier curve given by an array of its control points
+        const cubic = [[1, 1], [5.125, 8], [15.375, 0.875], [13.6875, 7.71875]];
+        const quads = fitQuadsToCubic(cubic, 0.1); //=> [[[1, 1], [2.617431640625, 3.5152587890625], ...
+        if (quads.length === 4) {
+            console.log('success! 😁');  // we should get to here!
+        } else {
+            console.log('failure! 😥');  // ...and not here
+        }
+    </script>
+</head>
+<body>Check the console.</body>
+</html>
+```
+### Bundlers (Webpack, Rollup, ...)
+Webpack will be taken as an example here.
+Since your webpack config file might still use `CommonJS` you must rename
+`webpack.config.js` to `webpack.config.cjs`.
+Follow this [guide](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c#how-can-i-make-my-typescript-project-output-esm).
+## License
+The MIT License (MIT)
+Copyright © 2026 Floris Steenkamp
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node/bezier/bezier-curves-to-line-segs.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Returns an array of line segments that is an approximation of the given
+ * bezier curves up to `PIXEL_ACCURACY` accuracy.
+ *
+ * @param bezierLoops
+ * @param resolution each bezier curve is split until its hausdorff distance
+ * from the line connecting it's endpoints are less than this value
+ */
+declare function bezierCurvesToLineSegs(bezierLoops: (number[][])[][], resolution: 0.5 | 1): number[][][];
+export { bezierCurvesToLineSegs };

package/node/bezier/eval-de-casteljau.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Returns the resulting point of evaluating the given bezier curve at the
+ * given parameter `t`.
+ *
+ * * uses [De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm)
+ * in double precision floating point arithmetic
+ *
+ * The resulting point `p` is returned as the pair `[x,y]`, where `x` and `y` are
+ * double precision floating point numbers.
+ *
+ * @param ps an order 1,2 or 3 bezier curve, e.g. `[[0,0],[1,1],[2,1],[2,0]]`
+ * @param t the parameter value where the bezier should be evaluated
+ *
+ * @doc mdx
+ **/
+declare function evalDeCasteljau(ps: number[][], t: number): number[];
+export { evalDeCasteljau };

package/node/bezier/from-to/from-to-2.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/**
+ * Returns a bezier curve that starts and ends at the given `t` parameters.
+ *
+ * @param ps a quadratic bezier curve given as an ordered array of its
+ * control point coordinates, e.g. `[[0,0], [1,1], [2,1]]`
+ * @param tS the `t` parameter where the resultant bezier should start
+ * @param tE the `t` parameter where the resultant bezier should end
+ *
+ * @internal
+ */
+declare function fromTo2(ps: number[][], tS: number, tE: number): number[][];
+export { fromTo2 };

package/node/bezier/from-to/from-to-3.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/**
+ * Returns a bezier curve that starts and ends at the given t parameters.
+ *
+ * @param ps a cubic bezier curve given as an ordered array of its
+ * control point coordinates, e.g. `[[0,0], [1,1], [2,1], [2,0]]`
+ * @param tS the `t` parameter where the resultant bezier should start
+ * @param tE the `t` parameter where the resultant bezier should end
+ *
+ * @internal
+ */
+declare function fromTo3(ps: number[][], tS: number, tE: number): number[][];
+export { fromTo3 };

package/node/bezier/from-to/from-to.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Returns a bezier curve that starts and ends at the given `t` parameters.
+ *
+ * @param ps an order 2 or 3 bezier curve given as an ordered array of its
+ * control point coordinates, e.g. `[[0,0], [1,1], [2,1], [2,0]]`
+ * @param tS the `t` parameter where the resultant bezier should start
+ * @param tE the `t` parameter where the resultant bezier should end
+ */
+declare function fromTo(ps: number[][], tS: number, tE: number): number[][];
+export { fromTo };

package/node/bezier/is-cubic-obtuse.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Returns `true` if the given cubic bezier is obtuse, `false` otherwise (i.e.
+ * `false` if acute).
+ *
+ * Obtuse here is defined as follows: let the cubic form triangles through its
+ * control points P0, P1, P3 where P0 and P3 are the endpoints. If both interior
+ * angles ∠P0 and ∠P2 are <= 90 degrees then the cubic is considered acute,
+ * otherwise it is considered obtuse. The same should be true for P0, P2, P3.
+ */
+declare function isCubicObtuse(ps: number[][]): boolean;
+export { isCubicObtuse };

package/node/bezier/is-quad-obtuse.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Returns `true` if the given quadratic bezier is obtuse, `false` otherwise (i.e.
+ * `false` if acute).
+ *
+ * Obtuse here is defined as follows: let the quad form a triangle through its
+ * control points P0, P1, P2 where P0 and P2 are the endpoints. If both interior
+ * angles ∠P0 and ∠P2 are <= 90 degrees then the quad is considered acute,
+ * otherwise it is considered obtuse.
+ */
+declare function isQuadObtuse(ps: number[][]): boolean;
+export { isQuadObtuse };

package/node/bezier/is-really-point.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ * Returns `true` if the given bezier curve has all control points coincident,
+ * `false` otherwise.
+ *
+ * @param ps an order 0,1,2 or 3 bezier curve given as an array of its control
+ * points, e.g. `[[0,0],[1,1],[2,1],[2,0]]`
+ */
+declare function isReallyPoint(ps: number[][]): boolean;
+export { isReallyPoint };

package/node/bezier/split-by-deviation-from-straight-line-cubic.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/**
+ * Split the given cubic bezier curve into pieces (given as an array of
+ * parameter `t` values) such that each piece is guaranteed to deviate less
+ * than `maxD` from a straigh line.
+ *
+ * * a crude method is employed (for efficiency) by noting that the hausdorff
+ * distance between a cubic and the line segment connecting its endpoints is at
+ * most 3/4 the distance of the max distance between any control point and the
+ * line segment if the control points are on the same side of the line segment
+ * and at most 4/9 if they are on opposite sides AND (in both cases) the cubic
+ * is not obtuse, i.e. the inner control points are not outside the strip formed
+ * by the two lines passing through the endpoint control points normal to the
+ * line segment connecting the endpoint control points.
+ *
+ * @param ps an order 2 bezier curve given as an ordered array of its
+ * control point coordinates, e.g. `[[0,0], [1,1], [2,1]]`
+ * @param maxD
+ */
+declare function splitByDeviationFromStraighLine_Cubic_Crude(ps: number[][], maxD: number): number[];
+export { splitByDeviationFromStraighLine_Cubic_Crude, };

package/node/bezier/split-by-deviation-from-straight-line-quad.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Split the given quadratic bezier curve into pieces (given as an array of
+ * parameter `t` values) such that each piece is guaranteed to deviate less
+ * than `maxD` from a straigh line.
+ *
+ * @param ps an order 2 bezier curve given as an ordered array of its
+ * control point coordinates, e.g. `[[0,0], [1,1], [2,1]]`
+ * @param maxD
+ */
+declare function splitByDeviationFromStraighLine_Quad(ps: number[][], maxD: number): number[];
+export { splitByDeviationFromStraighLine_Quad };

package/node/bezier/split-into-line-segments.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Returns the result of splitting the given bezier curve into straight line
+ * segments up to `maxDeviation`
+ *
+ *
+ * @param ps
+ * @param maxDeviation maximum deviation from straight line
+ */
+declare function splitIntoLineSegments(ps: number[][], maxDeviation: number): number[][][];
+export { splitIntoLineSegments };

package/node/debug-shaders.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ *
+ * @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/generate-sdf.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param gl
+ * @param psss
+ * @param width
+ * @param height
+ * @param viewbox
+ * @param maxDistance
+ * @param sdfExponent
+ * @param inclInside
+ * @param inclOutside
+ * @param x
+ * @param y
+ * @param channel
+ * @param resolution
+ */
+declare function generateIntoFramebuffer(gl: WebGL2RenderingContext, psss: (number[][])[][] | string, width: number, height: number, viewbox: [number, number, number, number], maxDistance: number, sdfExponent?: number, inclInside?: boolean, inclOutside?: boolean, x?: number, y?: number, channel?: number, resolution?: 0.5 | 1): void;
+export { generateIntoFramebuffer };

package/node/helpers/calc-circs.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+/**
+ * Represents the max distance (in cell side length units) from one corner of
+ * the viewbox to the opposing corner.
+ */
+declare const circsCache: Range[];
+interface Range {
+    readonly from: number;
+    readonly u: number;
+    readonly v: number;
+}
+export { circsCache };

package/node/helpers/clip-line-segment-to-grid.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import type { Cell } from "../types/cell";
+/**
+ * Clips a line segment to grid boundaries and returns multiple segments.
+ *
+ * * modifies grid by adding line segments to cells
+ * * size/count *must* be a power of 2
+ *
+ * @param count the number of grid cells per dimension
+ * @param width
+ * @param height
+ * @param seg the line segment (array of 2 points)
+ */
+declare function clipLineSegmentToGrid(grid: Cell[][], width: number, height: number, colCount: number, cellSize: number, seg: number[][], padCount: number): void;
+export { clipLineSegmentToGrid };

package/node/helpers/clip-line-segment-to-strips.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import type { Strip } from "../types/strip";
+/**
+ * Clips a line segment to strip boundaries and returns multiple segments.
+ *
+ * * modifies strips by adding line segments to each strip
+ * * size/count *must* be a power of 2
+ *
+ * @param count the number of strips
+ * @param height the height of a strip
+ * @param seg the line segment (array of 2 points)
+ */
+declare function clipLineSegmentToStrips(strips: Strip[], height: number, seg: number[][]): void;
+export { clipLineSegmentToStrips };

package/node/helpers/create-empty-grid.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { Cell } from "../types/cell";
+/**
+ *
+ * @param colCount
+ * @param padCount
+ */
+declare function createEmptyGrid(colCount: number, padCount: number): Cell[][];
+export { createEmptyGrid };

package/node/helpers/create-empty-strips.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { Strip } from "../types/strip";
+/**
+ *
+ * @param count the number of strips
+ */
+declare function createEmptyStrips(): Strip[];
+export { createEmptyStrips };

package/node/helpers/distance-seg-to-p.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * Returns the minimum distance from the given line segment to the origin.
+ */
+declare function distanceSegToP(seg: number[][], p: number[]): number;
+export { distanceSegToP };

package/node/helpers/find-close-cells.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { Cell } from "../types/cell";
+declare function findCloseCells(grid: Cell[][], colCount: number, cellSize: number, maxDistance: number, padCount: number): void;
+export { findCloseCells };

package/node/helpers/find-crossing-cells.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { Cell } from "../types/cell";
+declare function findCrossingCells(grid: Cell[][], colCount: number, padCount: number): void;
+export { findCrossingCells };

package/node/helpers/get-distance-to-line-function.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Returns a function that returns the signed distance to the given line from
+ * the given point.
+ *
+ * @param pS a point on the line
+ * @param pE a different point on the line; if `pS` is the same as `pE` then
+ * the distance to the point `pS` (or `pE`) will be returned.
+ */
+declare function getDistanceToLineFunction(pS: number[], pE: number[]): (p: number[]) => number;
+export { getDistanceToLineFunction };

package/node/helpers/jump-idx.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ declare function jumpIdx(c: number): number;
2	+ export { jumpIdx };

package/node/helpers/map-to-viewbox.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ declare function mapToViewbox(viewbox: [number, number, number, number], width: number, height: number, psss: (number[][])[][]): (number[][])[][];
2	+ export { mapToViewbox };

package/node/helpers/seg-box-x.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Returns the ordered (by t-value) intersection points of the given line
+ * segment and square.
+ *
+ * @param seg a line segment given by its endpoints
+ * @param square a square given by its two opposing corner points, min-x, min-y
+ * first
+ */
+declare function segBoxX(seg: number[][], square: number[][]): number[][];
+export { segBoxX };

package/node/helpers/seg-strip-x.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ * Returns the ordered (by t-value) intersection points of the given line
+ * segment and half-open strip.
+ *
+ * @param seg a line segment given by its endpoints
+ * @param strip a half-open strip given by max-x, min-y, max-y
+ */
+declare function segStripX(seg: number[][], strip: number[]): number[][];
+export { segStripX };

package/node/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { generateIntoFramebuffer } from './generate-sdf.js';

package/node/main-program.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { Program } from './types/program.js';
+import { GlContext } from './types/gl-context.js';
+declare function mainProgram(glContext: GlContext, programMain: Program, resolution: 0.5 | 1, psss: number[][][][], viewbox: [number, number, number, number], maxDistance: number, sdfExponent: number | undefined, width: number, height: number, colCount: number, cellSize: number, inclInside: boolean, inclOutside: boolean, padCount: number, stretch: number): void;
+export { mainProgram };

package/node/max-aspect-ratio-before-stretch.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ declare const MAX_ASPECT_RATIO_BEFORE_STRETCH = 4;
2	+ export { MAX_ASPECT_RATIO_BEFORE_STRETCH };

package/node/prepare-buffers.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+declare function prepareBuffers(psss: (number[][])[][], width: number, height: number, colCount: number, cellSize: number, maxDistance: number, padCount: number, resolution?: 0.5 | 1, viewbox?: [number, number, number, number], stretch?: number): {
+    lineSegPtCoords_Arr: Float32Array<ArrayBuffer>;
+    segIdxs_PerCell_Range_Arr: Int32Array<ArrayBuffer>;
+    closeCellIdxs_PerCell_Arr: Int32Array<ArrayBuffer>;
+    closeCellIdxs_PerCell_Range_Arr: Int32Array<ArrayBuffer>;
+    crossCellIdxs_PerCell_Arr: Int32Array<ArrayBuffer>;
+    crossCellIdxs_perCell_Range_Arr: Int32Array<ArrayBuffer>;
+    segIdxs_PerStrip_Range_Arr: Int32Array<ArrayBuffer>;
+};
+export { prepareBuffers };

package/node/row-count.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ declare const ROW_COUNT = 32;
2	+ export { ROW_COUNT };

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

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

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

	@@ -0,0 +1,2 @@
1	+ 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.0uv.y - 1.0\n ),\n 0.0, 1.0\n );\n}\n";
2	+ export { main_Vertex };

package/node/svg/get-beziers-from-raw-paths.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+/**
+ * Returns order 1, 2 and 3 beziers from the given SVG DOM element. If a path
+ * data tag is not "C, Q or L, etc", i.e. if it is not an absolute bezier
+ * coordinate then it is converted into one.
+ *
+ * @param paths An SVG element
+ */
+declare function getBeziersFromRawPaths(paths: {
+    type: string;
+    values: number[];
+}[]): number[][][][];
+export { getBeziersFromRawPaths };

package/node/svg/get-paths-from-str.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ * Returns an array of loops with each loop consisting of an array of beziers
+ * and each bezier in turn consisting of an array of control points from the
+ * given SVG path string. An array of loops are returned (as opposed to a single
+ * loop) since an SVG path may have sub-paths.
+ * @param str The SVG path string, e.g. 'M1 1 C 5 1 5 2 4 2 C 3 3 1 3 1 1 z'
+ */
+declare function getPathsFromStr(str: string): number[][][][];
+export { getPathsFromStr };

package/node/svg/path-data-polyfill/parse-number.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { Source } from './source.js';
+/**
+ * @hidden
+ * Parse a number from an SVG path. This very closely follows genericParseNumber(...) from
+ * Source/core/svg/SVGParserUtilities.cpp.
+ * Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF
+ * @param source
+ */
+declare function parseNumber(source: Source): number;
+export { parseNumber };

package/node/svg/path-data-polyfill/parse-path-data-string.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ * @hidden
+ * @param string
+ */
+declare function parsePathDataString(string: string): {
+    type: string;
+    values: number[];
+}[];
+export { parsePathDataString };

package/node/svg/path-data-polyfill/source.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+/** @hidden */
+declare class Source {
+    _string: string;
+    _currentIndex: number;
+    _endIndex: number;
+    _prevCommand: string | undefined;
+    constructor(string: string);
+    parseSegment(): {
+        type: string;
+        values: number[];
+    };
+    hasMoreData(): boolean;
+    initialCommandIsMoveTo(): boolean;
+    _isCurrentSpace(): boolean;
+    _skipOptionalSpaces(): boolean;
+    _skipOptionalSpacesOrDelimiter(): boolean;
+    _parseArcFlag(): number;
+}
+export { Source };

package/node/svg/path-segment/c.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { PathState } from "../path-state.js";
+/**
+ * @hidden
+ * C and c: (from www.w3.org)
+ *
+ * params: x1 y1 x2 y2 x y
+ *
+ * Draws a cubic Bézier curve from the current point to (x,y)
+ * using (x1,y1) as the control point at the beginning of the
+ * curve and (x2,y2) as the control point at the end of the
+ * curve. C (uppercase) indicates that absolute coordinates
+ * will follow; c (lowercase) indicates that relative
+ * coordinates will follow. Multiple sets of coordinates may
+ * be specified to draw a polybézier. At the end of the
+ * command, the new current point becomes the final (x,y)
+ * coordinate pair used in the polybézier.
+ */
+declare function c(s: PathState): number[][];
+export { c };

package/node/svg/path-segment/h.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { PathState } from '../path-state.js';
+/**
+ * @hidden
+ * H and h: (from www.w3.org)
+ *
+ * params: x
+ *
+ * Draws a horizontal line from the current point (cpx, cpy) to (x, cpy). H
+ * (uppercase) indicates that absolute coordinates will follow; h (lowercase)
+ * indicates that relative coordinates will follow. Multiple x values can be
+ * provided (although usually this doesn't make sense). At the end of the
+ * command, the new current point becomes (x, cpy) for the final value of x.
+ */
+declare function h(s: PathState): number[][];
+export { h };

package/node/svg/path-segment/l.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import { PathState } from '../path-state.js';
+/**
+ * @hidden
+ * L and l: (from www.w3.org)
+ *
+ * params: x y
+ *
+ * Draw a line from the current point to the given (x,y) coordinate which
+ * becomes the new current point. L (uppercase) indicates that absolute
+ * coordinates will follow; l (lowercase) indicates that relative coordinates
+ * will follow. A number of coordinates pairs may be specified to draw a
+ * polyline. At the end of the command, the new current point is set to the
+ * final set of coordinates provided.
+ */
+declare function l(s: PathState): number[][];
+export { l };

package/node/svg/path-segment/q.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import { PathState } from '../path-state.js';
+/**
+ * @hidden
+ * Q and q: (from www.w3.org)
+ *
+ * params: x1 y1 x y
+ *
+ * Draws a quadratic Bézier curve from the current point to (x,y) using (x1,y1)
+ * as the control point. Q (uppercase) indicates that absolute coordinates will
+ * follow; q (lowercase) indicates that relative coordinates will follow.
+ * Multiple sets of coordinates may be specified to draw a polybézier. At the
+ * end of the command, the new current point becomes the final (x,y) coordinate
+ * pair used in the polybézier.
+ */
+declare function q(s: PathState): number[][];
+export { q };

package/node/svg/path-segment/s.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { PathState } from "../path-state.js";
+/**
+ * @hidden
+ * S and s: (from www.w3.org)
+ *
+ * params: x2 y2 x y
+ *
+ * Draws a cubic Bézier curve from the current point to (x,y). The first control
+ * point is assumed to be the reflection of the second control point on the
+ * previous command relative to the current point. (If there is no previous
+ * command or if the previous command was not an C, c, S or s, assume the first
+ * control point is coincident with the current point.) (x2,y2) is the second
+ * control point (i.e., the control point at the end of the curve). S
+ * (uppercase) indicates that absolute coordinates will follow; s (lowercase)
+ * indicates that relative coordinates will follow. Multiple sets of coordinates
+ * may be specified to draw a polybézier. At the end of the command, the new
+ * current point becomes the final (x,y) coordinate pair used in the polybézier.
+ */
+declare function s(s: PathState): number[][];
+export { s };

package/node/svg/path-segment/t.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { PathState } from '../path-state.js';
+/**
+ * @hidden
+ * T and t: (from www.w3.org)
+ *
+ * params: x y
+ *
+ * Draws a quadratic Bézier curve from the current point to (x,y). The control
+ * point is assumed to be the reflection of the control point on the previous
+ * command relative to the current point. (If there is no previous command or if
+ * the previous command was not a Q, q, T or t, assume the control point is
+ * coincident with the current point.) T (uppercase) indicates that absolute
+ * coordinates will follow; t (lowercase) indicates that relative coordinates
+ * will follow. At the end of the command, the new current point becomes the
+ * final (x,y) coordinate pair used in the polybézier.
+ */
+declare function t(s: PathState): number[][];
+export { t };

package/node/svg/path-segment/v.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { PathState } from '../path-state.js';
+/**
+ * @hidden
+ * V and v: (from www.w3.org)
+ *
+ * params: y
+ *
+ * Draws a vertical line from the current point (cpx, cpy) to (cpx, y). V
+ * (uppercase) indicates that absolute coordinates will follow; v (lowercase)
+ * indicates that relative coordinates will follow. Multiple y values can be
+ * provided (although usually this doesn't make sense). At the end of the
+ * command, the new current point becomes (cpx, y) for the final value of y.
+ */
+declare function v(s: PathState): number[][];
+export { v };