@divinevoxel/vlox 0.0.0

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

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

package/VoxelModels/Rules/Functions/BuildGeomtryInputs.js

@@ -0,0 +1,223 @@
+import { Observable } from "@amodx/core/Observers";
+import { BoxVoxelGometryInputs } from "../../Input/BoxVoxelGometryInputs";
+import { VoxelFaceNameArray, VoxelFaceNameRecord, } 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;
+    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 getInputObserver = (id) => {
+        let obs = inputObservers.get(id);
+        if (!obs) {
+            obs = new Observable();
+            inputObservers.set(id, obs);
+        }
+        return obs;
+    };
+    let faceTransparentIndex = [];
+    let faceCount = 0;
+    let args = [];
+    for (const prcoessedNode of geomtry.data.nodes) {
+        const { node, tranform } = prcoessedNode;
+        if (node.type == "box") {
+            const newArgs = BoxVoxelGometryInputs.CreateArgs();
+            args.push(newArgs);
+            const argsIndex = args.length - 1;
+            for (const face of VoxelFaceNameArray) {
+                const relativeFaceCount = faceCount;
+                const faceIndex = VoxelFaceNameRecord[face];
+                const faceData = node.faces[face];
+                let defaultUvs = [0, 0, 1, 1];
+                if (isArgString(faceData.enabled)) {
+                    getInputObserver(String(faceData.enabled)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Enabled] = value));
+                }
+                if (isArgString(faceData.flip)) {
+                    getInputObserver(String(faceData.flip)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Fliped] = value));
+                }
+                if (isArgString(faceData.transparent)) {
+                    getInputObserver(String(faceData.transparent)).subscribe((value) => {
+                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
+                        faceTransparentIndex[relativeFaceCount + faceIndex] =
+                            Boolean(value);
+                    });
+                }
+                else {
+                    args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Transparent] = Boolean(faceData.transparent);
+                    faceTransparentIndex[relativeFaceCount + faceIndex] = Boolean(faceData.transparent);
+                }
+                if (isArgString(faceData.rotation)) {
+                    getInputObserver(String(faceData.rotation)).subscribe((value) => {
+                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation] = value;
+                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultUvs, value, tranform);
+                    });
+                }
+                else {
+                    faceData.rotation &&
+                        (args[argsIndex][VoxelFaceNameRecord[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][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultInput.default, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                        defaultUvs = defaultInput.default;
+                    }
+                    getInputObserver(String(faceData.uv)).subscribe((value) => {
+                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(value, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                    });
+                }
+                else {
+                    args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(faceData.uv, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                    defaultUvs = faceData.uv;
+                }
+                if (isArgString(faceData.texture)) {
+                    getInputObserver(String(faceData.texture)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Texture] = value));
+                }
+            }
+            faceCount += 6;
+        }
+        if (node.type == "quad") {
+            const newArgs = QuadVoxelGometryInputs.CreateArgs();
+            args.push(newArgs);
+            const argsIndex = args.length - 1;
+            const relativeFaceCount = faceCount;
+            let defaultUvs = [0, 0, 1, 1];
+            if (isArgString(node.transparent)) {
+                getInputObserver(String(node.transparent)).subscribe((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)) {
+                getInputObserver(String(node.doubleSided)).subscribe((value) => {
+                    args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
+                        value;
+                });
+            }
+            else {
+                args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
+                    Boolean(node.doubleSided);
+            }
+            if (isArgString(node.textureRotation)) {
+                getInputObserver(String(node.textureRotation)).subscribe((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;
+                }
+                getInputObserver(String(node.uv)).subscribe((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)) {
+                getInputObserver(String(node.texture)).subscribe((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) {
+        const argKey = `@${arg}`;
+        if (!inputObservers.has(argKey))
+            continue;
+        const obs = inputObservers.get(argKey);
+        const data = geomtry.data.ogData.arguments[arg];
+        Object.defineProperty(finalGeoInputs, argKey, {
+            set(value) {
+                if (data.type == "texture") {
+                    value = TextureManager.getTextureIndex(value);
+                }
+                obs.notify(value);
+            },
+        });
+    }
+    return finalGeoInputs;
+}

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

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

package/VoxelModels/Rules/Functions/BuildRules.js

@@ -0,0 +1,187 @@
+import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
+import { Vector3Like } from "@amodx/math";
+import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
+import { VoxelModelManager } from "../VoxelModelManager";
+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 = VoxelModelManager.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.data,
+        cullIndex: cullIndex.data,
+        faceCullMap,
+        vertexHitMap,
+    };
+}

package/VoxelModels/Rules/Functions/BuildStateData.d.ts

@@ -0,0 +1,23 @@
+import { BinarySchemaNodeData, VoxelRelationsScehmaNodeData, StateLogicStatement } from "../../State/State.types";
+import { VoxelRulesModoel } from "../Classes/VoxelRulesModel";
+import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+export declare function BuildStateData(model: VoxelRulesModoel, geoPalette: StringPalette): {
+    schema: (BinarySchemaNodeData | VoxelRelationsScehmaNodeData)[];
+    shapeStateGeometryPalette: number[][];
+    condiotnalShapeStateGeometryPalette: number[][];
+    shapeStateTree: any[];
+    geometryLinkPalette: Record<string, number>;
+    geometryLinkStateMap: number[];
+    relativeByteCount: number;
+    shapeStatePalette: number[][];
+    shapeStateRecord: Record<string, number>;
+    condiotnalNodeStateTree: any;
+    condiotnalStatements: StateLogicStatement[];
+    condiotnalShapeStatePalette: number[][];
+    condiotnalShapeStateRecord: Record<string, number>;
+    condiotanlStatePalette: number[][][];
+    condiotanlGeometryStatePalette: number[][][];
+    shapeStateRelativeGeometryMap: number[][];
+    relativeGeometryByteIndexMap: number[];
+    condiotnalShapeStateRelativeGeometryMap: number[][];
+};