@divinevoxel/vlox 0.0.74 → 0.0.75

package/Models/Rules/Classes/OcclusionFace.js

@@ -1,492 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { Quad } from "../../../Mesher/Geomtry/Primitives/Quad";
-export class OcclusionFace {
-    parentId;
-    nodeId;
-    vertexCount;
-    faceCount;
-    points;
-    normal;
-    offset = [0, 0, 0];
-}
-export class OcclusionFlatQuadFace extends OcclusionFace {
-    parentId;
-    nodeId;
-    direction;
-    vertexCount;
-    faceCount;
-    _start;
-    _end;
-    start = Vector3Like.Create();
-    end = Vector3Like.Create();
-    normal;
-    points;
-    constructor(parentId, nodeId, direction, vertexCount, faceCount, _start, _end) {
-        super();
-        this.parentId = parentId;
-        this.nodeId = nodeId;
-        this.direction = direction;
-        this.vertexCount = vertexCount;
-        this.faceCount = faceCount;
-        this._start = _start;
-        this._end = _end;
-        Vector3Like.CopyFromArray(this.start, _start);
-        Vector3Like.CopyFromArray(this.end, _end);
-        this.points = [
-            [0, 0, 0],
-            [0, 0, 0],
-            [0, 0, 0],
-            [0, 0, 0],
-        ];
-        this.updatePoints();
-        switch (this.direction) {
-            case "up":
-                this.normal = [0, 1, 0];
-                break;
-            case "down":
-                this.normal = [0, -1, 0];
-                break;
-            case "north":
-                this.normal = [0, 0, 1];
-                break;
-            case "south":
-                this.normal = [0, 0, -1];
-                break;
-            case "east":
-                this.normal = [1, 0, 0];
-                break;
-            case "west":
-                this.normal = [-1, 0, 0];
-                break;
-            default:
-                this.normal = [0, 0, 0];
-                break;
-        }
-    }
-    setOffset(x, y, z) {
-        this.offset[0] = x;
-        this.offset[1] = y;
-        this.offset[2] = z;
-        this.start.x = this._start[0] + x;
-        this.start.y = this._start[1] + y;
-        this.start.z = this._start[2] + z;
-        this.end.x = this._end[0] + x;
-        this.end.y = this._end[1] + y;
-        this.end.z = this._end[2] + z;
-        this.updatePoints();
-    }
-    updatePoints() {
-        const { start, end } = this;
-        switch (this.direction) {
-            case "up":
-                this.points[0][0] = end.x;
-                this.points[0][1] = end.y;
-                this.points[0][2] = end.z;
-                this.points[1][0] = start.x;
-                this.points[1][1] = end.y;
-                this.points[1][2] = end.z;
-                this.points[2][0] = start.x;
-                this.points[2][1] = end.y;
-                this.points[2][2] = start.z;
-                this.points[3][0] = end.x;
-                this.points[3][1] = end.y;
-                this.points[3][2] = start.z;
-                break;
-            case "down":
-                this.points[0][0] = start.x;
-                this.points[0][1] = start.y;
-                this.points[0][2] = end.z;
-                this.points[1][0] = end.x;
-                this.points[1][1] = start.y;
-                this.points[1][2] = end.z;
-                this.points[2][0] = end.x;
-                this.points[2][1] = start.y;
-                this.points[2][2] = start.z;
-                this.points[3][0] = start.x;
-                this.points[3][1] = start.y;
-                this.points[3][2] = start.z;
-                break;
-            case "north":
-                this.points[0][0] = start.x;
-                this.points[0][1] = end.y;
-                this.points[0][2] = end.z;
-                this.points[1][0] = end.x;
-                this.points[1][1] = end.y;
-                this.points[1][2] = end.z;
-                this.points[2][0] = end.x;
-                this.points[2][1] = start.y;
-                this.points[2][2] = end.z;
-                this.points[3][0] = start.x;
-                this.points[3][1] = start.y;
-                this.points[3][2] = end.z;
-                break;
-            case "south":
-                this.points[0][0] = end.x;
-                this.points[0][1] = end.y;
-                this.points[0][2] = start.z;
-                this.points[1][0] = start.x;
-                this.points[1][1] = end.y;
-                this.points[1][2] = start.z;
-                this.points[2][0] = start.x;
-                this.points[2][1] = start.y;
-                this.points[2][2] = start.z;
-                this.points[3][0] = end.x;
-                this.points[3][1] = start.y;
-                this.points[3][2] = start.z;
-                break;
-            case "east":
-                this.points[0][0] = end.x;
-                this.points[0][1] = end.y;
-                this.points[0][2] = end.z;
-                this.points[1][0] = end.x;
-                this.points[1][1] = end.y;
-                this.points[1][2] = start.z;
-                this.points[2][0] = end.x;
-                this.points[2][1] = start.y;
-                this.points[2][2] = start.z;
-                this.points[3][0] = end.x;
-                this.points[3][1] = start.y;
-                this.points[3][2] = end.z;
-                break;
-            case "west":
-                this.points[0][0] = start.x;
-                this.points[0][1] = end.y;
-                this.points[0][2] = start.z;
-                this.points[1][0] = start.x;
-                this.points[1][1] = end.y;
-                this.points[1][2] = end.z;
-                this.points[2][0] = start.x;
-                this.points[2][1] = start.y;
-                this.points[2][2] = end.z;
-                this.points[3][0] = start.x;
-                this.points[3][1] = start.y;
-                this.points[3][2] = start.z;
-                break;
-            default:
-                break;
-        }
-    }
-    clone() {
-        return new OcclusionFlatQuadFace(this.parentId, this.nodeId, this.direction, this.vertexCount, this.faceCount, [...this._start], [...this._end]);
-    }
-    isPointInBounds(point) {
-        const [x, y, z] = point;
-        switch (this.direction) {
-            case "up":
-            case "down":
-                // For the up and down faces, check X and Z bounds since Y is constant
-                return (x >= this.start.x &&
-                    x <= this.end.x &&
-                    z >= this.start.z &&
-                    z <= this.end.z);
-            case "north":
-            case "south":
-                // For north and south faces, check X and Y bounds since Z is constant
-                return (x >= this.start.x &&
-                    x <= this.end.x &&
-                    y >= this.start.y &&
-                    y <= this.end.y);
-            case "east":
-            case "west":
-                // For east and west faces, check Y and Z bounds since X is constant
-                return (y >= this.start.y &&
-                    y <= this.end.y &&
-                    z >= this.start.z &&
-                    z <= this.end.z);
-            default:
-                return false;
-        }
-    }
-    doesCoverFace(face) {
-        if (face instanceof OcclusionFlatQuadFace) {
-            // Existing logic for OcclusionFlatQuadFace
-            switch (this.direction) {
-                case "up":
-                    if (face.direction === "down" && this.start.y === face.end.y) {
-                        return this.totallyCoversInXAndZ(face);
-                    }
-                    break;
-                case "down":
-                    if (face.direction === "up" && this.end.y === face.start.y) {
-                        return this.totallyCoversInXAndZ(face);
-                    }
-                    break;
-                case "north":
-                    if (face.direction === "south" && this.end.z === face.start.z) {
-                        return this.totallyCoversInXAndY(face);
-                    }
-                    break;
-                case "south":
-                    if (face.direction === "north" && this.start.z === face.end.z) {
-                        return this.totallyCoversInXAndY(face);
-                    }
-                    break;
-                case "east":
-                    if (face.direction === "west" && this.start.x === face.end.x) {
-                        return this.totallyCoversInYAndZ(face);
-                    }
-                    break;
-                case "west":
-                    if (face.direction === "east" && this.end.x === face.start.x) {
-                        return this.totallyCoversInYAndZ(face);
-                    }
-                    break;
-                default:
-                    return false;
-            }
-        }
-        if (face instanceof OcclusionQuadFace) {
-            // New logic for OcclusionQuadFace
-            const epsilon = 1e-6;
-            // Check if normals are opposite (since we are checking occlusion)
-            const dotProduct = this.normal[0] * face.normal[0] +
-                this.normal[1] * face.normal[1] +
-                this.normal[2] * face.normal[2];
-            if (dotProduct >= -epsilon) {
-                // Normals are not opposite or parallel
-                return false;
-            }
-            // Determine the plane coordinate based on the face direction
-            let planeCoordinate;
-            let coordIndex;
-            switch (this.direction) {
-                case "up":
-                case "down":
-                    planeCoordinate = this.start.y;
-                    coordIndex = 1; // Y-axis
-                    break;
-                case "north":
-                case "south":
-                    planeCoordinate = this.start.z;
-                    coordIndex = 2; // Z-axis
-                    break;
-                case "east":
-                case "west":
-                    planeCoordinate = this.start.x;
-                    coordIndex = 0; // X-axis
-                    break;
-                default:
-                    return false;
-            }
-            // Check if all points of face lie on the plane of this face
-            for (const point of face.points) {
-                if (Math.abs(point[coordIndex] - planeCoordinate) > epsilon) {
-                    return false;
-                }
-            }
-            // Check if all points of face are within the bounds of this face
-            for (const point of face.points) {
-                if (!this.isPointInBounds(point)) {
-                    return false;
-                }
-            }
-            // All checks passed, this face covers the other face
-            return true;
-        }
-        return false;
-    }
-    totallyCoversInXAndZ(plane) {
-        return (this.start.x <= plane.start.x &&
-            this.end.x >= plane.end.x &&
-            this.start.z <= plane.start.z &&
-            this.end.z >= plane.end.z);
-    }
-    totallyCoversInXAndY(plane) {
-        return (this.start.x <= plane.start.x &&
-            this.end.x >= plane.end.x &&
-            this.start.y <= plane.start.y &&
-            this.end.y >= plane.end.y);
-    }
-    totallyCoversInYAndZ(plane) {
-        return (this.start.y <= plane.start.y &&
-            this.end.y >= plane.end.y &&
-            this.start.z <= plane.start.z &&
-            this.end.z >= plane.end.z);
-    }
-    isPointOnFace(x, y, z) {
-        const epsilon = 1e-6;
-        switch (this.direction) {
-            case "up":
-            case "down":
-                return (Math.abs(y - this.start.y) < epsilon &&
-                    x >= this.start.x &&
-                    x <= this.end.x &&
-                    z >= this.start.z &&
-                    z <= this.end.z);
-            case "north":
-            case "south":
-                return (Math.abs(z - this.start.z) < epsilon &&
-                    x >= this.start.x &&
-                    x <= this.end.x &&
-                    y >= this.start.y &&
-                    y <= this.end.y);
-            case "east":
-            case "west":
-                return (Math.abs(x - this.start.x) < epsilon &&
-                    y >= this.start.y &&
-                    y <= this.end.y &&
-                    z >= this.start.z &&
-                    z <= this.end.z);
-            default:
-                return false;
-        }
-    }
-}
-export class OcclusionQuadFace extends OcclusionFace {
-    parentId;
-    nodeId;
-    vertexCount;
-    faceCount;
-    _points;
-    normal;
-    normals;
-    points;
-    constructor(parentId, nodeId, vertexCount, faceCount, _points) {
-        super();
-        this.parentId = parentId;
-        this.nodeId = nodeId;
-        this.vertexCount = vertexCount;
-        this.faceCount = faceCount;
-        this._points = _points;
-        this.normals = Quad.GetQuadNormalLeftHanded(_points[0], _points[1], _points[2], _points[3]);
-        const averageNormal = [0, 0, 0];
-        for (let i = 0; i < this.normals.length; i++) {
-            averageNormal[0] += this.normals[i][0];
-            averageNormal[1] += this.normals[i][1];
-            averageNormal[2] += this.normals[i][2];
-        }
-        averageNormal[0] /= this.normals.length;
-        averageNormal[1] /= this.normals.length;
-        averageNormal[2] /= this.normals.length;
-        // Normalize the average normal
-        const magnitude = Math.sqrt(averageNormal[0] * averageNormal[0] +
-            averageNormal[1] * averageNormal[1] +
-            averageNormal[2] * averageNormal[2]);
-        if (magnitude !== 0) {
-            averageNormal[0] /= magnitude;
-            averageNormal[1] /= magnitude;
-            averageNormal[2] /= magnitude;
-        }
-        this.normal = averageNormal;
-        this.points = [
-            [0, 0, 0],
-            [0, 0, 0],
-            [0, 0, 0],
-            [0, 0, 0],
-        ];
-        this.updatePoints();
-    }
-    setOffset(x, y, z) {
-        this.offset[0] = x;
-        this.offset[1] = y;
-        this.offset[2] = z;
-        this.updatePoints();
-    }
-    updatePoints() {
-        for (let i = 0; i < 4; i++) {
-            this.points[i][0] = this._points[i][0] + this.offset[0];
-            this.points[i][1] = this._points[i][1] + this.offset[1];
-            this.points[i][2] = this._points[i][2] + this.offset[2];
-        }
-    }
-    clone() {
-        return new OcclusionQuadFace(this.parentId, this.nodeId, this.vertexCount, this.faceCount, structuredClone(this._points));
-    }
-    isPointInTriangle(p, a, b, c) {
-        // Compute vectors
-        const v0 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
-        const v1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
-        const v2 = [p[0] - a[0], p[1] - a[1], p[2] - a[2]];
-        // Compute dot products
-        const dot00 = Vector3Like.DotArray(v0, v0);
-        const dot01 = Vector3Like.DotArray(v0, v1);
-        const dot02 = Vector3Like.DotArray(v0, v2);
-        const dot11 = Vector3Like.DotArray(v1, v1);
-        const dot12 = Vector3Like.DotArray(v1, v2);
-        // Compute barycentric coordinates
-        const denom = dot00 * dot11 - dot01 * dot01;
-        if (denom === 0) {
-            return false; // Degenerate triangle
-        }
-        const u = (dot11 * dot02 - dot01 * dot12) / denom;
-        const v = (dot00 * dot12 - dot01 * dot02) / denom;
-        // Check if point is in triangle
-        return u >= 0 && v >= 0 && u + v <= 1;
-    }
-    isPointInBounds(point) {
-        return (this.isPointInTriangle(point, this.points[0], this.points[1], this.points[2]) ||
-            this.isPointInTriangle(point, this.points[0], this.points[2], this.points[3]));
-    }
-    isPointOnFace(x, y, z) {
-        // First, check if point is on the plane
-        const p0 = this.points[0];
-        const v = [x - p0[0], y - p0[1], z - p0[2]];
-        const d = Vector3Like.DotArray(this.normal, v);
-        const epsilon = 1e-6;
-        if (Math.abs(d) > epsilon) {
-            return false;
-        }
-        // Point is on plane, now check if it's inside the face
-        const p = [x, y, z];
-        return this.isPointInBounds(p);
-    }
-    doesCoverFace(face) {
-        const epsilon = 1e-6;
-        // Normalize normals
-        const n1 = this.normal;
-        const n2 = face.normal;
-        const n1Mag = Math.sqrt(n1[0] * n1[0] + n1[1] * n1[1] + n1[2] * n1[2]);
-        const n2Mag = Math.sqrt(n2[0] * n2[0] + n2[1] * n2[1] + n2[2] * n2[2]);
-        const n1Norm = [n1[0] / n1Mag, n1[1] / n1Mag, n1[2] / n1Mag];
-        const n2Norm = [n2[0] / n2Mag, n2[1] / n2Mag, n2[2] / n2Mag];
-        // Compute dot product of normals
-        const dotNormals = Vector3Like.DotArray(n1Norm, n2Norm);
-        if (Math.abs(Math.abs(dotNormals) - 1) > epsilon) {
-            // Normals are not parallel
-            return false;
-        }
-        // Check if a point from face lies on the plane of this face
-        const p0 = this.points[0];
-        const v = [
-            face.points[0][0] - p0[0],
-            face.points[0][1] - p0[1],
-            face.points[0][2] - p0[2],
-        ];
-        const d = Vector3Like.DotArray(this.normal, v);
-        if (Math.abs(d) > epsilon) {
-            // Faces are not coplanar
-            return false;
-        }
-        // Check if all points of face are within this face
-        for (const point of face.points) {
-            if (!this.isPointInBounds(point)) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-export class OcclusionFaceContainer {
-    faces = [];
-    offset = [0, 0, 0];
-    constructor() { }
-    setOffset(x, y, z) {
-        this.offset[0] = x;
-        this.offset[1] = y;
-        this.offset[2] = z;
-        for (const plane of this.faces) {
-            plane.setOffset(x, y, z);
-            plane.updatePoints();
-        }
-    }
-    addFace(face) {
-        this.faces[face.faceCount] = face;
-    }
-    clone() {
-        const container = new OcclusionFaceContainer();
-        for (const face of this.faces) {
-            container.faces[face.faceCount] = face.clone();
-        }
-        return container;
-    }
-}

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

@@ -1,15 +0,0 @@
-import { OcclusionFaceContainer } from "./OcclusionFace";
-import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
-import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
-import { CompiledVoxelGeometryData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
-export declare class VoxelRuleGeometry {
-    id: string;
-    data: CompiledVoxelGeometryData;
-    occlusionPlane: OcclusionFaceContainer;
-    inputs: ReturnType<typeof BuildGeomtryInputs>;
-    faceCount: number;
-    vertexCount: number;
-    state: ReturnType<typeof BuildStateData>;
-    constructor(id: string, data: CompiledVoxelGeometryData, occlusionPlane?: OcclusionFaceContainer, inputs?: ReturnType<typeof BuildGeomtryInputs>);
-    clone(): VoxelRuleGeometry;
-}

package/Models/Rules/Classes/VoxelRulesGeometry.js

@@ -1,29 +0,0 @@
-import { GetOcclusionFaces } from "../Functions/GetOcclusionFaces";
-import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
-export class VoxelRuleGeometry {
-    id;
-    data;
-    occlusionPlane;
-    inputs;
-    faceCount = 0;
-    vertexCount = 0;
-    state;
-    constructor(id, data, occlusionPlane, inputs) {
-        this.id = id;
-        this.data = data;
-        if (!occlusionPlane && data.ogData.doNotBuildRules !== true) {
-            this.occlusionPlane = GetOcclusionFaces(this.id, this, data.nodes);
-        }
-        else {
-            if (occlusionPlane)
-                this.occlusionPlane = occlusionPlane;
-        }
-        !inputs && (this.inputs = BuildGeomtryInputs(this));
-    }
-    clone() {
-        const newVoxel = new VoxelRuleGeometry(this.id, this.data, this.occlusionPlane.clone(), this.inputs);
-        newVoxel.vertexCount = this.vertexCount;
-        newVoxel.faceCount = this.faceCount;
-        return newVoxel;
-    }
-}

package/Models/Rules/Functions/BuildFinalInputs.js

@@ -1,93 +0,0 @@
-import { VoxelFaceTransparentResultsIndex } from "../../Indexing/VoxelFaceTransparentResultsIndex";
-import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
-const isArgString = (data) => {
-    if (typeof data !== "string")
-        return;
-    return data[0] == "@";
-};
-export function BuildFinalInputs(model) {
-    const stateVoxelInputs = {};
-    const transparentVoxelFaceIndexes = {};
-    const conditionalShapeStateVoxelInputs = {};
-    for (const [voxelId, voxel] of model.voxels) {
-        const transparentIndex = new VoxelFaceTransparentResultsIndex({
-            buffer: new SharedArrayBuffer(model.stateData.relativeByteCount * Object.keys(voxel.inputs).length),
-            resultsSize: model.stateData.relativeByteCount,
-        });
-        transparentVoxelFaceIndexes[voxelId] = transparentIndex;
-        const voxelModData = model.voxelModData.get(voxelId);
-        for (const modVoxelInputKey in voxel.inputs) {
-            const modVoxelInput = voxel.inputs[modVoxelInputKey];
-            const modIndex = voxelModData.modRecord[modVoxelInputKey];
-            const baseStates = [];
-            for (const state in model.data.stateNodes) {
-                const geoNodes = [];
-                const stateNodes = model.data.stateNodes[state];
-                for (const node of stateNodes) {
-                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
-                    if (!geo)
-                        throw new Error(`Geometry does not exist`);
-                    geo.inputs.resetDefaults();
-                    for (const geoArg in node.inputs) {
-                        const constructorArg = node.inputs[geoArg];
-                        if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] =
-                                modVoxelInput[constructorArg.replace("@", "")];
-                            continue;
-                        }
-                        geo.inputs[geoArg] = constructorArg;
-                    }
-                    geoNodes[model.stateData.geometryLinkPalette[node.id]] =
-                        geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.stateRelativeGeometryMap[model.stateData.stateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
-                    if (geo.data.ogData.doNotBuildRules !== true) {
-                        for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
-                            transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);
-                        }
-                    }
-                }
-                baseStates[model.stateData.stateRecord[state]] = geoNodes;
-            }
-            stateVoxelInputs[voxelId] ??= [];
-            stateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] =
-                baseStates;
-            const condiotnalStates = [];
-            for (const state in model.data.conditonalNodes) {
-                const geoNodes = [];
-                const stateNodes = model.data.conditonalNodes[state];
-                for (let i = 0; i < stateNodes.length; i++) {
-                    const node = stateNodes[i];
-                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
-                    if (!geo)
-                        throw new Error(`Geometry does not exist`);
-                    //   geo.inputs.resetDefaults();
-                    for (const geoArg in node.inputs) {
-                        const constructorArg = node.inputs[geoArg];
-                        if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] =
-                                modVoxelInput[constructorArg.replace("@", "")];
-                            continue;
-                        }
-                        geo.inputs[geoArg] = constructorArg;
-                    }
-                    geoNodes[i] = geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.condiotnalShapeStateRelativeGeometryMap[model.stateData.condiotnalShapeStateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
-                    if (geo.data.ogData.doNotBuildRules !== true) {
-                        for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
-                            transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);
-                        }
-                    }
-                }
-                condiotnalStates[model.stateData.condiotnalShapeStateRecord[state]] =
-                    geoNodes;
-            }
-            conditionalShapeStateVoxelInputs[voxelId] ??= [];
-            conditionalShapeStateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] = condiotnalStates;
-        }
-    }
-    return {
-        stateVoxelInputs,
-        transparentVoxelFaceIndexes,
-        conditionalShapeStateVoxelInputs,
-    };
-}

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

@@ -1,6 +0,0 @@
-import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-export declare function BuildGeomtryInputs(geomtry: VoxelRuleGeometry): Record<string, any> & {
-    faceTransparentIndex: boolean[];
-    cloneArgs(): any[];
-    resetDefaults(): void;
-};