@divinevoxel/vlox 0.0.74 → 0.0.75

package/Models/Rules/Functions/BuildGeomtryInputs.js

@@ -1,251 +0,0 @@
-import { BoxVoxelGometryInputs } from "../../Input/BoxVoxelGometryInputs";
-import { VoxelFaceNameArray } from "../../../Math";
-import { TextureManager } from "../../../Textures/TextureManager";
-import { Matrix2x2Like, AMath } from "@amodx/math";
-import { QuadVoxelGometryInputs } from "../../Input/QuadVoxelGometryInputs";
-const isArgString = (data) => {
-    if (typeof data !== "string")
-        return false;
-    return data[0] == "@";
-};
-const rotationMatrix = new Map();
-const mapQuadUvs = (uvs, rotation = 0, transform) => {
-    if (transform.lockUVs == true) {
-        let rotM = rotationMatrix.get(rotation);
-        if (!rotM) {
-            rotM = Matrix2x2Like.Rotation(AMath.DegreesToRadians(rotation));
-            rotationMatrix.set(rotation, rotM);
-        }
-        return [
-            Matrix2x2Like.ApplyMatrixArray(rotM, [uvs[2], uvs[3]]),
-            Matrix2x2Like.ApplyMatrixArray(rotM, [uvs[0], uvs[3]]),
-            Matrix2x2Like.ApplyMatrixArray(rotM, [uvs[0], uvs[1]]),
-            Matrix2x2Like.ApplyMatrixArray(rotM, [uvs[2], uvs[1]]),
-        ];
-    }
-    let u0 = uvs[0];
-    let v0 = uvs[1];
-    let u1 = uvs[2];
-    let v1 = uvs[3];
-    if (transform.flip) {
-        if (transform.flip[0] === 1) {
-            [u0, u1] = [u1, u0];
-        }
-        if (transform.flip[1] === 1) {
-            [v0, v1] = [v1, v0];
-        }
-    }
-    let quadUVs = [
-        [u1, v1],
-        [u0, v1],
-        [u0, v0],
-        [u1, v0],
-    ];
-    if (rotation !== 0) {
-        let rotM = rotationMatrix.get(rotation);
-        if (!rotM) {
-            rotM = Matrix2x2Like.Rotation(AMath.DegreesToRadians(rotation));
-            rotationMatrix.set(rotation, rotM);
-        }
-        const centerU = (u0 + u1) / 2;
-        const centerV = (v0 + v1) / 2;
-        quadUVs = quadUVs.map(([u, v]) => {
-            let x = u - centerU;
-            let y = v - centerV;
-            [x, y] = Matrix2x2Like.ApplyMatrixArray(rotM, [x, y]);
-            x += centerU;
-            y += centerV;
-            return [x, y];
-        });
-    }
-    return quadUVs;
-};
-export function BuildGeomtryInputs(geomtry) {
-    const inputObservers = new Map();
-    const onInput = (id, subscribe) => {
-        id = id.replace("@", "");
-        let obs = inputObservers.get(id);
-        if (!obs) {
-            obs = [];
-            inputObservers.set(id, obs);
-        }
-        return obs.push(subscribe);
-    };
-    let faceTransparentIndex = [];
-    let faceCount = 0;
-    let args = [];
-    for (const prcoessedNode of geomtry.data.nodes) {
-        const { node, tranform } = prcoessedNode;
-        if (node.type == "custom") {
-            const newArgs = {};
-            args.push(newArgs);
-            const argsIndex = args.length - 1;
-            for (const input in node.inputs) {
-                const value = node.inputs[input];
-                if (isArgString(value)) {
-                    args[argsIndex][input] = null;
-                    onInput(value, (value) => {
-                        args[argsIndex][input] = value;
-                    });
-                }
-                else {
-                    args[argsIndex][input] = value;
-                }
-            }
-        }
-        if (node.type == "box") {
-            args.push(BoxVoxelGometryInputs.CreateArgs());
-            const argsIndex = args.length - 1;
-            for (let face = 0; face < 6; face++) {
-                const relativeFaceCount = faceCount;
-                const faceName = VoxelFaceNameArray[face];
-                const faceData = node.faces[faceName];
-                let defaultUvs = [0, 0, 1, 1];
-                if (isArgString(faceData.enabled)) {
-                    onInput(String(faceData.enabled), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Enabled] =
-                        value));
-                }
-                if (isArgString(faceData.flip)) {
-                    onInput(String(faceData.flip), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Fliped] =
-                        value));
-                }
-                if (isArgString(faceData.transparent)) {
-                    faceTransparentIndex[relativeFaceCount + face] = false;
-                    onInput(String(faceData.transparent), (value) => {
-                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
-                        faceTransparentIndex[relativeFaceCount + face] = Boolean(value);
-                    });
-                }
-                else {
-                    args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] =
-                        Boolean(faceData.transparent);
-                    faceTransparentIndex[relativeFaceCount + face] = Boolean(faceData.transparent);
-                }
-                if (isArgString(faceData.rotation)) {
-                    onInput(String(faceData.rotation), (value) => {
-                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation] =
-                            value;
-                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
-                            mapQuadUvs(defaultUvs, value, tranform);
-                    });
-                }
-                else {
-                    faceData.rotation &&
-                        (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation] =
-                            faceData.rotation);
-                }
-                if (isArgString(faceData.uv)) {
-                    const defaultInput = geomtry.data.ogData.arguments[faceData.uv.substring(1)];
-                    if (defaultInput.type == "box-uv" && defaultInput.default) {
-                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
-                            mapQuadUvs(defaultInput.default, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                        defaultUvs = defaultInput.default;
-                    }
-                    onInput(String(faceData.uv), (value) => {
-                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
-                            mapQuadUvs(value, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                    });
-                }
-                else {
-                    args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
-                        mapQuadUvs(faceData.uv, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                    defaultUvs = faceData.uv;
-                }
-                if (isArgString(faceData.texture)) {
-                    onInput(String(faceData.texture), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Texture] =
-                        value));
-                }
-            }
-            faceCount += 6;
-        }
-        if (node.type == "quad") {
-            args.push(QuadVoxelGometryInputs.CreateArgs());
-            const argsIndex = args.length - 1;
-            const relativeFaceCount = faceCount;
-            let defaultUvs = [0, 0, 1, 1];
-            if (isArgString(node.transparent)) {
-                onInput(String(node.transparent), (value) => {
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Transparent] =
-                        value;
-                    faceTransparentIndex[relativeFaceCount] = Boolean(value);
-                });
-            }
-            else {
-                args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Transparent] =
-                    Boolean(node.transparent);
-                faceTransparentIndex[relativeFaceCount] = Boolean(node.transparent);
-            }
-            if (isArgString(node.doubleSided)) {
-                onInput(String(node.doubleSided), (value) => {
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
-                        value;
-                });
-            }
-            else {
-                args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
-                    Boolean(node.doubleSided);
-            }
-            if (isArgString(node.textureRotation)) {
-                onInput(String(node.textureRotation), (value) => {
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation] = value;
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultUvs, value, tranform);
-                });
-            }
-            else {
-                node.textureRotation &&
-                    (args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation] =
-                        node.textureRotation);
-            }
-            if (isArgString(node.uv)) {
-                const defaultInput = geomtry.data.ogData.arguments[node.uv.substring(1)];
-                if (defaultInput.type == "box-uv" && defaultInput.default) {
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultInput.default, args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                    defaultUvs = defaultInput.default;
-                }
-                onInput(String(node.uv), (value) => {
-                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(value, args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                });
-            }
-            else {
-                args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(node.uv, args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], tranform);
-                defaultUvs = node.uv;
-            }
-            if (isArgString(node.texture)) {
-                onInput(String(node.texture), (value) => (args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Texture] = value));
-            }
-            faceCount++;
-        }
-    }
-    const originalTransparentIndex = structuredClone(faceTransparentIndex);
-    const orginalArgs = structuredClone(args);
-    const finalGeoInputs = {
-        faceTransparentIndex,
-        cloneArgs() {
-            return structuredClone(args);
-        },
-        resetDefaults() {
-            args = structuredClone(orginalArgs);
-            faceTransparentIndex = structuredClone(originalTransparentIndex);
-            this.faceTransparentIndex = faceTransparentIndex;
-        },
-    };
-    for (const arg in geomtry.data.ogData.arguments) {
-        if (!inputObservers.has(arg))
-            continue;
-        const obs = inputObservers.get(arg);
-        const data = geomtry.data.ogData.arguments[arg];
-        Object.defineProperty(finalGeoInputs, arg, {
-            set(value) {
-                if (data.type == "texture") {
-                    const textureId = value;
-                    value =
-                        TextureManager.getTexture("dve_voxel")?.getTextureIndex(textureId);
-                }
-                for (const func of obs) {
-                    func(value);
-                }
-            },
-        });
-    }
-    return finalGeoInputs;
-}

package/Models/Rules/Functions/BuildRules.d.ts

@@ -1,8 +0,0 @@
-import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-import { StringPalette } from "../../../Util/StringPalette";
-export declare function BuildRules(main: VoxelRuleGeometry, geoPalette: StringPalette): {
-    aoIndex: import("../../Indexing/VoxelAOResultsIndex").VoxelAOResultsIndexData;
-    cullIndex: import("../../Indexing/VoxelFaceCullResultsIndex").VoxelFaceCullResultsIndexData;
-    faceCullMap: number[][];
-    vertexHitMap: number[][];
-};

package/Models/Rules/Functions/BuildRules.js

@@ -1,187 +0,0 @@
-import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
-import { Vector3Like } from "@amodx/math";
-import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
-import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
-import { VoxelFaceCullResultsIndex } from "../../Indexing/VoxelFaceCullResultsIndex";
-class OcculsionBox {
-    p1;
-    p2;
-    p3;
-    p4;
-    constructor(p1 = [0, 0, 0], p2 = [0, 0, 0], p3 = [0, 0, 0], p4 = [0, 0, 0]) {
-        this.p1 = p1;
-        this.p2 = p2;
-        this.p3 = p3;
-        this.p4 = p4;
-    }
-}
-const mainBox = new OcculsionBox();
-const size = 0.01;
-// Calculate half the size of the box
-const halfSize = size / 2;
-// Create a small offset to move the box forward
-const offset = 0.01;
-const boxNormals = [
-    [1, 0, 0],
-    [0, 1, 0],
-    [0, 0, 1],
-];
-const boxPoints = [mainBox.p1, mainBox.p2, mainBox.p3, mainBox.p4];
-const offsetPoint = [0, 0, 0];
-const tangent = [0, 0, 0];
-const bitangent = [0, 0, 0];
-function updateOcculsionBox(point, normal) {
-    offsetPoint[0] = point[0] + normal[0] * offset;
-    offsetPoint[1] = point[1] + normal[1] * offset;
-    offsetPoint[2] = point[2] + normal[2] * offset;
-    if (Math.abs(normal[0]) > Math.abs(normal[2])) {
-        tangent[0] = -normal[1];
-        tangent[1] = normal[0];
-        tangent[2] = 0;
-    }
-    else {
-        tangent[0] = 0;
-        tangent[1] = -normal[2];
-        tangent[2] = normal[1];
-    }
-    const tangentLength = Math.sqrt(tangent[0] ** 2 + tangent[1] ** 2 + tangent[2] ** 2);
-    tangent[0] = tangent[0] / tangentLength;
-    tangent[1] = tangent[1] / tangentLength;
-    tangent[2] = tangent[2] / tangentLength;
-    bitangent[0] = normal[1] * tangent[2] - normal[2] * tangent[1];
-    bitangent[1] = normal[2] * tangent[0] - normal[0] * tangent[2];
-    bitangent[2] = normal[0] * tangent[1] - normal[1] * tangent[0];
-    mainBox.p1[0] =
-        offsetPoint[0] - tangent[0] * halfSize - bitangent[0] * halfSize;
-    mainBox.p1[1] =
-        offsetPoint[1] - tangent[1] * halfSize - bitangent[1] * halfSize;
-    mainBox.p1[2] =
-        offsetPoint[2] - tangent[2] * halfSize - bitangent[2] * halfSize;
-    mainBox.p2[0] =
-        offsetPoint[0] + tangent[0] * halfSize - bitangent[0] * halfSize;
-    mainBox.p2[1] =
-        offsetPoint[1] + tangent[1] * halfSize - bitangent[1] * halfSize;
-    mainBox.p2[2] =
-        offsetPoint[2] + tangent[2] * halfSize - bitangent[2] * halfSize;
-    mainBox.p3[0] =
-        offsetPoint[0] + tangent[0] * halfSize + bitangent[0] * halfSize;
-    mainBox.p3[1] =
-        offsetPoint[1] + tangent[1] * halfSize + bitangent[1] * halfSize;
-    mainBox.p3[2] =
-        offsetPoint[2] + tangent[2] * halfSize + bitangent[2] * halfSize;
-    mainBox.p4[0] =
-        offsetPoint[0] - tangent[0] * halfSize + bitangent[0] * halfSize;
-    mainBox.p4[1] =
-        offsetPoint[1] - tangent[1] * halfSize + bitangent[1] * halfSize;
-    mainBox.p4[2] =
-        offsetPoint[2] - tangent[2] * halfSize + bitangent[2] * halfSize;
-    return mainBox;
-}
-function projectPointOntoAxis(point, axis) {
-    return point[0] * axis[0] + point[1] * axis[1] + point[2] * axis[2];
-}
-function projectionsOverlap(axis, shape1Points, shape2Points) {
-    let min1 = Infinity;
-    let max1 = -Infinity;
-    let min2 = Infinity;
-    let max2 = -Infinity;
-    for (const point of shape1Points) {
-        const projection = projectPointOntoAxis(point, axis);
-        min1 = Math.min(min1, projection);
-        max1 = Math.max(max1, projection);
-    }
-    for (const point of shape2Points) {
-        const projection = projectPointOntoAxis(point, axis);
-        min2 = Math.min(min2, projection);
-        max2 = Math.max(max2, projection);
-    }
-    return !(max1 < min2 || max2 < min1);
-}
-function doesBoxIntersectFace(quad) {
-    const quadPoints = quad.points;
-    const quadNormal = quad.normal;
-    if (!projectionsOverlap(quadNormal, quadPoints, boxPoints)) {
-        return false;
-    }
-    for (const boxNormal of boxNormals) {
-        if (!projectionsOverlap(boxNormal, quadPoints, boxPoints)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function BuildRules(main, geoPalette) {
-    main.occlusionPlane.setOffset(0, 0, 0);
-    const faceCullMap = [];
-    for (let i = 0; i < main.faceCount; i++) {
-        faceCullMap[i] = [];
-    }
-    const vertexHitMap = [];
-    for (let i = 0; i < main.vertexCount; i++) {
-        vertexHitMap[i] = [];
-    }
-    const maxIndex = VoxelRelativeCubeIndex.flatIndex.size;
-    const totalAOReusltsSize = main.vertexCount * maxIndex;
-    const aoRulesBuffer = new SharedArrayBuffer(totalAOReusltsSize * (geoPalette.size + 1));
-    const aoIndex = new VoxelAOResultsIndex({
-        buffer: aoRulesBuffer,
-        vertexByteCount: main.vertexCount,
-    });
-    const cullIndex = new VoxelFaceCullResultsIndex({
-        buffer: new SharedArrayBuffer(main.faceCount * 2 * maxIndex * (geoPalette.size + 1)),
-        faceByteCount: main.faceCount,
-    });
-    for (let otherNumberId = 0; otherNumberId < geoPalette.size; otherNumberId++) {
-        let other = VoxelModelRuleBuilderRegister.geometry.get(geoPalette._palette[otherNumberId]);
-        if (other.data.ogData.doNotBuildRules !== undefined)
-            continue;
-        if (other.id == main.id)
-            other = main.clone();
-        for (let y = -1; y < 2; y++) {
-            for (let nx = -1; nx < 2; nx++) {
-                for (let nz = -1; nz < 2; nz++) {
-                    const directionIndex = VoxelRelativeCubeIndex.getIndex(nx, y, nz);
-                    other.occlusionPlane.setOffset(nx, y, nz);
-                    for (const currentPlane of main.occlusionPlane.faces) {
-                        let occuledFaceIndex = -1;
-                        const points = currentPlane.points;
-                        const normal = currentPlane.normal;
-                        for (const otherPlane of other.occlusionPlane.faces) {
-                            if (otherPlane.parentId == currentPlane.parentId &&
-                                currentPlane.nodeId == otherPlane.nodeId &&
-                                nx == 0 &&
-                                y == 0 &&
-                                nz == 0)
-                                continue;
-                            if (otherPlane.doesCoverFace(currentPlane)) {
-                                occuledFaceIndex = otherPlane.faceCount;
-                            }
-                            if (Vector3Like.EqualsArray(otherPlane.normal, currentPlane.normal))
-                                continue;
-                            for (let v = 0; v < points.length; v++) {
-                                updateOcculsionBox(points[v], normal);
-                                const trueVertexIndex = currentPlane.vertexCount + v;
-                                if (doesBoxIntersectFace(otherPlane)) {
-                                    aoIndex.setValue(otherNumberId, directionIndex, trueVertexIndex, 1);
-                                    if (!vertexHitMap[trueVertexIndex].includes(directionIndex))
-                                        vertexHitMap[trueVertexIndex].push(directionIndex);
-                                }
-                            }
-                        }
-                        cullIndex.setValue(otherNumberId, directionIndex, currentPlane.faceCount, occuledFaceIndex);
-                        if (occuledFaceIndex > -1) {
-                            if (!faceCullMap[currentPlane.faceCount].includes(directionIndex))
-                                faceCullMap[currentPlane.faceCount].push(directionIndex);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return {
-        aoIndex: aoIndex.getData(),
-        cullIndex: cullIndex.getData(),
-        faceCullMap,
-        vertexHitMap,
-    };
-}

package/Models/Rules/Functions/GetOcclusionFaces.d.ts

@@ -1,4 +0,0 @@
-import { OcclusionFaceContainer } from "../Classes/OcclusionFace";
-import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-import { CompiledVoxelGeometryNodes } from "../../../Voxels/Types/VoxelModelCompiledData.types";
-export declare function GetOcclusionFaces(parentId: string, geometry: VoxelRuleGeometry, data: CompiledVoxelGeometryNodes[]): OcclusionFaceContainer;

package/Models/Rules/Functions/GetOcclusionFaces.js

@@ -1,112 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { OcclusionFlatQuadFace, OcclusionFaceContainer, OcclusionQuadFace, } from "../Classes/OcclusionFace";
-import { VoxelFaces } from "../../../Math";
-import { TransformBox, TransformQuad } from "../../Shared/Transform";
-import { Quad } from "../../../Mesher/Geomtry/Primitives/Quad";
-export function GetOcclusionFaces(parentId, geometry, data) {
-    const faceContainer = new OcclusionFaceContainer();
-    let vertexCount = 0;
-    let faceCount = 0;
-    let nodeId = 0;
-    for (const prcoessedNode of data) {
-        if (prcoessedNode.node.type == "box") {
-            const keys = Object.keys(prcoessedNode.tranform);
-            if (!keys.length ||
-                (keys.length == 1 &&
-                    keys[0] == "position" &&
-                    prcoessedNode.tranform.position)) {
-                const [start, end] = prcoessedNode.node.points.map((_) => Vector3Like.Create(...Vector3Like.AddArray(_, prcoessedNode.tranform.position || [0, 0, 0])));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "up", vertexCount + VoxelFaces.Up * 4, VoxelFaces.Up + faceCount, [start.x, end.y, start.z], [end.x, end.y, end.z]));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "down", vertexCount + VoxelFaces.Down * 4, VoxelFaces.Down + faceCount, [start.x, start.y, start.z], [end.x, start.y, end.z]));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "north", vertexCount + VoxelFaces.North * 4, VoxelFaces.North + faceCount, [start.x, start.y, end.z], [end.x, end.y, end.z]));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "south", vertexCount + VoxelFaces.South * 4, VoxelFaces.South + faceCount, [start.x, start.y, start.z], [end.x, end.y, start.z]));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "east", vertexCount + VoxelFaces.East * 4, VoxelFaces.East + faceCount, [end.x, start.y, start.z], [end.x, end.y, end.z]));
-                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "west", vertexCount + VoxelFaces.West * 4, VoxelFaces.West + faceCount, [start.x, start.y, start.z], [start.x, end.y, end.z]));
-            }
-            else {
-                const [start, end] = prcoessedNode.node.points.map((_) => Vector3Like.Create(..._));
-                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(_)), prcoessedNode.tranform);
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.Up * 4, faceCount + VoxelFaces.Up, tranformed[VoxelFaces.Up].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.Down * 4, faceCount + VoxelFaces.Down, tranformed[VoxelFaces.Down].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.North * 4, faceCount + VoxelFaces.North, tranformed[VoxelFaces.North].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.South * 4, faceCount + VoxelFaces.South, tranformed[VoxelFaces.South].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.East * 4, faceCount + VoxelFaces.East, tranformed[VoxelFaces.East].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.West * 4, faceCount + VoxelFaces.West, tranformed[VoxelFaces.West].positions
-                    .getAsArray()
-                    .map((_) => Vector3Like.ToArray(_))));
-            }
-            faceCount += 6;
-            vertexCount += 6 * 4;
-        }
-        if (prcoessedNode.node.type == "quad") {
-            const quad = TransformQuad(Quad.Create(prcoessedNode.node.points), prcoessedNode.tranform);
-            faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount, faceCount, quad.positions.getAsArray().map((_) => Vector3Like.ToArray(_))));
-            faceCount++;
-            vertexCount += 4;
-        }
-        nodeId++;
-        /*     if (node.type == "plane") {
-          if (node.rotation) continue;
-          const [start, end] = node.points;
-    
-          planes.addPlane(new OcclusionQuad(node.direction, start, end));
-        } */
-    }
-    geometry.vertexCount = vertexCount;
-    geometry.faceCount = faceCount;
-    return faceContainer;
-}

package/Models/Shared/Transform.d.ts

@@ -1,4 +0,0 @@
-import { Quad } from "../../Mesher/Geomtry/Primitives/Quad";
-import { VoxelGeometryTransform } from "../../Voxels/Types/VoxelModelCompiledData.types";
-export declare function TransformQuad(quad: Quad, transform: VoxelGeometryTransform): Quad;
-export declare function TransformBox(quads: [Quad, Quad, Quad, Quad, Quad, Quad], transform: VoxelGeometryTransform): [Quad, Quad, Quad, Quad, Quad, Quad];

package/Tasks/Logic/InitTasks.js

@@ -1,10 +0,0 @@
-import { Threads } from "@amodx/threads";
-import { TasksIds } from "../TasksIds";
-import { VoxelUpdateTask } from "../VoxelUpdateTask";
-import { VoxelLogicUpdate } from "./VoxelLogicUpdate";
-export default function () {
-    const tasks = new VoxelUpdateTask();
-    Threads.registerTask(TasksIds.LogicUpdate, async (data, origin) => {
-        VoxelLogicUpdate(tasks, data);
-    });
-}

package/Tasks/Logic/VoxelLogicUpdate.d.ts

@@ -1,3 +0,0 @@
-import { LocationData } from "../../Math";
-import { VoxelUpdateTask } from "../../Tasks/VoxelUpdateTask";
-export declare function VoxelLogicUpdate(task: VoxelUpdateTask, location: LocationData): false | undefined;

package/Tasks/Logic/VoxelLogicUpdate.js

@@ -1,71 +0,0 @@
-import { WorldRegister } from "../../World/WorldRegister";
-import { WorldSpaces } from "../../World/WorldSpaces";
-import { SectionCursor } from "../../World/Cursor/SectionCursor";
-import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
-import { VoxelTagIds } from "../../Voxels/Data/VoxelTag.types";
-import { RGBRemove, RGBUpdate } from "../../Tasks/Propagation";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors";
-const sectionCursor = new SectionCursor();
-export function VoxelLogicUpdate(task, location) {
-    task.setOrigin(location);
-    const sector = WorldRegister.sectors.getAt(location);
-    if (!sector) {
-        console.warn(`Could not run logic update sector at ${location} does not exist`);
-        return false;
-    }
-    const section = sector.getSection(location[1], location[2], location[3]);
-    if (!section) {
-        console.warn(`Could not run logic update sector at ${location}.  Section does not exist`);
-        return false;
-    }
-    const [minY, maxY] = section.getLogicMinMax();
-    const [cx, cy, cz] = section.position;
-    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
-    const startY = minY * slice;
-    const endY = (maxY + 1) * slice;
-    sectionCursor.setSection(section);
-    for (let i = startY; i < endY; i++) {
-        if (!(i % slice)) {
-            const y = i / slice;
-            if (!section.isLogicSliceDirty(y)) {
-                i += slice - 1;
-                continue;
-            }
-        }
-        if (!section.ids[i] || !section.getVoxelLogicDirty(i))
-            continue;
-        const voxel = sectionCursor.getVoxelAtIndex(i);
-        const x = cx + sectionCursor._voxelPosition.x;
-        const y = cy + sectionCursor._voxelPosition.y;
-        const z = cz + sectionCursor._voxelPosition.z;
-        const logic = VoxelLogicRegister.voxels[section.ids[i]];
-        if (!logic)
-            continue;
-        if (logic.hasTag(VoxelTagIds.isLightSource)) {
-            const lightSource = logic.getTagValue(VoxelTagIds.isLightSource, voxel);
-            if (lightSource) {
-                task.rgb.update.push(x, y, z);
-            }
-            else {
-                for (const n of $3dCardinalNeighbors) {
-                    const nx = n[0] + x;
-                    const ny = n[1] + y;
-                    const nz = n[2] + z;
-                    const nVoxel = task.nDataCursor.getVoxel(nx, ny, nz);
-                    if (!nVoxel)
-                        continue;
-                    if (nVoxel.hasRGBLight()) {
-                        task.rgb.remove.push(nx, ny, nz);
-                    }
-                }
-            }
-        }
-    }
-    RGBRemove(task);
-    RGBUpdate(task);
-    section.logicDirtyMap.fill(0);
-    section.logicDirty.fill(0);
-    section.setLogicDirty(false);
-    section.setLogicUpdateInProgress(false);
-    task.bounds.markSectionsAsDirty();
-}

package/Tasks/Propagation/Explosion/ExplosionManager.d.ts

@@ -1,4 +0,0 @@
-import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
-export declare const ExplosionManager: {
-    runExplosion(tasks: VoxelUpdateTask, radius: number): void;
-};