@divinevoxel/vlox 0.0.4 → 0.0.6

package/Mesher/Geomtry/Buffers.d.ts

@@ -0,0 +1,19 @@
+export interface VoxelVertexBuffer {
+    [index: number]: number;
+}
+export declare class VoxelVertexBuffer {
+    vertexFloatSize: number;
+    sectorVertexSize: number;
+    _buffers: Float32Array[];
+    constructor(vertexFloatSize: number, sectorVertexSize: number, startingSectorSize?: number);
+    get length(): number;
+}
+export interface VoxelIndiceBuffer {
+    [index: number]: number;
+}
+export declare class VoxelIndiceBuffer {
+    sectorSize: number;
+    _buffers: Uint32Array[];
+    constructor(sectorSize: number, startingSectorSize?: number);
+    get length(): number;
+}

package/Mesher/Geomtry/Buffers.js

@@ -0,0 +1,81 @@
+export class VoxelVertexBuffer {
+    vertexFloatSize;
+    sectorVertexSize;
+    _buffers = [];
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+        this.vertexFloatSize = vertexFloatSize;
+        this.sectorVertexSize = sectorVertexSize;
+        const sectorSize = vertexFloatSize * sectorVertexSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Float32Array(sectorSize));
+        }
+        const array = this;
+        return new Proxy([], {
+            get: (target, property) => {
+                if (property == "length")
+                    return array.length;
+                if (property == "_buffers")
+                    return array._buffers;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    this._buffers[bufferIndex] = new Float32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                return array._buffers[bufferIndex][arrayIndex];
+            },
+            set: (target, property, value) => {
+                if (property == "length")
+                    return false;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    array._buffers[bufferIndex] = new Float32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                array._buffers[bufferIndex][arrayIndex] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this._buffers.length * this.vertexFloatSize;
+    }
+}
+export class VoxelIndiceBuffer {
+    sectorSize;
+    _buffers = [];
+    constructor(sectorSize, startingSectorSize = 4) {
+        this.sectorSize = sectorSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Uint32Array(sectorSize));
+        }
+        const array = this;
+        return new Proxy([], {
+            get: (target, property) => {
+                if (property == "length")
+                    return array.length;
+                if (property == "_buffers")
+                    return array._buffers;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    this._buffers[bufferIndex] = new Uint32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                return array._buffers[bufferIndex][arrayIndex];
+            },
+            set: (target, property, value) => {
+                if (property == "length")
+                    return false;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    array._buffers[bufferIndex] = new Uint32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                array._buffers[bufferIndex][arrayIndex] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this._buffers.length * this.sectorSize;
+    }
+}

package/Mesher/Geomtry/Geometry.types.d.ts

@@ -0,0 +1,11 @@
+import type { Vec2Array, Vec3Array } from "@amodx/math";
+export type QuadVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+export type QuadVertexFloatData = [number, number, number, number];
+export type QuadUVData = [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
+export declare enum QuadVerticies {
+    TopRight = 0,
+    TopLeft = 1,
+    BottomLeft = 2,
+    BottomRight = 3
+}
+export declare const QuadVerticiesArray: QuadVerticies[];

package/Mesher/Geomtry/Geometry.types.js

@@ -0,0 +1,13 @@
+export var QuadVerticies;
+(function (QuadVerticies) {
+    QuadVerticies[QuadVerticies["TopRight"] = 0] = "TopRight";
+    QuadVerticies[QuadVerticies["TopLeft"] = 1] = "TopLeft";
+    QuadVerticies[QuadVerticies["BottomLeft"] = 2] = "BottomLeft";
+    QuadVerticies[QuadVerticies["BottomRight"] = 3] = "BottomRight";
+})(QuadVerticies || (QuadVerticies = {}));
+export const QuadVerticiesArray = [
+    QuadVerticies.TopRight,
+    QuadVerticies.TopLeft,
+    QuadVerticies.BottomLeft,
+    QuadVerticies.BottomRight,
+];

package/Mesher/Geomtry/GeometryNormals.d.ts

@@ -0,0 +1,10 @@
+import type { Vec3Array } from "@amodx/math";
+export declare class GeometryNormals {
+    static subtract(v1: Vec3Array, v2: Vec3Array): Vec3Array;
+    static cross(v1: Vec3Array, v2: Vec3Array): Vec3Array;
+    static scale(v: Vec3Array, scaleFactor: number): Vec3Array;
+    static add(v1: Vec3Array, v2: Vec3Array): Vec3Array;
+    static normalize(v: Vec3Array): Vec3Array;
+    static getTriangleNormals(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array): Vec3Array;
+    static getQuadNormal(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
+}

package/Mesher/Geomtry/GeometryNormals.js

@@ -0,0 +1,52 @@
+export class GeometryNormals {
+    static subtract(v1, v2) {
+        return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
+    }
+    static cross(v1, v2) {
+        return [
+            v1[1] * v2[2] - v1[2] * v2[1],
+            v1[2] * v2[0] - v1[0] * v2[2],
+            v1[0] * v2[1] - v1[1] * v2[0],
+        ];
+    }
+    static scale(v, scaleFactor) {
+        return [v[0] * scaleFactor, v[1] * scaleFactor, v[2] * scaleFactor];
+    }
+    static add(v1, v2) {
+        return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
+    }
+    static normalize(v) {
+        const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+        return length > 0
+            ? [v[0] / length, v[1] / length, v[2] / length]
+            : [0, 0, 0];
+    }
+    static getTriangleNormals(p1, p2, p3) {
+        const a = this.subtract(p2, p1);
+        const b = this.subtract(p3, p1);
+        const substract = this.cross(a, b);
+        const normal = this.scale(substract, -1);
+        return this.normalize(normal);
+    }
+    static getQuadNormal(p1, p2, p3, p4) {
+        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        const normalA = this.normalize(this.cross(vectorA1, vectorA2));
+        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
+        const normalB = this.normalize(this.cross(vectorB1, vectorB2));
+        const n1 = this.normalize([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n2 = normalA;
+        const n3 = this.normalize([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n4 = normalB;
+        return [n1, n2, n3, n4];
+    }
+}

package/Mesher/Geomtry/MeshData.types.d.ts

@@ -0,0 +1,13 @@
+import type { TypedArrays } from "@amodx/binary";
+export declare enum MeshDefaultAttributes {
+    Position = "position",
+    Normal = "normal",
+    Indices = "indices"
+}
+export type MeshAttributes = [
+    id: string,
+    data: TypedArrays,
+    stride: number,
+    componentTypes?: number,
+    noramlizer?: number
+][];

package/Mesher/Geomtry/MeshData.types.js

@@ -0,0 +1,6 @@
+export var MeshDefaultAttributes;
+(function (MeshDefaultAttributes) {
+    MeshDefaultAttributes["Position"] = "position";
+    MeshDefaultAttributes["Normal"] = "normal";
+    MeshDefaultAttributes["Indices"] = "indices";
+})(MeshDefaultAttributes || (MeshDefaultAttributes = {}));

package/Mesher/Geomtry/Primitives/Quad.d.ts

@@ -0,0 +1,38 @@
+import { Vec2Array, Vec3Array } from "@amodx/math";
+import { QuadVector2VertexData, QuadVector3VertexData } from "./QuadVertexData";
+import { QuadUVData, QuadVertexVec3Data, QuadVerticies } from "../Geometry.types";
+export declare class Quad {
+    static FullUVs: Readonly<QuadUVData>;
+    static RotateUvs(uvs: QuadUVData | Readonly<QuadUVData>, rotation: number): QuadUVData;
+    static Create(positions?: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array], uvs?: [Vec2Array, Vec2Array, Vec2Array, Vec2Array], doubleSided?: boolean, orientation?: 0 | 1): Quad;
+    static RotateVertices90Degrees(vertices: [QuadVerticies, QuadVerticies, QuadVerticies, QuadVerticies], times?: number): [QuadVerticies, QuadVerticies, QuadVerticies, QuadVerticies];
+    static GetQuadNormalRightHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
+    static GetQuadNormalLeftHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
+    static CalculateQuadPoints(start: Vec3Array, end: Vec3Array): {
+        points: QuadVertexVec3Data;
+        normal: Vec3Array;
+    };
+    static OrderQuadVertices(vertices: [Vec3Array, Vec3Array, Vec3Array, Vec3Array], direction: "north" | "south" | "east" | "west" | "up" | "down"): [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+    positions: QuadVector3VertexData;
+    normals: QuadVector3VertexData;
+    uvs: QuadVector2VertexData;
+    flip: boolean;
+    doubleSided: boolean;
+    orientation: 0 | 1;
+    constructor(data: {
+        positions?: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+        uvs?: [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
+        doubleSided?: boolean;
+        orientation?: 0 | 1;
+    });
+    setUVs([v1, v2, v3, v4]: [
+        v1: Vec2Array,
+        v2: Vec2Array,
+        v3: Vec2Array,
+        v4: Vec2Array
+    ]): this;
+    scale(x: number, y: number, z: number): this;
+    transform(x: number, y: number, z: number): this;
+    setPositions(positions: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array]): this;
+    clone(): Quad;
+}

package/Mesher/Geomtry/Primitives/Quad.js

@@ -0,0 +1,224 @@
+import { Matrix3x3Like, Vector2Like, Vector3Like, } from "@amodx/math";
+import { QuadVector2VertexData, QuadVector3VertexData } from "./QuadVertexData";
+export class Quad {
+    static FullUVs = Object.freeze([
+        [1, 1],
+        [0, 1],
+        [0, 0],
+        [1, 0],
+    ]);
+    static RotateUvs(uvs, rotation) {
+        const rotationMatrix = Matrix3x3Like.RotationZ(rotation);
+        const pivot = [0.5, 0.5];
+        const rotatedUVs = [
+            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[0], pivot),
+            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[1], pivot),
+            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[2], pivot),
+            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[3], pivot),
+        ];
+        return rotatedUVs;
+    }
+    static Create(positions, uvs, doubleSided, orientation) {
+        return new Quad({ positions, uvs, doubleSided, orientation });
+    }
+    static RotateVertices90Degrees(vertices, times = 1) {
+        while (times--) {
+            vertices = [vertices[1], vertices[2], vertices[3], vertices[0]];
+        }
+        return vertices;
+    }
+    static GetQuadNormalRightHanded(p1, p2, p3, p4) {
+        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        const normalA = Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorA1, vectorA2));
+        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
+        const normalB = Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorB1, vectorB2));
+        const n1 = Vector3Like.NormalizeArray([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n2 = normalA;
+        const n3 = Vector3Like.NormalizeArray([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n4 = normalB;
+        const normals = [n1, n2, n3, n4];
+        for (let i = 0; i < normals.length; i++) {
+            const n = normals[i];
+            for (let j = 0; j < 3; j++) {
+                if (Math.abs(n[j]) === 0)
+                    n[j] = 0;
+            }
+        }
+        return normals;
+    }
+    static GetQuadNormalLeftHanded(p1, p2, p3, p4) {
+        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        // Reverse the cross product direction for left-handed system
+        const normalA = Vector3Like.MultiplyScalarArray(Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorA1, vectorA2)), -1);
+        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
+        // Reverse the cross product direction for left-handed system
+        const normalB = Vector3Like.MultiplyScalarArray(Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorB1, vectorB2)), -1);
+        const n1 = Vector3Like.NormalizeArray([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n2 = normalA;
+        const n3 = Vector3Like.NormalizeArray([
+            (normalA[0] + normalB[0]) / 2,
+            (normalA[1] + normalB[1]) / 2,
+            (normalA[2] + normalB[2]) / 2,
+        ]);
+        const n4 = normalB;
+        const normals = [n1, n2, n3, n4];
+        for (let i = 0; i < normals.length; i++) {
+            const n = normals[i];
+            for (let j = 0; j < 3; j++) {
+                if (Math.abs(n[j]) === 0)
+                    n[j] = 0;
+            }
+        }
+        return normals;
+    }
+    static CalculateQuadPoints(start, end) {
+        const plane = start
+            .map((value, index) => (end[index] !== value ? index : -1))
+            .filter((index) => index !== -1);
+        let topLeft, bottomRight;
+        const topRight = end;
+        const bottomLeft = start;
+        if (plane.includes(0) && plane.includes(2)) {
+            // XZ plane
+            topLeft = [start[0], start[1], end[2]];
+            bottomRight = [end[0], start[1], start[2]];
+        }
+        else if (plane.includes(0) && plane.includes(1)) {
+            // XY plane
+            topLeft = [start[0], end[1], start[2]];
+            bottomRight = [end[0], start[1], start[2]];
+        }
+        else if (plane.includes(1) && plane.includes(2)) {
+            // YZ plane
+            topLeft = [start[0], end[1], start[2]];
+            bottomRight = [start[0], start[1], end[2]];
+        }
+        const delta = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
+        let normal = [0, 0, 0];
+        if (delta[0] === 0) {
+            // Constant X, so normal is along X
+            normal[0] = 1;
+        }
+        else if (delta[1] === 0) {
+            // Constant Y, so normal is along Y
+            normal[1] = 1;
+        }
+        else if (delta[2] === 0) {
+            // Constant Z, so normal is along Z
+            normal[2] = 1;
+        }
+        return {
+            points: [topRight, topLeft, bottomLeft, bottomRight],
+            normal,
+        };
+    }
+    static OrderQuadVertices(vertices, direction) {
+        const projections = {
+            north: (v) => [v[0], v[1]],
+            south: (v) => [v[0], v[1]],
+            east: (v) => [v[2], v[1]],
+            west: (v) => [v[2], v[1]],
+            up: (v) => [v[0], v[2]],
+            down: (v) => [v[0], v[2]],
+        };
+        // Project vertices onto the 2D plane
+        const projectedVertices = vertices.map((v) => projections[direction](v));
+        // Calculate the center of the quad
+        const center = [
+            (projectedVertices[0][0] +
+                projectedVertices[1][0] +
+                projectedVertices[2][0] +
+                projectedVertices[3][0]) /
+                4,
+            (projectedVertices[0][1] +
+                projectedVertices[1][1] +
+                projectedVertices[2][1] +
+                projectedVertices[3][1]) /
+                4,
+        ];
+        // Function to calculate the angle relative to the center
+        const angleFromCenter = (v) => Math.atan2(v[1] - center[1], v[0] - center[0]);
+        // Map vertices to their angles
+        const verticesWithAngles = vertices.map((v, i) => ({
+            vertex: v,
+            angle: angleFromCenter(projectedVertices[i]),
+        }));
+        // Sort vertices by angle
+        verticesWithAngles.sort((a, b) => a.angle - b.angle);
+        // Return sorted vertices in the order of Top Right, Top Left, Bottom Left, Bottom Right
+        return [
+            verticesWithAngles[2].vertex,
+            verticesWithAngles[3].vertex,
+            verticesWithAngles[0].vertex,
+            verticesWithAngles[1].vertex,
+        ];
+    }
+    positions = new QuadVector3VertexData();
+    normals = new QuadVector3VertexData();
+    uvs = new QuadVector2VertexData();
+    flip = false;
+    doubleSided = false;
+    orientation = 0;
+    constructor(data) {
+        if (data.positions)
+            this.setPositions(data.positions);
+        if (data.uvs)
+            this.setUVs(data.uvs);
+        if (data.doubleSided)
+            this.doubleSided = data.doubleSided;
+        if (data.orientation !== undefined)
+            this.orientation = data.orientation;
+    }
+    setUVs([v1, v2, v3, v4]) {
+        this.uvs.set(Vector2Like.FromArray(v1), Vector2Like.FromArray(v2), Vector2Like.FromArray(v3), Vector2Like.FromArray(v4));
+        return this;
+    }
+    scale(x, y, z) {
+        const scale = Vector3Like.Create(x, y, z);
+        for (const position of this.positions) {
+            Vector3Like.MultiplyInPlace(position, scale);
+        }
+        return this;
+    }
+    transform(x, y, z) {
+        const transform = Vector3Like.Create(x, y, z);
+        for (const position of this.positions) {
+            Vector3Like.AddInPlace(position, transform);
+        }
+        return this;
+    }
+    setPositions(positions) {
+        if (positions.length == 2) {
+            const { points, normal } = Quad.CalculateQuadPoints(positions[0], positions[1]);
+            this.positions.set(Vector3Like.FromArray(points[0]), Vector3Like.FromArray(points[1]), Vector3Like.FromArray(points[2]), Vector3Like.FromArray(points[3]));
+            this.normals.set(Vector3Like.FromArray(normal), Vector3Like.FromArray(normal), Vector3Like.FromArray(normal), Vector3Like.FromArray(normal));
+        }
+        if (positions.length == 4) {
+            const [n1, n2, n3, n4] = Quad.GetQuadNormalLeftHanded(...positions);
+            this.positions.set(Vector3Like.FromArray(positions[0]), Vector3Like.FromArray(positions[1]), Vector3Like.FromArray(positions[2]), Vector3Like.FromArray(positions[3]));
+            this.normals.set(Vector3Like.FromArray(n1), Vector3Like.FromArray(n2), Vector3Like.FromArray(n3), Vector3Like.FromArray(n4));
+        }
+        return this;
+    }
+    clone() {
+        return Quad.Create(this.positions
+            .getAsArray()
+            .map((_) => Vector3Like.ToArray(_)), this.uvs.getAsArray().map((_) => Vector2Like.ToArray(_)));
+    }
+}

package/Mesher/Geomtry/Primitives/QuadVertexData.d.ts

@@ -0,0 +1,66 @@
+import { QuadVerticies } from "../Geometry.types.js";
+import { Vector3Like, Vector2Like, Vec3Array } from "@amodx/math";
+export declare class QuadVertexData<Data> {
+    vertices: Record<QuadVerticies, Data>;
+    constructor(vertices: Record<QuadVerticies, Data>);
+    getAsArray(): Data[];
+    setVertex(vertex: QuadVerticies, value: Data): void;
+    getVertex(vertex: QuadVerticies): Data;
+    setAll(value: Data): void;
+    set(v1: Data, v2: Data, v3: Data, v4: Data): void;
+    isEqualTo(v1: Data, v2: Data, v3: Data, v4: Data): boolean;
+    isAllEqualTo(value: Data): boolean;
+    [Symbol.iterator](): Iterator<Data>;
+    clone(): QuadVertexData<Data>;
+}
+export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
+    vertices: Record<QuadVerticies, Vec3Array>;
+    constructor(vertices?: Record<QuadVerticies, Vec3Array>);
+    setFromQuadData(vertexData: QuadVertexData<Vec3Array>): void;
+    addToVertex(vertex: QuadVerticies, value: Vec3Array): void;
+    subtractFromVertex(vertex: QuadVerticies, value: Vec3Array): void;
+    addAll(value: Vec3Array): void;
+    subtractAll(value: Vec3Array): void;
+    isEqualTo(v1: Vec3Array, v2: Vec3Array, v3: Vec3Array, v4: Vec3Array): boolean;
+    isAllEqualTo(v1: Vec3Array): boolean;
+    clone(): QuadVec3ArrayVertexData;
+}
+export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
+    vertices: Record<QuadVerticies, Vector3Like>;
+    constructor(vertices?: Record<QuadVerticies, Vector3Like>);
+    setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
+    addToVertex(vertex: QuadVerticies, value: Vector3Like): void;
+    subtractFromVertex(vertex: QuadVerticies, value: Vector3Like): void;
+    addAll(value: Vector3Like): void;
+    subtractAll(value: Vector3Like): void;
+    isEqualTo(v1: Vector3Like, v2: Vector3Like, v3: Vector3Like, v4: Vector3Like): boolean;
+    isAllEqualTo(v1: Vector3Like): boolean;
+    clone(): QuadVector3VertexData;
+}
+export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
+    vertices: Record<QuadVerticies, Vector2Like>;
+    constructor(vertices?: Record<QuadVerticies, Vector2Like>);
+    setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
+    addToVertex(vertex: QuadVerticies, value: Vector2Like): void;
+    subtractFromVertex(vertex: QuadVerticies, value: Vector2Like): void;
+    addAll(value: Vector2Like): void;
+    subtractAll(value: Vector2Like): void;
+    isEqualTo(v1: Vector2Like, v2: Vector2Like, v3: Vector2Like, v4: Vector2Like): boolean;
+    isAllEqualTo(v1: Vector2Like): boolean;
+    clone(): QuadVector2VertexData;
+}
+export declare class QuadScalarVertexData extends QuadVertexData<number> {
+    vertices: Record<QuadVerticies, number>;
+    constructor(vertices?: Record<QuadVerticies, number>);
+    setFromQuadData(vertexData: QuadVertexData<number>): void;
+    subtractFromVertex(vertex: QuadVerticies, value: number): void;
+    addAll(value: number): void;
+    add(v1: number, v2: number, v3: number, v4: number): void;
+    subtractAll(value: number): void;
+    subtract(v1: number, v2: number, v3: number, v4: number): void;
+    isGreaterThan(v1: number, v2: number, v3: number, v4: number): boolean;
+    isAllGreaterThan(value: number): boolean;
+    isLessThan(v1: number, v2: number, v3: number, v4: number): boolean;
+    isAllLessThan(value: number): boolean;
+    clone(): QuadScalarVertexData;
+}