@matboks/utilities 0.0.1

package/dist/shader-renderer/pixel-shader.js

@@ -0,0 +1,172 @@
+import { Resolution } from "../utilities/resolution.js";
+import { parseShaderUniforms } from "./helpers.js";
+import { pixelVertexShader } from "./pixel-vertex-shader.js";
+import { ShaderTexture } from "./texture.js";
+import { UniformHandler } from "./uniform.js";
+export class PixelShader {
+    constructor(options) {
+        this.textures = {};
+        this.textureUnitCounter = 0;
+        let { fragmentShader, resolution = new Resolution(100, 100), attributes, gl: customGL } = options;
+        let canvas;
+        let gl;
+        let programData;
+        if (customGL) {
+            canvas = customGL.canvas;
+            resolution = new Resolution(canvas.width, canvas.height);
+            ({ gl, programData } = setupWebGL(customGL, pixelVertexShader, fragmentShader, attributes));
+        }
+        else {
+            canvas = new OffscreenCanvas(resolution.width, resolution.height);
+            ({ gl, programData } = setupWebGL(canvas, pixelVertexShader, fragmentShader, attributes));
+        }
+        this.resolution = resolution;
+        this.canvas = canvas;
+        this.gl = gl;
+        this.programData = programData;
+        this.uniforms = new UniformHandler(gl, programData.uniforms);
+    }
+    setUniform(...args) {
+        this.ensureCurrentProgram();
+        let data;
+        if (args.length === 2) {
+            data = { [args[0]]: args[1] };
+        }
+        else {
+            data = args[0];
+        }
+        for (const name in data) {
+            this.uniforms.setUniform(name, data[name]);
+        }
+        return this;
+    }
+    createTexture(name, spec) {
+        const tex = new ShaderTexture(this.gl, spec);
+        this.textures[name] = tex;
+        return tex;
+    }
+    setTextureData(name, width, height, data) {
+        const tex = this.textures[name];
+        if (!tex)
+            throw new Error(`Texture ${name} not found`);
+        tex.setData(width, height, data);
+    }
+    updateTextureSpec(name, partial) {
+        const tex = this.textures[name];
+        if (!tex)
+            throw new Error(`Texture ${name} not found`);
+        tex.updateSpec(partial);
+    }
+    ensureCurrentProgram() {
+        const { program, vao } = this.programData;
+        this.gl.useProgram(program);
+        this.gl.bindVertexArray(vao);
+    }
+    render(target) {
+        const { gl, programData, textures, resolution: { width, height } } = this;
+        gl.viewport(0, 0, width, height);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        this.ensureCurrentProgram();
+        let unit = 0;
+        for (const name in textures) {
+            const tex = textures[name];
+            const uniform = programData.uniforms[name];
+            if (!uniform)
+                continue;
+            gl.activeTexture(gl.TEXTURE0 + unit);
+            gl.bindTexture(gl.TEXTURE_2D, tex.texture);
+            gl.uniform1i(uniform.location, unit);
+            unit++;
+        }
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+        let ctx = null;
+        if (target instanceof HTMLCanvasElement || target instanceof OffscreenCanvas) {
+            ctx = target.getContext("2d");
+        }
+        else if (target instanceof CanvasRenderingContext2D || target instanceof OffscreenCanvasRenderingContext2D) {
+            ctx = target;
+        }
+        if (ctx) {
+            const transform = ctx.getTransform();
+            ctx.resetTransform();
+            ctx.drawImage(this.canvas, 0, 0);
+            ctx.setTransform(transform);
+        }
+    }
+    resize(resolution) {
+        const { resolution: currentResolution } = this;
+        if (currentResolution.width === resolution.width && currentResolution.height === resolution.height)
+            return;
+        this.resolution = resolution;
+        this.canvas.width = resolution.width;
+        this.canvas.height = resolution.height;
+    }
+}
+export function setupWebGL(target, vertexShaderDefinition, fragmentShaderDefinition, attributes) {
+    let gl;
+    if (target instanceof WebGL2RenderingContext) {
+        gl = target;
+    }
+    else {
+        gl = target.getContext("webgl2", attributes);
+    }
+    if (!gl)
+        throw new Error("Unable to create WebGL2 context");
+    const program = createProgram(gl, vertexShaderDefinition, fragmentShaderDefinition);
+    const positionAttribLocation = gl.getAttribLocation(program, "p");
+    const positionBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+    const positionData = new Float32Array([
+        0, 0,
+        1, 0,
+        1, 1,
+        0, 0,
+        1, 1,
+        0, 1
+    ]);
+    gl.bufferData(gl.ARRAY_BUFFER, positionData, gl.STATIC_DRAW);
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    gl.enableVertexAttribArray(positionAttribLocation);
+    gl.vertexAttribPointer(positionAttribLocation, 2, gl.FLOAT, false, 0, 0);
+    gl.useProgram(program);
+    const parsedUniforms = parseShaderUniforms(fragmentShaderDefinition);
+    const uniformMap = {};
+    for (const u of parsedUniforms) {
+        const location = gl.getUniformLocation(program, u.name);
+        uniformMap[u.name] = { ...u, location };
+    }
+    const programData = {
+        program,
+        vao,
+        uniforms: uniformMap
+    };
+    return { gl, programData };
+}
+function createProgram(gl, vertexShaderDefinition, fragmentShaderDefinition) {
+    const program = gl.createProgram();
+    const vertexShader = createShader(gl, "VERTEX", vertexShaderDefinition);
+    const fragmentShader = createShader(gl, "FRAGMENT", fragmentShaderDefinition);
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    const linkStatus = gl.getProgramParameter(program, gl.LINK_STATUS);
+    if (!linkStatus) {
+        gl.deleteProgram(program);
+        throw new Error(`Error linking program: ${gl.getProgramParameter(program, gl.LINK_STATUS)}`);
+    }
+    return program;
+}
+function createShader(gl, type, definition) {
+    const shader = gl.createShader(gl[`${type}_SHADER`]);
+    gl.shaderSource(shader, definition);
+    gl.compileShader(shader);
+    const compileStatus = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+    if (!compileStatus) {
+        const error = gl.getShaderInfoLog(shader);
+        gl.deleteShader(shader);
+        throw new Error(`Unable to compile ${type}: ${error}`);
+    }
+    return shader;
+}

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

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

package/dist/shader-renderer/pixel-vertex-shader.js

@@ -0,0 +1,14 @@
+export const pixelVertexShader = /*glsl*/ `
+#version 300 es
+
+precision highp float;
+
+in vec2 p;
+out vec2 uv;
+
+void main() {
+  uv = p;
+  gl_Position = vec4(-1.0 + 2.0*p, 0, 1);
+}
+
+`.trim();

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

@@ -0,0 +1,28 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Vec3 } from "../geometry/vec3.js";
+import { Vec4 } from "../geometry/vec4.js";
+export type TextureDimension = 1 | 2 | 3 | 4;
+export type TextureDataItem = number | Vec2 | Vec3 | Vec4;
+export type TextureData = Array<TextureDataItem> | TexImageSource;
+export type TextureSpec = {
+    dimension: TextureDimension;
+    width?: number;
+    height?: number;
+    filter?: GLenum;
+    wrap?: GLenum;
+};
+export declare class ShaderTexture {
+    gl: WebGL2RenderingContext;
+    texture: WebGLTexture;
+    spec: TextureSpec;
+    constructor(gl: WebGL2RenderingContext, spec: TextureSpec);
+    private createGLTexture;
+    /** Update only filtering, wrapping, etc. */
+    updateSpec(partial: Partial<TextureSpec>): void;
+    /** Uploads data – reallocates if width/height changed */
+    setData(width: number, height: number, data: TextureData): void;
+    /** Converts Vec2/Vec3/Vec4/number to Float32Array */
+    private convertToFlatArray;
+    private internalFormat;
+    private format;
+}

package/dist/shader-renderer/texture.js

@@ -0,0 +1,97 @@
+export class ShaderTexture {
+    constructor(gl, spec) {
+        this.gl = gl;
+        this.spec = {
+            filter: gl.NEAREST,
+            wrap: gl.CLAMP_TO_EDGE,
+            width: 20,
+            height: 1,
+            ...spec,
+        };
+        this.texture = this.createGLTexture();
+    }
+    createGLTexture() {
+        const { gl } = this;
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.spec.filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.spec.filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.spec.wrap);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.spec.wrap);
+        // allocate empty storage initially
+        const { width, height } = this.spec;
+        gl.texImage2D(gl.TEXTURE_2D, 0, this.internalFormat(), width, height, 0, this.format(), gl.FLOAT, null);
+        return tex;
+    }
+    /** Update only filtering, wrapping, etc. */
+    updateSpec(partial) {
+        Object.assign(this.spec, partial);
+        const { gl, texture } = this;
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        if (partial.filter !== undefined) {
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.spec.filter);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.spec.filter);
+        }
+        if (partial.wrap !== undefined) {
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.spec.wrap);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.spec.wrap);
+        }
+    }
+    /** Uploads data – reallocates if width/height changed */
+    setData(width, height, data) {
+        const { gl } = this;
+        let texData;
+        if (Array.isArray(data)) {
+            const expectedItems = width * height;
+            if (data.length !== expectedItems) {
+                throw new Error(`Texture data mismatch: expected ${expectedItems}, got ${data.length}`);
+            }
+            texData = this.convertToFlatArray(data);
+        }
+        else {
+            texData = data;
+        }
+        gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        const dimensionChanged = width !== this.spec.width || height !== this.spec.height;
+        if (dimensionChanged) {
+            this.spec.width = width;
+            this.spec.height = height;
+            gl.texImage2D(gl.TEXTURE_2D, 0, this.internalFormat(), width, height, 0, this.format(), gl.FLOAT, texData);
+        }
+        else {
+            // Faster path when dimension stays constant
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, this.format(), gl.FLOAT, texData);
+        }
+    }
+    /** Converts Vec2/Vec3/Vec4/number to Float32Array */
+    convertToFlatArray(data) {
+        const { dimension } = this.spec;
+        let flatData = [];
+        if (dimension === 1) {
+            flatData = data;
+        }
+        else {
+            for (const item of data)
+                flatData.push(...item.toArray());
+        }
+        return new Float32Array(flatData);
+    }
+    internalFormat() {
+        const gl = this.gl;
+        return {
+            1: gl.R32F,
+            2: gl.RG32F,
+            3: gl.RGB32F,
+            4: gl.RGBA32F,
+        }[this.spec.dimension];
+    }
+    format() {
+        const gl = this.gl;
+        return {
+            1: gl.RED,
+            2: gl.RG,
+            3: gl.RGB,
+            4: gl.RGBA,
+        }[this.spec.dimension];
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Vec3 } from "../geometry/vec3.js";
+import { Vec4 } from "../geometry/vec4.js";
+import { ParsedUniform } from "./helpers.js";
+export type Uniform = ParsedUniform & {
+    location: WebGLUniformLocation;
+};
+export type UniformMap = Record<string, Uniform>;
+export type ProgramData = {
+    program: WebGLProgram;
+    vao: WebGLVertexArrayObject;
+    uniforms: UniformMap;
+};
+export type UniformPrimitive = number | boolean | Vec2 | Vec3 | Vec4 | Array<boolean>;
+export type UniformValue = UniformPrimitive | Array<UniformPrimitive>;
+export type UniformData = Record<string, UniformValue>;
+export declare const vecClasses: readonly [typeof Vec2, typeof Vec3, typeof Vec4];

package/dist/shader-renderer/types.js

@@ -0,0 +1,4 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Vec3 } from "../geometry/vec3.js";
+import { Vec4 } from "../geometry/vec4.js";
+export const vecClasses = [Vec2, Vec3, Vec4];

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

@@ -0,0 +1,16 @@
+import { UniformMap } from "./types.js";
+export declare class UniformHandler {
+    gl: WebGL2RenderingContext;
+    uniforms: UniformMap;
+    constructor(gl: WebGL2RenderingContext, uniforms: UniformMap);
+    setUniform(name: string, value: any): void;
+    private throwError;
+    private setFloatUniform;
+    private setIntUniform;
+    private setBoolUniform;
+    private setVecUniform;
+    private setIVecUniform;
+    private setBVecUniform;
+    private setMatUniform;
+    private processUniformValue;
+}

package/dist/shader-renderer/uniform.js

@@ -0,0 +1,134 @@
+import { vecClasses } from "./types.js";
+export class UniformHandler {
+    constructor(gl, uniforms) {
+        this.gl = gl;
+        this.uniforms = uniforms;
+    }
+    setUniform(name, value) {
+        const uniform = this.uniforms[name];
+        if (!uniform)
+            throw new Error(`Uniform with name ${name} not found`);
+        const processedValue = this.processUniformValue(uniform, value);
+        const { type } = uniform;
+        if (type === "float") {
+            this.setFloatUniform(uniform, processedValue);
+        }
+        else if (type === "int") {
+            this.setIntUniform(uniform, processedValue);
+        }
+        else if (type === "bool") {
+            this.setBoolUniform(uniform, processedValue);
+        }
+        else if (type.startsWith("vec")) {
+            this.setVecUniform(uniform, processedValue);
+        }
+        else if (type.startsWith("ivec")) {
+            this.setIVecUniform(uniform, processedValue);
+        }
+        else if (type.startsWith("bvec")) {
+            this.setBVecUniform(uniform, processedValue);
+        }
+        else if (type.startsWith("mat")) {
+            this.setMatUniform(uniform, processedValue);
+        }
+        else {
+            throw new Error(`Invalid uniform type: ${type}`);
+        }
+    }
+    throwError(uniform, error, value) {
+        const { name } = uniform;
+        throw new Error(`Error when setting ${name}: ${error} value: ${JSON.stringify(value)}`);
+    }
+    setFloatUniform(uniform, value) {
+        if (value.some((v) => typeof v !== "number"))
+            this.throwError(uniform, `not all values are numbers.`, value);
+        this.gl.uniform1fv(uniform.location, value);
+    }
+    setIntUniform(uniform, value) {
+        if (!allAreInt(value))
+            this.throwError(uniform, `not all values are integers.`, value);
+        this.gl.uniform1iv(uniform.location, value);
+    }
+    setBoolUniform(uniform, value) {
+        if (!allAreBool(value))
+            this.throwError(uniform, `not all values are booleans.`, value);
+        this.gl.uniform1iv(uniform.location, value.map((v) => v ? 1 : 0));
+    }
+    setVecUniform(uniform, value) {
+        if (!allAreVec(value))
+            this.throwError(uniform, `not all values are VecN.`, value);
+        const array = value
+            .map((v) => v.toArray())
+            .flat();
+        switch (uniform.type) {
+            case "vec4": return this.gl.uniform4fv(uniform.location, array);
+            case "vec3": return this.gl.uniform3fv(uniform.location, array);
+            case "vec2": return this.gl.uniform2fv(uniform.location, array);
+        }
+    }
+    setIVecUniform(uniform, value) {
+        if (!allAreVec(value))
+            this.throwError(uniform, `not all values are Vec.`, value);
+        const array = value.map((v) => v.toArray()).flat();
+        if (!allAreInt(array))
+            this.throwError(uniform, `not all entries are integers.`, array);
+        switch (uniform.type) {
+            case "ivec4": return this.gl.uniform4iv(uniform.location, array);
+            case "ivec3": return this.gl.uniform3iv(uniform.location, array);
+            case "ivec2": return this.gl.uniform2iv(uniform.location, array);
+        }
+    }
+    setBVecUniform(uniform, value) {
+        if (!value.every(allAreBool))
+            this.throwError(uniform, `not all values are arrays of booleans.`, value);
+        const array = value
+            .flat()
+            .map((v) => v ? 1 : 0);
+        switch (uniform.type) {
+            case "bvec4": return this.gl.uniform4iv(uniform.location, array);
+            case "bvec3": return this.gl.uniform3iv(uniform.location, array);
+            case "bvec2": return this.gl.uniform2iv(uniform.location, array);
+        }
+    }
+    setMatUniform(_uniform, _value) {
+        throw new Error("Not implemented yet");
+    }
+    processUniformValue(uniform, value) {
+        const { type, isArray } = uniform;
+        let wrappedValue = [];
+        // Start with types that are arrays of arrays
+        if (type.startsWith("bvec") || type.startsWith("mat")) {
+            if (isArray) {
+                if (!Array.isArray(value) || !Array.isArray(value[0]))
+                    this.throwError(uniform, `Expected array of arrays.`, value);
+                wrappedValue = value;
+            }
+            else {
+                if (Array.isArray(value[0]))
+                    this.throwError(uniform, `Expected array of values.`, value);
+                wrappedValue = [value];
+            }
+        }
+        else {
+            if (!isArray && Array.isArray(value))
+                this.throwError(uniform, `Expected non-array.`, value);
+            wrappedValue = Array.isArray(value) ? value : [value];
+        }
+        if (isArray) {
+            if (!Array.isArray(value))
+                this.throwError(uniform, `Array value expected.`, value);
+            if (value.length !== uniform.arraySize)
+                this.throwError(uniform, `Invalid array length, expected size ${uniform.arraySize}, received ${value.length}`);
+        }
+        return wrappedValue;
+    }
+}
+function allAreVec(value) {
+    return value.every((v) => vecClasses.some((C) => v instanceof C));
+}
+function allAreInt(value) {
+    return value.every((v) => typeof v === "number" && Math.floor(v) === v);
+}
+function allAreBool(value) {
+    return value.every((v) => typeof v === "boolean");
+}

package/dist/tilings/delaunay.d.ts

@@ -0,0 +1,11 @@
+import { Polygon } from "../geometry/polygon.js";
+import { RNG } from "../utilities/rng.js";
+import { PointSamplerStrategy } from "../utilities/point-sampler.js";
+import { Hollowgon } from "../geometry/hollowgon.js";
+export type DelaunaySubdivisionOptions = {
+    shape: Polygon | Hollowgon;
+    numPoints: number;
+    rng: RNG;
+    strategy?: PointSamplerStrategy;
+};
+export declare function delaunaySubdivision(options: DelaunaySubdivisionOptions): Polygon[];

package/dist/tilings/delaunay.js

@@ -0,0 +1,28 @@
+import { Delaunay } from "d3-delaunay";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2 } from "../geometry/vec2.js";
+import { pointSampler } from "../utilities/point-sampler.js";
+import { clip } from "../geometry/polygon-operations.js";
+import { Hollowgon } from "../geometry/hollowgon.js";
+export function delaunaySubdivision(options) {
+    const { shape, numPoints, rng, strategy = "poisson" } = options;
+    const pointBuffer = [];
+    for (const { x, y } of pointSampler({ shape, size: numPoints, strategy, rng })) {
+        pointBuffer.push(x, y);
+    }
+    // TODO figure out if there is a way to triangulate directly on polygon with holes
+    const vertices = shape instanceof Hollowgon ? shape.boundary.vertices : shape.vertices;
+    for (const { x, y } of vertices)
+        pointBuffer.push(x, y);
+    const delaunay = new Delaunay(pointBuffer);
+    let triangles = delaunay.trianglePolygons();
+    const polygons = [];
+    for (const triangle of triangles) {
+        const vertices = [];
+        for (const vertex of triangle) {
+            vertices.push(vec2(vertex[0], vertex[1]));
+        }
+        polygons.push(new Polygon(vertices));
+    }
+    return clip(polygons, shape);
+}

package/dist/tilings/grid.d.ts

@@ -0,0 +1,5 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { OperationShape } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function gridSubdivision(shape: Polygon, rotation: number, resolution: number): Array<Polygon>;
+export declare function gridSubdivision(shape: Hollowgon, rotation: number, resolution: number): Array<OperationShape>;

package/dist/tilings/grid.js

@@ -0,0 +1,29 @@
+import { Line } from "../geometry/line.js";
+import { subdivide } from "../geometry/polygon-operations.js";
+import { Vec2, vec2 } from "../geometry/vec2.js";
+export function gridSubdivision(shape, rotation, resolution) {
+    const centroid = shape.centroid();
+    const { xMin, yMin, width, height, aspectRatio } = shape
+        .clone()
+        .rotate(-rotation, centroid)
+        .aabb();
+    const [columns, rows] = aspectRatio > 1 ?
+        [Math.round(aspectRatio * resolution), resolution] :
+        [resolution, Math.round(resolution / aspectRatio)];
+    const columnSpacing = width / columns;
+    let polygons = [shape];
+    let cutDirection = Vec2.fromPolar(1, Math.PI / 2 + rotation);
+    for (let i = 1; i < columns; i++) {
+        const point = vec2(xMin + columnSpacing * i, yMin - 1).rotate(rotation, centroid);
+        const cutLine = new Line(point, cutDirection);
+        polygons = subdivide(polygons, cutLine);
+    }
+    const rowSpacing = height / rows;
+    cutDirection = Vec2.fromPolar(1, rotation);
+    for (let i = 1; i < rows; i++) {
+        const point = vec2(xMin - 1, yMin + rowSpacing * i).rotate(rotation, centroid);
+        const cutLine = new Line(point, cutDirection);
+        polygons = subdivide(polygons, cutLine);
+    }
+    return polygons;
+}

package/dist/tilings/hexagononal.d.ts

@@ -0,0 +1,4 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function hexagonalTiling(shape: Polygon | Hollowgon, rotation: number, resolution: number): Polygon[];
+export declare function hexagonalTileHelper(shape: Polygon | Hollowgon, rotation: number, resolution: number): Polygon[];

package/dist/tilings/hexagononal.js

@@ -0,0 +1,40 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2 } from "../geometry/vec2.js";
+const SQRT_3 = Math.sqrt(3);
+export function hexagonalTiling(shape, rotation, resolution) {
+    const polygons = hexagonalTileHelper(shape, rotation, resolution);
+    for (const polygon of polygons)
+        polygon.rotate(rotation, shape.centroid());
+    return clip(polygons, shape);
+}
+export function hexagonalTileHelper(shape, rotation, resolution) {
+    const { xMin, xMax, yMin, width, height, aspectRatio } = shape
+        .clone()
+        .rotate(-rotation, shape.centroid())
+        .aabb();
+    const size = (aspectRatio > 1 ? 1.5 * height : Math.sqrt(3) * width) / resolution;
+    const hexagonWidth = Math.sqrt(3) * size;
+    const hexagonHeight = 1.5 * size;
+    const columns = Math.ceil(width / hexagonWidth);
+    // Compensate for hexagon height portion that is tapered
+    const rows = Math.ceil((height + 0.5 * size) / hexagonHeight);
+    let polygons = [];
+    for (let row = 0; row < rows; row++) {
+        const y0 = yMin + row * hexagonHeight;
+        for (let column = row % 2 === 0 ? 0 : -0.5; column < columns; column++) {
+            const x0 = xMin + column * hexagonWidth;
+            if (x0 > xMax)
+                break;
+            polygons.push(new Polygon([
+                vec2(x0, y0),
+                vec2(x0 + 0.5 * SQRT_3 * size, y0 - 0.5 * size),
+                vec2(x0 + SQRT_3 * size, y0),
+                vec2(x0 + SQRT_3 * size, y0 + size),
+                vec2(x0 + 0.5 * SQRT_3 * size, y0 + 1.5 * size),
+                vec2(x0, y0 + size),
+            ]));
+        }
+    }
+    return polygons;
+}

package/dist/tilings/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./delaunay.js";
+export * from "./grid.js";
+export * from "./hexagononal.js";
+export * from "./line.js";
+export * from "./pythagorean.js";
+export * from "./random-cuts.js";
+export * from "./recursive-cuts.js";
+export * from "./rhombille.js";
+export * from "./rightangled-triangle.js";
+export * from "./triangle.js";
+export * from "./voronoi.js";
+export * from "./mediterranean.js";

package/dist/tilings/index.js

@@ -0,0 +1,12 @@
+export * from "./delaunay.js";
+export * from "./grid.js";
+export * from "./hexagononal.js";
+export * from "./line.js";
+export * from "./pythagorean.js";
+export * from "./random-cuts.js";
+export * from "./recursive-cuts.js";
+export * from "./rhombille.js";
+export * from "./rightangled-triangle.js";
+export * from "./triangle.js";
+export * from "./voronoi.js";
+export * from "./mediterranean.js";

package/dist/tilings/line.d.ts

@@ -0,0 +1,5 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { OperationShape } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function lineSubdivision(shape: Polygon, rotation: number, columns: number): Array<Polygon>;
+export declare function lineSubdivision(shape: Hollowgon, rotation: number, columns: number): Array<OperationShape>;

package/dist/tilings/line.js

@@ -0,0 +1,19 @@
+import { Line } from "../geometry/line.js";
+import { subdivide } from "../geometry/polygon-operations.js";
+import { Vec2, vec2 } from "../geometry/vec2.js";
+export function lineSubdivision(shape, rotation, columns) {
+    const centroid = shape.centroid();
+    const { xMin, yMin, width } = shape
+        .clone()
+        .rotate(-rotation, centroid)
+        .aabb();
+    const spacing = width / columns;
+    let polygons = [shape];
+    const cutDirection = Vec2.fromPolar(1, Math.PI / 2 + rotation);
+    for (let i = 1; i < columns; i++) {
+        const point = vec2(xMin + spacing * i, yMin - 1).rotate(rotation, centroid);
+        const cutLine = new Line(point, cutDirection);
+        polygons = subdivide(polygons, cutLine);
+    }
+    return polygons;
+}