@divinevoxel/vlox 0.0.0

package/Util/DataMatrix.js

@@ -0,0 +1,90 @@
+export class DataMatrix {
+    size;
+    defaultValue;
+    _matrix;
+    constructor(size, defaultValue) {
+        this.size = size;
+        this.defaultValue = defaultValue;
+        this._matrix = [];
+        this.setAll(defaultValue);
+    }
+    get sizeX() {
+        return this.size[0];
+    }
+    get sizeY() {
+        return this.size[1];
+    }
+    get sizeZ() {
+        return this.size[2];
+    }
+    setMatrix(matrix) {
+        this._matrix = matrix;
+    }
+    cloneMatrix() {
+        return structuredClone(this._matrix);
+    }
+    setVec3([x, y, z], value) {
+        if (!this.isWithinBounds(x, y, z))
+            return;
+        if (!this._matrix[x])
+            this._matrix[x] = [];
+        if (!this._matrix[x][y])
+            this._matrix[x][y] = [];
+        this._matrix[x][y][z] = value;
+    }
+    setXYZ(x, y, z, value) {
+        this.setVec3([x, y, z], value);
+    }
+    getVec3([x, y, z]) {
+        return this.isWithinBounds(x, y, z) ? this._matrix[x]?.[y]?.[z] : undefined;
+    }
+    getXYZ(x, y, z) {
+        return this.getVec3([x, y, z]);
+    }
+    deleteVec3([x, y, z]) {
+        if (this.isWithinBounds(x, y, z))
+            this._matrix[x][y][z] = this.defaultValue;
+    }
+    deleteXYZ(x, y, z) {
+        this.deleteVec3([x, y, z]);
+    }
+    setAll(value) {
+        for (let x = 0; x < this.size[0]; x++) {
+            this._matrix[x] = [];
+            for (let y = 0; y < this.size[1]; y++) {
+                this._matrix[x][y] = [];
+                for (let z = 0; z < this.size[2]; z++) {
+                    this._matrix[x][y][z] = value;
+                }
+            }
+        }
+    }
+    *getAll() {
+        for (let x = 0; x < this.size[0]; x++) {
+            for (let y = 0; y < this.size[1]; y++) {
+                for (let z = 0; z < this.size[2]; z++) {
+                    yield [[x, y, z], this._matrix[x][y][z]];
+                }
+            }
+        }
+    }
+    swap(startPosition, endPosition) {
+        const startValue = this.getVec3(startPosition);
+        const endValue = this.getVec3(endPosition);
+        if (startValue !== undefined && endValue !== undefined) {
+            this.setVec3(startPosition, endValue);
+            this.setVec3(endPosition, startValue);
+        }
+    }
+    isCube() {
+        return this.sizeX === this.sizeY && this.sizeZ === this.sizeX;
+    }
+    isWithinBounds(x, y, z) {
+        return (x >= 0 &&
+            x < this.size[0] &&
+            y >= 0 &&
+            y < this.size[1] &&
+            z >= 0 &&
+            z < this.size[2]);
+    }
+}

package/Util/LocationVisitedMap.d.ts

@@ -0,0 +1,9 @@
+import { LocationData } from "../Math/index.js";
+export declare class LocationVisitedMap {
+    _map: Map<string, boolean>;
+    get size(): number;
+    has(location: LocationData): boolean;
+    add(location: LocationData): void;
+    remove(location: LocationData): void;
+    clear(): void;
+}

package/Util/LocationVisitedMap.js

@@ -0,0 +1,18 @@
+export class LocationVisitedMap {
+    _map = new Map();
+    get size() {
+        return this._map.size;
+    }
+    has(location) {
+        return this._map.has(location.toString());
+    }
+    add(location) {
+        this._map.set(location.toString(), true);
+    }
+    remove(location) {
+        this._map.delete(location.toString());
+    }
+    clear() {
+        this._map.clear();
+    }
+}

package/Util/VisistedMap.d.ts

@@ -0,0 +1,10 @@
+export declare class VisitedMap {
+    _map: Map<string, boolean>;
+    get size(): number;
+    _getKey(x: number, y: number, z: number): string;
+    inMap(x: number, y: number, z: number): boolean;
+    add(x: number, y: number, z: number): void;
+    remove(x: number, y: number, z: number): void;
+    removeDiffernce(map: VisitedMap): VisitedMap;
+    clear(): void;
+}

package/Util/VisistedMap.js

@@ -0,0 +1,29 @@
+export class VisitedMap {
+    _map = new Map();
+    get size() {
+        return this._map.size;
+    }
+    _getKey(x, y, z) {
+        return `${x}_${y}_${z}`;
+    }
+    inMap(x, y, z) {
+        return this._map.has(this._getKey(x, y, z));
+    }
+    add(x, y, z) {
+        this._map.set(this._getKey(x, y, z), true);
+    }
+    remove(x, y, z) {
+        this._map.delete(this._getKey(x, y, z));
+    }
+    removeDiffernce(map) {
+        for (const [key] of map._map) {
+            if (this._map.has(key)) {
+                this._map.delete(key);
+            }
+        }
+        return map;
+    }
+    clear() {
+        this._map.clear();
+    }
+}

package/Util/VoxelIDMatrix.d.ts

@@ -0,0 +1,15 @@
+import type { Vec3Array } from "@amodx/math";
+import { DataMatrix } from "./DataMatrix.js";
+import { Flat3DIndex } from "@amodx/math/Volumes/Indexing/Flat3DIndex.js";
+import { DataTool } from "../Tools/Data/DataTool";
+export declare class VoxelIDMatrix extends DataMatrix<string | number> {
+    size: Vec3Array;
+    static dataTool: DataTool;
+    index: Flat3DIndex;
+    constructor(size: Vec3Array);
+    setBounds(size: Vec3Array): void;
+    toFlatArray(): number[];
+    toTypedArray(): Uint16Array;
+    fromFlatArray(voxels: ArrayLike<number>): void;
+    copy(matrix: VoxelIDMatrix): void;
+}

package/Util/VoxelIDMatrix.js

@@ -0,0 +1,55 @@
+import { DataMatrix } from "./DataMatrix.js";
+import { Flat3DIndex } from "@amodx/math/Volumes/Indexing/Flat3DIndex.js";
+import { DataTool } from "../Tools/Data/DataTool";
+export class VoxelIDMatrix extends DataMatrix {
+    size;
+    static dataTool = new DataTool();
+    index = Flat3DIndex.GetXYZOrder();
+    constructor(size) {
+        super(size, 0);
+        this.size = size;
+        this.setBounds(size);
+    }
+    setBounds(size) {
+        this.index.setBounds(size[0], size[1], size[2]);
+    }
+    toFlatArray() {
+        const voxels = [];
+        for (const [location, vox] of this.getAll()) {
+            const i = this.index.getIndexVec3Array(location);
+            if (typeof vox !== "string") {
+                voxels[i] = 0;
+                continue;
+            }
+            voxels[i] = VoxelIDMatrix.dataTool.setStringId(vox).getId();
+        }
+        return voxels;
+    }
+    toTypedArray() {
+        const length = this.sizeX * this.sizeY * this.sizeZ;
+        const voxels = new Uint16Array(length);
+        for (const [location, vox] of this.getAll()) {
+            const i = this.index.getIndexVec3Array(location);
+            if (typeof vox !== "string") {
+                voxels[i] = 0;
+                continue;
+            }
+            voxels[i] = VoxelIDMatrix.dataTool.setStringId(vox).getId();
+        }
+        return voxels;
+    }
+    fromFlatArray(voxels) {
+        for (const [location, nodeId] of this.getAll()) {
+            const rawValue = voxels[this.index.getIndexVec3Array(location)];
+            if (!rawValue) {
+                this.setVec3(location, 0);
+                continue;
+            }
+            this.setVec3(location, VoxelIDMatrix.dataTool.setId(rawValue).getStringId());
+        }
+    }
+    copy(matrix) {
+        this.setBounds(matrix.size);
+        this.setMatrix(matrix.cloneMatrix());
+    }
+}

package/VoxelModels/Constructor/InitVoxelModelsConstructor.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
+export default function (DVEC: DivineVoxelEngineConstructor): void;

package/VoxelModels/Constructor/InitVoxelModelsConstructor.js

@@ -0,0 +1,20 @@
+import { VoxelConstructorsRegister } from "../../Mesher/Constructors/Voxel/VoxelConstructorsRegister";
+import { VoxelModelVoxelConstructor } from "./VoxelModelVoxelConstructor";
+import { VoxelModelConstructorRegister } from "./Register/VoxelModelConstructorRegister";
+import { VoxelGeometryLookUp } from "./VoxelGeometryLookUp";
+import { SchemaRegister } from "../State/SchemaRegister";
+export default function (DVEC) {
+    VoxelGeometryLookUp.init();
+    DVEC.TC.registerTasks("sync-voxel-model-data", (data) => {
+        VoxelModelConstructorRegister.setGeometryPalette(data.geometryPalette);
+        VoxelModelConstructorRegister.registerGeometry(data.geometry);
+        VoxelModelConstructorRegister.registerModels(data.models);
+        for (const model of data.models) {
+            SchemaRegister.registerModel(model.id, model.schema);
+        }
+        for (const voxel of data.voxels) {
+            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
+            VoxelConstructorsRegister.registerVoxel(new VoxelModelVoxelConstructor(voxel.id, VoxelModelConstructorRegister.models.get(voxel.modelId), voxel));
+        }
+    });
+}

package/VoxelModels/Constructor/Nodes/GeometryNode.d.ts

@@ -0,0 +1,15 @@
+import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
+import { Vector3Like } from "@amodx/math";
+import { VoxelGeometryConstructor } from "../Register/VoxelGeometryConstructor";
+export declare abstract class GeoemtryNode<Args> {
+    geometryPaletteId: number;
+    geomtry: VoxelGeometryConstructor;
+    faceIndex: number;
+    vertexIndex: number;
+    faceCount: number;
+    vertexCount: number;
+    tool: VoxelMesherDataTool;
+    origin: Vector3Like;
+    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor);
+    abstract add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: Args): void;
+}

package/VoxelModels/Constructor/Nodes/GeometryNode.js

@@ -0,0 +1,14 @@
+export class GeoemtryNode {
+    geometryPaletteId;
+    geomtry;
+    faceIndex = -1;
+    vertexIndex = -1;
+    faceCount = -1;
+    vertexCount = -1;
+    tool;
+    origin;
+    constructor(geometryPaletteId, geomtry) {
+        this.geometryPaletteId = geometryPaletteId;
+        this.geomtry = geomtry;
+    }
+}

package/VoxelModels/Constructor/Nodes/Ruled/BoxVoxelGeometryNode.d.ts

@@ -0,0 +1,22 @@
+import { Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelBoxGeometryNode } from "../../../VoxelModel.types";
+import { Quad } from "@amodx/meshing/Classes/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { BoxVoxelGometryArgs } from "../../../Input/BoxVoxelGometryInputs";
+import { GeoemtryNode } from "../GeometryNode";
+import { VoxelGeometryConstructor } from "../../Register/VoxelGeometryConstructor";
+import { VoxelGeometryTransform } from "../../../VoxelModelRules.types";
+export declare class BoxVoxelGometryNode extends GeoemtryNode<BoxVoxelGometryArgs> {
+    data: VoxelBoxGeometryNode;
+    quads: Quad[];
+    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array][];
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    constructor(geometryPaletteId: number, geometry: VoxelGeometryConstructor, data: VoxelBoxGeometryNode, transform: VoxelGeometryTransform);
+    isExposed(face: VoxelFaces): boolean;
+    determineShading(face: VoxelFaces): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
+}

package/VoxelModels/Constructor/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -0,0 +1,220 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { Quad } from "@amodx/meshing/Classes/Quad";
+import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
+import { BoxVoxelGometryInputs, } from "../../../Input/BoxVoxelGometryInputs";
+import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
+import { GeoemtryNode } from "../GeometryNode";
+import { addQuadWeights, getInterpolationValue, shouldCauseFlip, } from "../../../../Mesher/Calc/CalcConstants";
+import { LightData } from "../../../../Data/LightData";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../Indexing/VoxelRelativeCubeIndex";
+import { TransformBox } from "../../../Shared/Transform";
+const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
+export class BoxVoxelGometryNode extends GeoemtryNode {
+    data;
+    quads = [];
+    vertexWeights = [];
+    worldLight;
+    worldAO;
+    constructor(geometryPaletteId, geometry, data, transform) {
+        super(geometryPaletteId, geometry);
+        this.data = data;
+        const [start, end] = data.points.map((_) => Vector3Like.Create(..._));
+        this.faceCount = 6;
+        this.vertexCount = this.faceCount * 4;
+        const quadPoints = [
+            //top
+            [
+                [end.x, end.y, end.z],
+                [start.x, end.y, end.z],
+                [start.x, end.y, start.z],
+                [end.x, end.y, start.z],
+            ],
+            //bottom
+            [
+                [start.x, start.y, end.z],
+                [end.x, start.y, end.z],
+                [end.x, start.y, start.z],
+                [start.x, start.y, start.z],
+            ],
+            //north
+            [
+                [start.x, end.y, end.z],
+                [end.x, end.y, end.z],
+                [end.x, start.y, end.z],
+                [start.x, start.y, end.z],
+            ],
+            //south
+            [
+                [end.x, end.y, start.z],
+                [start.x, end.y, start.z],
+                [start.x, start.y, start.z],
+                [end.x, start.y, start.z],
+            ],
+            //east
+            [
+                [end.x, end.y, end.z],
+                [end.x, end.y, start.z],
+                [end.x, start.y, start.z],
+                [end.x, start.y, end.z],
+            ],
+            //west
+            [
+                [start.x, end.y, start.z],
+                [start.x, end.y, end.z],
+                [start.x, start.y, end.z],
+                [start.x, start.y, start.z],
+            ],
+        ];
+        const tranformed = TransformBox(quadPoints.map((_) => Quad.Create(_)), transform);
+        this.quads[VoxelFaces.Up] = tranformed[VoxelFaces.Up];
+        tranformed[VoxelFaces.Up].orientation = 0;
+        this.vertexWeights[VoxelFaces.Up] = addQuadWeights(this.quads[VoxelFaces.Up], VoxelFaces.Up);
+        this.quads[VoxelFaces.Down] = tranformed[VoxelFaces.Down];
+        tranformed[VoxelFaces.Down].orientation = 0;
+        this.vertexWeights[VoxelFaces.Down] = addQuadWeights(this.quads[VoxelFaces.Down], VoxelFaces.Down);
+        this.quads[VoxelFaces.North] = tranformed[VoxelFaces.North];
+        tranformed[VoxelFaces.North].orientation = 0;
+        this.vertexWeights[VoxelFaces.North] = addQuadWeights(this.quads[VoxelFaces.North], VoxelFaces.North);
+        this.quads[VoxelFaces.South] = tranformed[VoxelFaces.South];
+        tranformed[VoxelFaces.South].orientation = 0;
+        this.vertexWeights[VoxelFaces.South] = addQuadWeights(this.quads[VoxelFaces.South], VoxelFaces.South);
+        this.quads[VoxelFaces.East] = tranformed[VoxelFaces.East];
+        tranformed[VoxelFaces.East].orientation = 0;
+        this.vertexWeights[VoxelFaces.East] = addQuadWeights(this.quads[VoxelFaces.East], VoxelFaces.East);
+        this.quads[VoxelFaces.West] = tranformed[VoxelFaces.West];
+        tranformed[VoxelFaces.West].orientation = 0;
+        this.vertexWeights[VoxelFaces.West] = addQuadWeights(this.quads[VoxelFaces.West], VoxelFaces.West);
+    }
+    isExposed(face) {
+        const trueFaceIndex = face + this.faceIndex;
+        const faceIndexes = this.geomtry.data.faceCullMap[trueFaceIndex];
+        if (!faceIndexes)
+            return true;
+        const tool = this.tool;
+        for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
+            const currentIndex = faceIndexes[positionIndex];
+            const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
+            const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+            const offsetBaseGometry = VoxelGeometryLookUp.geometryCache[hashed];
+            const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+            if (offsetBaseGometry) {
+                for (let i = 0; i < offsetBaseGometry.length; i++) {
+                    const geoId = offsetBaseGometry[i];
+                    if (VoxelGeometryLookUp.isRulesless(geoId))
+                        continue;
+                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
+                    if (faceIndex > -1 &&
+                        !VoxelGeometryLookUp.voxelHash[hashed].isShapeStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex)) {
+                        return false;
+                    }
+                }
+            }
+            if (!offsetConditonalGeometry)
+                continue;
+            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                const cond = offsetConditonalGeometry[i];
+                for (let k = 0; k < cond.length; k++) {
+                    const geoId = cond[k];
+                    if (VoxelGeometryLookUp.isRulesless(geoId))
+                        continue;
+                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
+                    if (faceIndex > -1 &&
+                        !VoxelGeometryLookUp.voxelHash[hashed].isCondtionalStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex))
+                        return false;
+                }
+            }
+        }
+        return true;
+    }
+    determineShading(face) {
+        const tool = this.tool;
+        const lightData = tool.lightData[face];
+        const noAO = this.tool.voxel.isLightSource() || this.tool.voxel.noAO();
+        const worldLight = this.worldLight;
+        const worldAO = this.worldAO;
+        for (let v = 0; v < 4; v++) {
+            worldAO.vertices[v] = 0;
+            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[face][v]);
+            if (noAO)
+                continue;
+            const trueVertexIndex = this.vertexIndex + face * 4 + v;
+            const aoIndexes = this.geomtry.data.vertexHitMap[trueVertexIndex];
+            if (!aoIndexes)
+                continue;
+            for (let positionIndex = 0; positionIndex < aoIndexes.length; positionIndex++) {
+                const currentIndex = aoIndexes[positionIndex];
+                const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
+                const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+                if (VoxelGeometryLookUp.noCastAO[hashed] === true)
+                    continue;
+                const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
+                const conditonalGeo = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+                if (!baseGeo && !conditonalGeo)
+                    continue;
+                let length = 0;
+                let shaded = false;
+                if (baseGeo) {
+                    length = baseGeo.length;
+                    for (let geoIndex = 0; geoIndex < length; geoIndex++) {
+                        if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
+                            worldAO.vertices[v] = 1;
+                            shaded = true;
+                            break;
+                        }
+                    }
+                }
+                if (!conditonalGeo)
+                    continue;
+                length = conditonalGeo.length;
+                for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
+                    const condiotnalength = conditonalGeo[condtionsIndex].length;
+                    for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
+                        if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
+                            worldAO.vertices[v] = 1;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    shouldFlip() {
+        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
+            return true;
+        return (shouldCauseFlip(LightData.getS(this.worldLight.vertices[0]), LightData.getS(this.worldLight.vertices[1]), LightData.getS(this.worldLight.vertices[2]), LightData.getS(this.worldLight.vertices[3])) ||
+            shouldCauseFlip(LightData.sumRGB(this.worldLight.vertices[0]), LightData.sumRGB(this.worldLight.vertices[1]), LightData.sumRGB(this.worldLight.vertices[2]), LightData.sumRGB(this.worldLight.vertices[3])));
+    }
+    add(tool, originHash, origin, args) {
+        this.tool = tool;
+        this.origin = tool.voxel;
+        this.worldAO = tool.getWorldAO();
+        this.worldLight = tool.getWorldLight();
+        for (let face = 0; face < 6; face++) {
+            if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
+                tool.calculateFaceData(face);
+                this.determineShading(face);
+                const faceArgs = args[face];
+                const quad = this.quads[face];
+                quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
+                tool.setTexture(faceArgs[ArgIndexes.Texture]);
+                const uvs = faceArgs[ArgIndexes.UVs];
+                //1
+                quad.uvs.vertices[0].x = uvs[0][0];
+                quad.uvs.vertices[0].y = uvs[0][1];
+                //2
+                quad.uvs.vertices[1].x = uvs[1][0];
+                quad.uvs.vertices[1].y = uvs[1][1];
+                //3
+                quad.uvs.vertices[2].x = uvs[2][0];
+                quad.uvs.vertices[2].y = uvs[2][1];
+                //4
+                quad.uvs.vertices[3].x = uvs[3][0];
+                quad.uvs.vertices[3].y = uvs[3][1];
+                VoxelGeometry.addQuad(tool, origin, quad);
+            }
+        }
+        this.worldLight.setAll(0);
+        this.worldAO.setAll(0);
+    }
+}

package/VoxelModels/Constructor/Nodes/Ruled/QuadVoxelGeometryNode.d.ts

@@ -0,0 +1,23 @@
+import { Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelQuadGeometryNode } from "../../../VoxelModel.types";
+import { Quad } from "@amodx/meshing/Classes/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { GeoemtryNode } from "../GeometryNode";
+import { VoxelGeometryConstructor } from "../../Register/VoxelGeometryConstructor";
+import { QuadVoxelGometryArgs } from "../../../Input/QuadVoxelGometryInputs";
+import { VoxelGeometryTransform } from "../../../VoxelModelRules.types";
+export declare class QuadVoxelGometryNode extends GeoemtryNode<QuadVoxelGometryArgs> {
+    data: VoxelQuadGeometryNode;
+    quad: Quad;
+    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    closestFace: VoxelFaces;
+    constructor(geometryPaletteId: number, geometry: VoxelGeometryConstructor, data: VoxelQuadGeometryNode, transform: VoxelGeometryTransform);
+    isExposed(): boolean;
+    determineShading(): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
+}