@divinevoxel/vlox 0.0.2 → 0.0.4

package/Textures/TextureType.d.ts

@@ -1,63 +0,0 @@
-import type { TextureData } from "./Texture.types";
-import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader";
-import { URIMaterial } from "@amodx/uri/Materials/URIMaterial";
-import { URITexture } from "@amodx/uri/Textures/URITexture";
-declare class TextureSegment {
-    parentID: string;
-    id: string;
-    mode: "sampler" | "overlay";
-    attributeID: string;
-    totalTextures: number;
-    textureMap: Map<string, TextureData>;
-    textures: TextureData[];
-    textureIndex: Record<string, number>;
-    animationsMap: number[][];
-    animationTimes: number[][];
-    animations: {
-        uniformIndex: number;
-        overlay?: boolean;
-        keys: number[];
-        currentFrame: number;
-        currentCount: number;
-        keyCounts: number[];
-    }[];
-    varyingID: string;
-    animationUniforID: string;
-    animationUniform: Float32Array;
-    paths: Map<string, Uint8ClampedArray | string | false>;
-    shaderTexture: URITexture<any, any> | null;
-    textureID: string;
-    constructor(parentID: string, id: string, mode: "sampler" | "overlay", attributeID: string);
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData(): void;
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush(): void;
-}
-export declare class TextureType {
-    id: string;
-    extension: string;
-    segments: Map<string, TextureSegment>;
-    materials: Map<string, URIMaterial>;
-    shader: URIShader;
-    constructor(id: string);
-    flushAll(): void;
-    build(): Promise<void>;
-    getTextureIndex(textureId: string, varation?: string, segment?: string): number;
-    clearSegmentData(): void;
-    removeSegment(id: string): false | undefined;
-    addTexture(data: TextureData): false | undefined;
-    addToShader(shader: URIShader): URIShader;
-    addToMaterial(material: URIMaterial): void;
-    runAnimations(): void;
-    getTextureIndexMap(): Record<string, Record<string, number>>;
-    _processVariations(textureData: TextureData, paths: Map<string, Uint8ClampedArray | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
-    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
-    buildTextureIndex(): false | undefined;
-}
-export {};

package/Textures/TextureType.js

@@ -1,287 +0,0 @@
-import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader";
-import { TextureManager } from "./TextureManager.js";
-import { TextureAnimationCreator } from "./TextureAnimations.js";
-import { TextureBuilder } from "./TextureBuilder.js";
-class TextureSegment {
-    parentID;
-    id;
-    mode;
-    attributeID;
-    totalTextures = 0;
-    textureMap = new Map();
-    textures = [];
-    textureIndex = {};
-    animationsMap = [];
-    animationTimes = [];
-    animations = [];
-    varyingID = "";
-    animationUniforID = "";
-    animationUniform = new Float32Array();
-    paths = new Map();
-    shaderTexture = null;
-    textureID = "";
-    constructor(parentID, id, mode, attributeID) {
-        this.parentID = parentID;
-        this.id = id;
-        this.mode = mode;
-        this.attributeID = attributeID;
-        this.textureID = `${parentID}_${id}`.replace("#", "");
-    }
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData() {
-        this.paths.clear();
-        this.textures = [];
-        this.textureMap.clear();
-        this.textureIndex = {};
-        this.shaderTexture = null;
-        this.animationsMap = [];
-        this.animationTimes = [];
-    }
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush() {
-        this.clearData();
-        this.shaderTexture?.dispose();
-        this.shaderTexture = null;
-        this.animations = [];
-        this.animationTimes = [];
-        this.animationsMap = [];
-        this.textureIndex = {};
-        this.totalTextures = 0;
-    }
-}
-export class TextureType {
-    id;
-    extension = "png";
-    segments;
-    materials = new Map();
-    shader;
-    constructor(id) {
-        this.id = id;
-        const main = new TextureSegment(id, "main", "sampler", "textureIndex");
-        const overlay = new TextureSegment(id, "overlay", "overlay", "textureIndex");
-        this.segments = new Map([
-            ["main", main],
-            ["overlay", overlay],
-        ]);
-    }
-    flushAll() {
-        this.segments.forEach((_, key) => _.flush());
-        this.materials.clear();
-    }
-    async build() {
-        this.buildTextureIndex();
-        this.shader = new URIShader(this.id);
-        for (const [id, segment] of this.segments) {
-            segment.shaderTexture = await TextureBuilder.createMaterialTexture(id, segment.paths);
-            this.shader.addTextures([
-                [segment.textureID, { type: "sampler2DArray" }],
-            ]);
-        }
-        TextureAnimationCreator.createAnimations(this);
-    }
-    getTextureIndex(textureId, varation = "", segment = "main") {
-        const textureSegment = this.segments.get(segment);
-        let id = textureId;
-        if (varation) {
-            id = `${textureId}:${varation}`;
-        }
-        let uv = -1;
-        uv = textureSegment.textureIndex[id];
-        if (uv == -1) {
-            throw new Error(`Texture with id: ${id} does not exists.typeId : ${this.id}  segment : ${segment}`);
-        }
-        return uv;
-    }
-    clearSegmentData() {
-        this.segments.forEach((_) => _.clearData());
-    }
-    removeSegment(id) {
-        const segment = this.segments.get(id);
-        if (!segment)
-            return false;
-        if (this.shader)
-            this.shader.data.textures.delete(segment.textureID);
-        this.segments.delete(id);
-    }
-    addTexture(data) {
-        const segment = this.segments.get(data.segment ? data.segment : "main");
-        if (!segment)
-            return false;
-        segment.textures.push(data);
-        segment.textureMap.set(data.id, data);
-    }
-    addToShader(shader) {
-        const main = this.segments.get("main");
-        const overlay = this.segments.get("overlay");
-        if (overlay) {
-            shader.setArgumentOverride("function", "getBaseColor", {
-                textureID: main.textureID,
-                overlayTextureID: overlay.textureID,
-                mainVarying: main.varyingID,
-                overlayVarying: overlay.varyingID,
-            });
-        }
-        shader.setArgumentOverride("function", "getMainColor", {
-            textureID: main.textureID,
-            mainVarying: main.varyingID,
-        });
-        return this.shader.merge(shader, false);
-    }
-    addToMaterial(material) {
-        for (const [key, segment] of this.segments) {
-            if (!segment.shaderTexture)
-                continue;
-            material.setTexture(segment.textureID, segment.shaderTexture);
-            material.setNumberArray(segment.animationUniforID, segment.animationUniform);
-        }
-        this.materials.set(material.id, material);
-    }
-    runAnimations() {
-        for (const [key, segment] of this.segments) {
-            for (let i = 0; i < segment.animations.length; i++) {
-                const anim = segment.animations[i];
-                if (anim.currentCount <= anim.keyCounts[anim.currentFrame]) {
-                    anim.currentCount++;
-                    continue;
-                }
-                anim.currentCount = 0;
-                if (anim.currentFrame < anim.keys.length - 1) {
-                    anim.currentFrame++;
-                }
-                else {
-                    anim.currentFrame = 0;
-                }
-                segment.animationUniform[anim.uniformIndex] =
-                    anim.keys[anim.currentFrame];
-                for (const [key, material] of this.materials) {
-                    material.setNumberArray(segment.animationUniforID, segment.animationUniform);
-                }
-            }
-        }
-    }
-    getTextureIndexMap() {
-        const segmentMap = {};
-        for (const [key, segment] of this.segments) {
-            segmentMap[key] ??= {};
-            segmentMap[key] = segment.textureIndex;
-        }
-        return segmentMap;
-    }
-    _processVariations(textureData, paths, map, animations, textureAnimatioTimes, extension, count) {
-        if (!textureData.variations)
-            return count;
-        for (const varation of Object.keys(textureData.variations)) {
-            const data = textureData.variations[varation];
-            if (data.frames == 0) {
-                map[`${textureData.id}:${varation}`] = count;
-                const assetPath = this._getPath(textureData, varation, extension);
-                let raw = false;
-                if (data.rawData && !Array.isArray(data.rawData)) {
-                    raw = data.rawData;
-                }
-                if (data.base64 && !Array.isArray(data.base64)) {
-                    raw = data.base64;
-                }
-                paths.set(assetPath, raw);
-                count++;
-            }
-            else {
-                if (!data.animKeys)
-                    throw new Error("Texture Varation must have supplied animKeys if frames are greater than 0.");
-                for (let i = 1; i <= data.frames; i++) {
-                    map[`${textureData.id}:${varation}-${i}`] = count;
-                    const assetPath = this._getPath(textureData, `${varation}-${i}`, extension);
-                    let raw = false;
-                    if (data.rawData) {
-                        raw = data.rawData[i - 1];
-                    }
-                    if (data.base64) {
-                        raw = data.base64[i - 1];
-                    }
-                    paths.set(assetPath, raw);
-                    count++;
-                }
-                const trueKeys = [];
-                for (let i = 0; i < data.animKeys.length; i++) {
-                    trueKeys.push(map[`${textureData.id}:${varation}-${data.animKeys[i]}`]);
-                }
-                if (data.animKeyFrameTimes) {
-                    textureAnimatioTimes.push(data.animKeyFrameTimes);
-                }
-                if (data.globalFrameTime) {
-                    textureAnimatioTimes.push([data.globalFrameTime]);
-                }
-                animations.push(trueKeys);
-            }
-        }
-        return count;
-    }
-    _getPath(textureData, varation = "default", extension) {
-        return `${textureData.path ? textureData.path : TextureManager.defaultTexturePath}/${textureData.id}/${varation}.${extension}`;
-    }
-    buildTextureIndex() {
-        const texture = this;
-        if (!texture)
-            return false;
-        const extension = texture.extension;
-        for (const [key, segment] of texture.segments) {
-            let count = 1;
-            const map = segment.textureIndex;
-            const paths = segment.paths;
-            const animationTimes = segment.animationTimes;
-            const animations = segment.animationsMap;
-            for (const textureData of segment.textures) {
-                if (textureData.frames == 0) {
-                    segment.textureIndex[`${textureData.id}`] = count;
-                    const assetPath = this._getPath(textureData, "default", extension);
-                    let raw = false;
-                    if (textureData.rawData && !Array.isArray(raw)) {
-                        raw = textureData.rawData;
-                    }
-                    if (textureData.base64 && !Array.isArray(textureData.base64)) {
-                        raw = textureData.base64;
-                    }
-                    paths.set(assetPath, raw);
-                    count++;
-                    count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
-                }
-                else {
-                    if (!textureData.animKeys)
-                        throw new Error("Texture must have supplied animKeys if frames are greater than 0.");
-                    const rawData = textureData.rawData;
-                    for (let i = 1; i <= textureData.frames; i++) {
-                        const assetPath = this._getPath(textureData, `default-${i}`, extension);
-                        let raw = false;
-                        if (rawData) {
-                            raw = rawData[i - 1];
-                        }
-                        if (textureData.base64) {
-                            raw = textureData.base64[i - 1];
-                        }
-                        paths.set(assetPath, raw);
-                        count++;
-                    }
-                    const trueKeys = [];
-                    for (let i = 0; i < textureData.animKeys.length; i++) {
-                        trueKeys.push(map[`${textureData.id}:default-${textureData.animKeys[i]}`]);
-                    }
-                    if (textureData.animKeyFrameTimes) {
-                        animationTimes.push(textureData.animKeyFrameTimes);
-                    }
-                    if (textureData.globalFrameTime) {
-                        animationTimes.push([textureData.globalFrameTime]);
-                    }
-                    animations.push(trueKeys);
-                    count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
-                }
-            }
-            segment.totalTextures = count;
-        }
-    }
-}

package/Tools/Data/RichDataTool.d.ts

@@ -1,25 +0,0 @@
-import { Thread } from "@amodx/threads/";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-export declare class RichDataTool extends LocationBoundTool {
-    segment: string;
-    comm: Thread;
-    _enabled: boolean;
-    constructor();
-    isEnabled(): boolean;
-    setSegment(segment: string): this;
-    columnHasData(check: (hasData: boolean) => void): void;
-    columnHasDataAsync(): Promise<boolean>;
-    getData<T = any>(onDone: (data: T | false) => void): void;
-    getDataAsync<T = any>(): Promise<T | false>;
-    setData<T = any>(data: T, onDone?: (data: boolean) => void): void;
-    setDataAsync<T = any>(data: T): Promise<boolean>;
-    removeData(onDone: (removed: boolean) => void): void;
-    removeDataAsync<T = any>(): Promise<boolean>;
-    removeColumn(onDone: (removed: boolean) => void): void;
-    removeColumnAsync<T = any>(): Promise<boolean>;
-    getColumn(onDone: (data: ArrayBuffer) => void): void;
-    getColumnAsync(): Promise<ArrayBuffer>;
-    setColumn(column: ArrayBuffer, onDone: (success: boolean) => void): void;
-    setColumnAsync(column: ArrayBuffer): Promise<boolean>;
-    releaeAllData(): void;
-}

package/Tools/Data/RichDataTool.js

@@ -1,121 +0,0 @@
-import { BinaryObject } from "@amodx/binary";
-import { Threads } from "@amodx/threads/";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-export class RichDataTool extends LocationBoundTool {
-    segment = "voxels";
-    comm;
-    _enabled = false;
-    constructor() {
-        super();
-        this.comm = Threads.getThread("rich-world");
-        if (!this.comm || !this.comm.isPortSet()) {
-            this._enabled = false;
-            if (this.comm) {
-                this.comm.onSetPort(() => {
-                    this._enabled = true;
-                });
-            }
-            return;
-        }
-        if (this.comm.isPortSet()) {
-            this._enabled = true;
-        }
-    }
-    isEnabled() {
-        return this._enabled;
-    }
-    setSegment(segment) {
-        this.segment = segment;
-        return this;
-    }
-    columnHasData(check) {
-        this.comm.runPromiseTasks("has-data", this.location, [], (hadData) => {
-            check(hadData);
-        });
-    }
-    columnHasDataAsync() {
-        return new Promise((resolve) => {
-            this.columnHasData((hasData) => {
-                resolve(hasData);
-            });
-        });
-    }
-    getData(onDone) {
-        this.comm.runPromiseTasks("get-data", [this.location, this.segment], [], (data) => {
-            if (!data)
-                return onDone(false);
-            onDone(BinaryObject.bufferToObject(data));
-        });
-    }
-    getDataAsync() {
-        return new Promise((resolve) => {
-            this.getData((data) => {
-                resolve(data);
-            });
-        });
-    }
-    setData(data, onDone = (data) => { }) {
-        const buffer = BinaryObject.objectToBuffer(data);
-        this.comm.runPromiseTasks("set-data", [this.location, this.segment, buffer], [buffer], (success) => {
-            onDone(success);
-        });
-    }
-    setDataAsync(data) {
-        return new Promise((resolve) => {
-            this.setData(data, (updated) => {
-                resolve(updated);
-            });
-        });
-    }
-    removeData(onDone) {
-        this.comm.runPromiseTasks("remove-data", [this.location, this.segment], [], (removed) => {
-            onDone(removed);
-        });
-    }
-    removeDataAsync() {
-        return new Promise((resolve) => {
-            this.removeData((removed) => {
-                resolve(removed);
-            });
-        });
-    }
-    removeColumn(onDone) {
-        this.comm.runPromiseTasks("remove-column", this.location, [], (removed) => {
-            onDone(removed);
-        });
-    }
-    removeColumnAsync() {
-        return new Promise((resolve) => {
-            this.removeData((removed) => {
-                resolve(removed);
-            });
-        });
-    }
-    getColumn(onDone) {
-        this.comm.runPromiseTasks("get-column", this.location, [], (data) => {
-            onDone(data);
-        });
-    }
-    getColumnAsync() {
-        return new Promise((resolve) => {
-            this.getColumn((data) => {
-                resolve(data);
-            });
-        });
-    }
-    setColumn(column, onDone) {
-        this.comm.runPromiseTasks("set-column", [this.location, column], [], (success) => {
-            onDone(success);
-        });
-    }
-    setColumnAsync(column) {
-        return new Promise((resolve) => {
-            this.setColumn(column, (success) => {
-                resolve(success);
-            });
-        });
-    }
-    releaeAllData() {
-        this.comm.runTasks("release-all-data", [], []);
-    }
-}

package/Types/DataSync.types.d.ts

@@ -1,25 +0,0 @@
-import type { BinaryStructData } from "@amodx/binary/";
-import { LocationData } from "Math/index.js";
-export type DataSyncTypes = "chunk" | "voxel-data" | "iten-data" | "shape-map";
-export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];
-export type PaletteSyncData = [
-    voxelPalette: string[],
-    voxelPaletteMap: Record<string, number>,
-    nameToIdMap: Record<string, string>,
-    idToNameMap: Record<string, string>
-];
-export type VoxelDataSync = [
-    initData: BinaryStructData,
-    voxelMapData: SharedArrayBuffer
-];
-export type RegisterStringMapSync = [
-    segment: string,
-    id: string,
-    map: string[]
-];
-export type RegisterObjectMapSync = [
-    segment: string,
-    id: string,
-    map: any[]
-];
-export type VoxelMapSyncData = string[];

package/Types/Substances.types.d.ts

@@ -1,4 +0,0 @@
-export type SubstanceData = {
-    id: string;
-    tags: ([id: string, value: string | number | boolean | number[]] | [id: "#dve_parent_substance", value: string] | [id: "#dve_is_transparent", value: string] | [id: "#dve_rendered_substance", value: string] | [id: "#dve_culled_substances", value: string[]] | [id: "#dve_is_solid", value: boolean] | [id: "#dve_is_liquid", value: boolean] | [id: "#dve_flow_rate", value: number])[];
-};

package/Types/Voxel.types.d.ts

@@ -1,12 +0,0 @@
-export type VoxelPalette = string[];
-export type VoxelPaletteMap = Record<string, number>;
-/**# Voxel Data
- * ---
- * This the needed information for each voxel.
- */
-export interface VoxelData {
-    id: string;
-    name?: string;
-    title?: string;
-    tags: ([id: string, value: any] | [id: "#dve_substance", value: string] | [id: "#dve_shape_id", value: string] | [id: "#dve_is_light_source", value: boolean] | [id: "#dve_no_ao", value: boolean] | [id: "#dve_light_value", value: [r: number, g: number, z: number]] | [id: "#dve_collider_id", value: string] | [id: "#dve_check_collisions", value: boolean] | [id: "#dve_can_have_secondary", value: boolean] | [id: "#dve_material", value: string] | [id: "#dve_hardness", value: number] | [id: "#dve_is_rich", value: boolean])[];
-}

package/Types/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./Voxel.types.js";
-export * from "./Util.types.js";

package/Types/index.js

@@ -1,2 +0,0 @@
-export * from "./Voxel.types.js";
-export * from "./Util.types.js";

package/VoxelModels/Constructor/InitVoxelModelsConstructor.d.ts

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

package/VoxelModels/Constructor/InitVoxelModelsConstructor.js

@@ -1,20 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/Ruled/BoxVoxelGeometryNode.d.ts

@@ -1,22 +0,0 @@
-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/QuadVoxelGeometryNode.d.ts

@@ -1,23 +0,0 @@
-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;
-}

package/VoxelModels/Constructor/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.d.ts

@@ -1,21 +0,0 @@
-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 { VoxelGeometryRulelessConstructor } from "../../Register/VoxelGeometryRulelessConstructor";
-import { RulelessGeoemtryNode } from "../RulelessGeometryNode";
-import { VoxelGeometryTransform } from "../../../VoxelModelRules.types";
-export declare class RulelessBoxVoxelGeometryNode extends RulelessGeoemtryNode<BoxVoxelGometryArgs> {
-    data: VoxelBoxGeometryNode;
-    quads: Quad[];
-    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array][];
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
-    constructor(geometryPaletteId: number, geometry: VoxelGeometryRulelessConstructor, data: VoxelBoxGeometryNode, transform: VoxelGeometryTransform);
-    determineShading(face: VoxelFaces): void;
-    shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
-}