@divinevoxel/vlox 0.0.74 → 0.0.76

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.js

@@ -1,75 +0,0 @@
-import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
-import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { GeoemtryNode } from "../GeometryNode";
-import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
-const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
-export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
-    quads;
-    quadBounds = [];
-    vertexWeights;
-    lightData = new VoxelLightData();
-    init() {
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        const { quads, vertexWeights, quadBounds } = GetBoxGeometryNodeData(this.data.points, this.transform);
-        this.quads = quads;
-        this.quadBounds = quadBounds;
-        this.vertexWeights = vertexWeights;
-    }
-    determineShading(face) {
-        const tool = this.builder;
-        const lightData = tool.lightData[face];
-        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[face][v]);
-            if (noAO)
-                continue;
-        }
-    }
-    shouldFlip() {
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
-            return true;
-        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
-    }
-    add(args) {
-        const tool = this.builder;
-        let added = false;
-        for (let face = 0; face < 6; face++) {
-            if (args[face][ArgIndexes.Enabled]) {
-                added = true;
-                tool.calculateFaceData(face);
-                this.determineShading(face);
-                const faceArgs = args[face];
-                const quad = this.quads[face];
-                quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.vars.textureIndex = 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];
-                addVoxelQuad(tool, tool.position, quad);
-                this.builder.updateBounds(this.quadBounds[face]);
-            }
-        }
-        this.builder.vars.light.setAll(0);
-        this.builder.vars.ao.setAll(0);
-        return added;
-    }
-}

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -1,18 +0,0 @@
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
-import { GeoemtryNode } from "../GeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
-    quad: Quad;
-    quadBounds: [Vec3Array, Vec3Array];
-    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    closestFace: VoxelFaces;
-    lightData: VoxelLightData;
-    init(): void;
-    determineShading(): void;
-    shouldFlip(): boolean;
-    add(args: QuadVoxelGometryArgs): boolean;
-}

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.js

@@ -1,77 +0,0 @@
-import { VoxelFaces } from "../../../../Math";
-import { addVoxelQuad, } from "../../../Geomtry/VoxelGeometryBuilder";
-import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
-import { GeoemtryNode } from "../GeometryNode";
-import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
-export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
-    quad;
-    quadBounds = [
-        [0, 0, 0],
-        [0, 0, 0],
-    ];
-    vertexWeights;
-    closestFace;
-    lightData = new VoxelLightData();
-    init() {
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        const { quad, closestFace, vertexWeights, quadBounds } = GetQuadGeometryData(this.data, this.transform);
-        this.quad = quad;
-        this.quadBounds = quadBounds;
-        this.vertexWeights = vertexWeights;
-        this.closestFace = closestFace;
-    }
-    determineShading() {
-        const tool = this.builder;
-        const lightData = tool.lightData[VoxelFaces.Up];
-        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[v]);
-            if (noAO)
-                continue;
-        }
-    }
-    shouldFlip() {
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
-            return true;
-        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
-    }
-    add(args) {
-        if (!args[ArgIndexes.Enabled])
-            return false;
-        const tool = this.builder;
-        tool.calculateFaceData(this.closestFace);
-        this.determineShading();
-        const quad = this.quad;
-        quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
-        tool.vars.textureIndex = args[ArgIndexes.Texture];
-        quad.doubleSided = args[ArgIndexes.DoubleSided];
-        const uvs = args[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];
-        addVoxelQuad(tool, tool.position, quad);
-        this.builder.updateBounds(this.quadBounds);
-        this.builder.vars.light.setAll(0);
-        this.builder.vars.ao.setAll(0);
-        return true;
-    }
-}

package/Mesher/Models/Protocols/OutlinedVoxelTool.d.ts

@@ -1,6 +0,0 @@
-import type { TextureId } from "../../../Textures/Texture.types.js";
-export declare class OutlinedVoxelTool {
-    static _currentTexts: number[];
-    static setCurrentTextures(textures: number[]): void;
-    static getOutlineUVs(texture: TextureId, onRegister: (uvs: number[]) => void): void;
-}

package/Mesher/Models/Protocols/OutlinedVoxelTool.js

@@ -1,233 +0,0 @@
-import { VoxelFaces } from "../../../Math/index.js";
-/*
-0 -> normal direction
-1 -> top right
-2 -> top left
-*/
-const uvsSets = {
-    //top bottom faces
-    north: {
-        0b0: 0,
-        0b101: 1,
-        0b011: 2,
-        0b001: 3,
-    },
-    south: {
-        0b0: 4,
-        0b101: 5,
-        0b011: 6,
-        0b001: 7,
-    },
-    east: {
-        0b0: 8,
-    },
-    west: {
-        0b0: 9,
-    },
-    //side faces
-    top: {
-        0b0: 0,
-        0b101: 1,
-        0b011: 2,
-        0b001: 3,
-    },
-    bottom: {
-        0b0: 4,
-        0b101: 5,
-        0b011: 6,
-        0b001: 7,
-    },
-    right: {
-        0b0: 8,
-    },
-    left: {
-        0b0: 9,
-    },
-};
-const topAndDown = {
-    north: [
-        [0, 0, 1],
-        [1, 0, 1],
-        [-1, 0, 1],
-    ],
-    south: [
-        [0, 0, -1],
-        [1, 0, -1],
-        [-1, 0, -1],
-    ],
-    east: [[1, 0, 0]],
-    west: [[-1, 0, 0]],
-};
-const eastAndWest = {
-    top: [
-        [0, 1, 0],
-        [0, 1, 1],
-        [0, 1, -1],
-    ],
-    bottom: [
-        [0, -1, 0],
-        [0, -1, 1],
-        [0, -1, -1],
-    ],
-    right: [[0, 0, 1]],
-    left: [[0, 0, -1]],
-};
-const northAndSouth = {
-    top: [
-        [0, 1, 0],
-        [1, 1, 0],
-        [-1, 1, 0],
-    ],
-    bottom: [
-        [0, -1, 0],
-        [1, -1, 0],
-        [-1, -1, 0],
-    ],
-    right: [[1, 0, 0]],
-    left: [[-1, 0, 0]],
-};
-const CheckSets = {
-    [VoxelFaces.Up]: topAndDown,
-    [VoxelFaces.Down]: topAndDown,
-    [VoxelFaces.East]: eastAndWest,
-    [VoxelFaces.West]: eastAndWest,
-    [VoxelFaces.North]: northAndSouth,
-    [VoxelFaces.South]: northAndSouth,
-};
-const generateCheck = (direction, tool, normal, sets) => {
-    return 0;
-    /*   const { x, y, z } = tool.position;
-  
-    let key = 0b0;
-  
-    for (let i = 0; i < sets.length; i++) {
-      const set = sets[i];
-      const cx = x + set[0];
-      const cy = y + set[1];
-      const cz = z + set[2];
-  
-      tool.nVoxel.loadInAt(cx, cy, cz);
-      const sameLevelCheck = tool.voxel.isSameVoxel(tool.nVoxel);
-      let normalCheck = true;
-      if (tool.nVoxel.loadInAt(cx + normal[0], cy + normal[1], cz + normal[2])) {
-        if (tool.nVoxel.isRenderable() && tool.nVoxel.isOpaque()) {
-          normalCheck = false;
-        }
-      }
-  
-      if (sameLevelCheck && normalCheck) {
-        key |= 0b1 << i;
-      } else {
-        key |= 0b0 << i;
-        if (i == 0) break;
-      }
-    }
-    if (uvsSets[direction][key] == undefined) return 0;
-    const index = uvsSets[direction][key];
-    return OutlinedVoxelTool._currentTexts[index]; */
-};
-export class OutlinedVoxelTool {
-    static _currentTexts = [];
-    static setCurrentTextures(textures) {
-        this._currentTexts = textures;
-    }
-    /*   static addTo = {
-        top: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.Up];
-          const set = CheckSets[VoxelFaces.Up];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("north", tool, normal, set.north),
-              generateCheck("south", tool, normal, set.south),
-              generateCheck("east", tool, normal, set.east),
-              generateCheck("west", tool, normal, set.west)
-            );
-        },
-        bottom: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.Down];
-          const set = CheckSets[VoxelFaces.Down];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("north", tool, normal, set.north),
-              generateCheck("south", tool, normal, set.south),
-              generateCheck("east", tool, normal, set.east),
-              generateCheck("west", tool, normal, set.west)
-            );
-        },
-        north: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.North];
-          const set = CheckSets[VoxelFaces.North];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("top", tool, normal, set.top),
-              generateCheck("bottom", tool, normal, set.bottom),
-              generateCheck("left", tool, normal, set.left),
-              generateCheck("right", tool, normal, set.right)
-            );
-        },
-        south: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.South];
-          const set = CheckSets[VoxelFaces.South];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("top", tool, normal, set.top),
-              generateCheck("bottom", tool, normal, set.bottom),
-              generateCheck("left", tool, normal, set.left),
-              generateCheck("right", tool, normal, set.right)
-            );
-        },
-        east: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.East];
-          const set = CheckSets[VoxelFaces.East];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("top", tool, normal, set.top),
-              generateCheck("bottom", tool, normal, set.bottom),
-              generateCheck("left", tool, normal, set.left),
-              generateCheck("right", tool, normal, set.right)
-            );
-        },
-        west: (tool: VoxelMesherDataTool) => {
-          const normal = VoxelFaceDirections[VoxelFaces.West];
-          const set = CheckSets[VoxelFaces.West];
-          tool
-            .getOverlayTextures()
-            .set(
-              generateCheck("top", tool, normal, set.top),
-              generateCheck("bottom", tool, normal, set.bottom),
-              generateCheck("left", tool, normal, set.left),
-              generateCheck("right", tool, normal, set.right)
-            );
-        },
-      }; */
-    static getOutlineUVs(texture, onRegister) {
-        const overlayTextures = [];
-        /*     DVEMesher.observers.texturesRegistered.subscribeOnce((textureManager) => {
-          const type = texture[0];
-          const id = texture[1];
-          overlayTextures.push(
-            textureManager.getTextureUV([type, id, "top"]) ,
-            textureManager.getTextureUV([type, id, "corner-top-right"]),
-            textureManager.getTextureUV([type, id, "corner-top-left"]),
-            textureManager.getTextureUV([type, id, "corner-top-left-top-right"]),
-            textureManager.getTextureUV([type, id, "bottom"]),
-            textureManager.getTextureUV([type, id, "corner-bottom-right"]),
-            textureManager.getTextureUV([type, id, "corner-bottom-left"]),
-            textureManager.getTextureUV([
-              type,
-              id,
-              "corner-bottom-left-bottom-right",
-            ]),
-            textureManager.getTextureUV([type, id, "right"]),
-            textureManager.getTextureUV([type, id, "left"])
-          );
-          onRegister(overlayTextures);
-        });
-     */
-    }
-}

package/Models/Indexing/VoxelAOResultsIndex.d.ts

@@ -1,12 +0,0 @@
-export type VoxelAOResultsIndexData = {
-    buffer: ArrayBufferLike;
-    vertexByteCount: number;
-};
-export declare class VoxelAOResultsIndex {
-    view: Uint8Array;
-    readonly vertexByteCount: number;
-    constructor(data: VoxelAOResultsIndexData);
-    getValue(otherId: number, directionIndex: number, vertexIndex: number): number;
-    setValue(otherId: number, directionIndex: number, vertexIndex: number, value?: number): void;
-    getData(): VoxelAOResultsIndexData;
-}

package/Models/Indexing/VoxelAOResultsIndex.js

@@ -1,26 +0,0 @@
-import { BinaryArrays } from "@amodx/binary/Util/BinaryArrays";
-import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
-const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
-function getByteIndex(otherId, directionIndex, vertexByteCount) {
-    return (otherId * vertexByteCount * flatIndexSize + directionIndex * vertexByteCount);
-}
-export class VoxelAOResultsIndex {
-    view;
-    vertexByteCount;
-    constructor(data) {
-        this.vertexByteCount = data.vertexByteCount;
-        this.view = new Uint8Array(data.buffer);
-    }
-    getValue(otherId, directionIndex, vertexIndex) {
-        return BinaryArrays.getBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex);
-    }
-    setValue(otherId, directionIndex, vertexIndex, value = 1) {
-        BinaryArrays.setBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex, value);
-    }
-    getData() {
-        return {
-            buffer: this.view.buffer,
-            vertexByteCount: this.vertexByteCount,
-        };
-    }
-}

package/Models/Indexing/VoxelFaceCullResultsIndex.d.ts

@@ -1,12 +0,0 @@
-export type VoxelFaceCullResultsIndexData = {
-    buffer: ArrayBufferLike;
-    faceByteCount: number;
-};
-export declare class VoxelFaceCullResultsIndex {
-    view: Uint16Array;
-    readonly faceByteCount: number;
-    constructor(data: VoxelFaceCullResultsIndexData);
-    getValue(otherId: number, directionIndex: number, faceIndex: number): number;
-    setValue(otherId: number, directionIndex: number, faceIndex: number, value?: number): number;
-    getData(): VoxelFaceCullResultsIndexData;
-}

package/Models/Indexing/VoxelFaceCullResultsIndex.js

@@ -1,26 +0,0 @@
-import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
-const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
-function getByteIndex(otherId, directionIndex, faceByteCount) {
-    return (otherId * faceByteCount * flatIndexSize + directionIndex * faceByteCount);
-}
-export class VoxelFaceCullResultsIndex {
-    view;
-    faceByteCount;
-    constructor(data) {
-        this.view = new Uint16Array(data.buffer);
-        this.faceByteCount = data.faceByteCount;
-    }
-    getValue(otherId, directionIndex, faceIndex) {
-        const v = this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex];
-        return v == 65535 ? -1 : v;
-    }
-    setValue(otherId, directionIndex, faceIndex, value = -1) {
-        return (this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex] = value);
-    }
-    getData() {
-        return {
-            buffer: this.view.buffer,
-            faceByteCount: this.faceByteCount,
-        };
-    }
-}

package/Models/Indexing/VoxelFaceTransparentResultsIndex.d.ts

@@ -1,11 +0,0 @@
-export type VoxelFaceTransparentResultsIndexData = {
-    buffer: SharedArrayBuffer;
-    resultsSize: number;
-};
-export declare class VoxelFaceTransparentResultsIndex {
-    data: VoxelFaceTransparentResultsIndexData;
-    view: Uint8Array;
-    constructor(data: VoxelFaceTransparentResultsIndexData);
-    getValue(modState: number, faceByteIndex: number, faceIndex: number): number;
-    setValue(modState: number, faceByteIndex: number, faceIndex: number, value?: number): void;
-}

package/Models/Indexing/VoxelFaceTransparentResultsIndex.js

@@ -1,15 +0,0 @@
-import { BinaryArrays } from "@amodx/binary/Util/BinaryArrays";
-export class VoxelFaceTransparentResultsIndex {
-    data;
-    view;
-    constructor(data) {
-        this.data = data;
-        this.view = new Uint8Array(data.buffer);
-    }
-    getValue(modState, faceByteIndex, faceIndex) {
-        return BinaryArrays.getBitArrayIndex(this.view, this.data.resultsSize * modState + faceByteIndex, faceIndex);
-    }
-    setValue(modState, faceByteIndex, faceIndex, value = 1) {
-        BinaryArrays.setBitArrayIndex(this.view, this.data.resultsSize * modState + faceByteIndex, faceIndex, value);
-    }
-}

package/Models/Input/BoxVoxelGometryInputs.d.ts

@@ -1,25 +0,0 @@
-import { QuadUVData } from "../../Mesher/Geomtry/Geometry.types";
-export type BoxFaceArags = [
-    enabled: boolean,
-    Fliped: boolean,
-    texture: number,
-    rotation: number,
-    transparent: boolean,
-    uvs: QuadUVData,
-    index: number
-];
-declare enum ArgIndexes {
-    Enabled = 0,
-    Fliped = 1,
-    Texture = 2,
-    Rotation = 3,
-    Transparent = 4,
-    UVs = 5,
-    Index = 6
-}
-export type BoxVoxelGometryArgs = BoxFaceArags[];
-export declare class BoxVoxelGometryInputs {
-    static ArgIndexes: typeof ArgIndexes;
-    static CreateArgs(): BoxVoxelGometryArgs;
-}
-export {};

package/Models/Input/BoxVoxelGometryInputs.js

@@ -1,36 +0,0 @@
-var ArgIndexes;
-(function (ArgIndexes) {
-    ArgIndexes[ArgIndexes["Enabled"] = 0] = "Enabled";
-    ArgIndexes[ArgIndexes["Fliped"] = 1] = "Fliped";
-    ArgIndexes[ArgIndexes["Texture"] = 2] = "Texture";
-    ArgIndexes[ArgIndexes["Rotation"] = 3] = "Rotation";
-    ArgIndexes[ArgIndexes["Transparent"] = 4] = "Transparent";
-    ArgIndexes[ArgIndexes["UVs"] = 5] = "UVs";
-    ArgIndexes[ArgIndexes["Index"] = 6] = "Index";
-})(ArgIndexes || (ArgIndexes = {}));
-const getArgs = (face) => {
-    const args = [];
-    args[ArgIndexes.Enabled] = true;
-    args[ArgIndexes.Fliped] = false;
-    args[ArgIndexes.Texture] = 0;
-    args[ArgIndexes.Rotation] = 0;
-    args[ArgIndexes.Transparent] = false;
-    args[ArgIndexes.UVs] = [
-        [1, 1],
-        [0, 1],
-        [0, 0],
-        [1, 0],
-    ];
-    args[ArgIndexes.Index] = face;
-    return args;
-};
-export class BoxVoxelGometryInputs {
-    static ArgIndexes = ArgIndexes;
-    static CreateArgs() {
-        const base = [];
-        for (let face = 0; face < 6; face++) {
-            base[face] = getArgs(face);
-        }
-        return base;
-    }
-}

package/Models/Input/QuadVoxelGometryInputs.d.ts

@@ -1,24 +0,0 @@
-import { QuadUVData } from "../../Mesher/Geomtry/Geometry.types";
-export type QuadVoxelGometryArgs = [
-    enabled: boolean,
-    fliped: boolean,
-    texture: number,
-    rotation: number,
-    transparent: boolean,
-    doubleSided: boolean,
-    uvs: QuadUVData
-];
-declare enum ArgIndexes {
-    Enabled = 0,
-    Fliped = 1,
-    Texture = 2,
-    Rotation = 3,
-    Transparent = 4,
-    DoubleSided = 5,
-    UVs = 6
-}
-export declare class QuadVoxelGometryInputs {
-    static ArgIndexes: typeof ArgIndexes;
-    static CreateArgs(): QuadVoxelGometryArgs;
-}
-export {};

package/Models/Rules/Classes/OcclusionFace.d.ts

@@ -1,65 +0,0 @@
-import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelFaceNames } from "../../../Math";
-export declare abstract class OcclusionFace {
-    parentId: string;
-    nodeId: number;
-    vertexCount: number;
-    faceCount: number;
-    points: Vec3Array[];
-    normal: Vec3Array;
-    offset: Vec3Array;
-    abstract setOffset(x: number, y: number, z: number): void;
-    abstract updatePoints(): void;
-    abstract clone(): OcclusionFace;
-    abstract isPointInBounds(point: Vec3Array): boolean;
-    abstract doesCoverFace(face: OcclusionFace): boolean;
-}
-export declare class OcclusionFlatQuadFace extends OcclusionFace {
-    parentId: string;
-    nodeId: number;
-    direction: VoxelFaceNames;
-    vertexCount: number;
-    faceCount: number;
-    private _start;
-    private _end;
-    start: Vector3Like;
-    end: Vector3Like;
-    normal: Vec3Array;
-    points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
-    constructor(parentId: string, nodeId: number, direction: VoxelFaceNames, vertexCount: number, faceCount: number, _start: Vec3Array, _end: Vec3Array);
-    setOffset(x: number, y: number, z: number): void;
-    updatePoints(): void;
-    clone(): OcclusionFlatQuadFace;
-    isPointInBounds(point: Vec3Array): boolean;
-    doesCoverFace(face: OcclusionFace): boolean;
-    private totallyCoversInXAndZ;
-    private totallyCoversInXAndY;
-    private totallyCoversInYAndZ;
-    isPointOnFace(x: number, y: number, z: number): boolean;
-}
-export declare class OcclusionQuadFace extends OcclusionFace {
-    parentId: string;
-    nodeId: number;
-    vertexCount: number;
-    faceCount: number;
-    private _points;
-    normal: Vec3Array;
-    normals: Vec3Array[];
-    points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
-    constructor(parentId: string, nodeId: number, vertexCount: number, faceCount: number, _points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array]);
-    setOffset(x: number, y: number, z: number): void;
-    updatePoints(): void;
-    clone(): OcclusionQuadFace;
-    private isPointInTriangle;
-    isPointInBounds(point: Vec3Array): boolean;
-    isPointOnFace(x: number, y: number, z: number): boolean;
-    doesCoverFace(face: OcclusionFace): boolean;
-}
-export declare class OcclusionFaceContainer {
-    faces: OcclusionFace[];
-    offset: Vec3Array;
-    constructor();
-    setOffset(x: number, y: number, z: number): void;
-    addFace(face: OcclusionFace): void;
-    clone(): OcclusionFaceContainer;
-}