@divinevoxel/vlox 0.0.0

package/VoxelModels/Indexing/VoxelAOResultsIndex.d.ts

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

package/VoxelModels/Indexing/VoxelAOResultsIndex.js

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

package/VoxelModels/Indexing/VoxelFaceCullResultsIndex.d.ts

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

package/VoxelModels/Indexing/VoxelFaceCullResultsIndex.js

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

package/VoxelModels/Indexing/VoxelFaceTransparentResultsIndex.d.ts

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

package/VoxelModels/Indexing/VoxelFaceTransparentResultsIndex.js

@@ -0,0 +1,15 @@
+import { BinaryArrays } from "@amodx/binary/Util/BinaryArrays";
+export class VoxelFaceTransparentResultsIndex {
+    data;
+    view;
+    constructor(data) {
+        this.data = data;
+        this.view = new DataView(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/VoxelModels/Indexing/VoxelRelativeCubeIndex.d.ts

@@ -0,0 +1,6 @@
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
+export declare class VoxelRelativeCubeIndex {
+    static flatIndex: Flat3DIndex;
+    static getIndex(x: number, y: number, z: number): number;
+}
+export declare const VoxelRelativeCubeIndexPositionMap: Record<number, Vec3Array>;

package/VoxelModels/Indexing/VoxelRelativeCubeIndex.js

@@ -0,0 +1,14 @@
+import { Flat3DIndex } from "@amodx/math";
+export class VoxelRelativeCubeIndex {
+    static flatIndex = Flat3DIndex.GetXYZOrder();
+    static getIndex(x, y, z) {
+        return this.flatIndex.getIndexXYZ(x + 1, y + 1, z + 1);
+    }
+}
+VoxelRelativeCubeIndex.flatIndex.setBounds(3, 3, 3);
+export const VoxelRelativeCubeIndexPositionMap = [];
+for (let i = 0; i < VoxelRelativeCubeIndex.flatIndex.size; i++) {
+    VoxelRelativeCubeIndexPositionMap[i] = VoxelRelativeCubeIndex.flatIndex
+        .getXYZ(i)
+        .map((_) => _ - 1);
+}

package/VoxelModels/InitVoxelModels.d.ts

@@ -0,0 +1,10 @@
+import { VoxelGeometryData, VoxelModelData } from "./VoxelModel.types";
+import { VoxelData } from "../Types/Voxel.types";
+import { Thread, ThreadPool } from "@amodx/threads";
+export declare function InitVoxelModels(data: {
+    constructors: ThreadPool;
+    world: Thread;
+    geometry?: VoxelGeometryData[];
+    models?: VoxelModelData[];
+    voxels: VoxelData[];
+}): void;

package/VoxelModels/InitVoxelModels.js

@@ -0,0 +1,109 @@
+import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Examples";
+import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Defaults/CubeVoxelGeometry";
+import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "./Defaults/CubeVoxelModels";
+import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "./Defaults/PanelVoxelGeometry";
+import { stair } from "./Defaults/StairVoxelModel";
+import { VoxelModelManager } from "./Rules/VoxelModelManager";
+import { BuildRules } from "./Rules/Functions/BuildRules";
+import { BuildStateData } from "./Rules/Functions/BuildStateData";
+import { BuildGeomtryInputs } from "./Rules/Functions/BuildGeomtryInputs";
+import { BuildFinalInputs } from "./Rules/Functions/BuildFinalInputs";
+import { SchemaRegister } from "./State/SchemaRegister";
+import { simpleCrossedPannel, simpleThinPannel, } from "./Defaults/PanelVoxelModels";
+export function InitVoxelModels(data) {
+    const initTime = performance.now();
+    VoxelModelManager.registerGeometry(cube, fencePost, fenceEastWest, fenceNorthsouth, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, ...leverGeometry, ...(data.geometry || []));
+    VoxelModelManager.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, fence, stair, simpleCrossedPannel, candlesModel, leverModel, ...(data.models || []));
+    const syncData = {
+        geometryPalette: VoxelModelManager.geometryPalette._palette,
+        geometry: [],
+        models: [],
+        voxels: [],
+    };
+    for (const voxel of data.voxels) {
+        const data = voxel.tags.find((_) => _[0] == "#dve_model_data");
+        if (!data)
+            continue;
+        const voxelData = data[1];
+        VoxelModelManager.registerVoxel(voxel.id, voxelData);
+        const model = VoxelModelManager.models.get(voxelData.id);
+        if (!model)
+            throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
+        model.voxels.set(voxel.id, voxelData);
+    }
+    const output = {};
+    const startTime = performance.now();
+    for (const [mainKey, mainGeo] of VoxelModelManager.geometry) {
+        if (mainGeo.data.ogData.doNotBuildRules) {
+            syncData.geometry.push({
+                id: mainKey,
+                nodes: mainGeo.data.nodes,
+                ruleless: true,
+            });
+            continue;
+        }
+        const output = BuildRules(mainGeo, VoxelModelManager.geometryPalette);
+        syncData.geometry.push({
+            id: mainKey,
+            nodes: mainGeo.data.nodes,
+            ...output,
+        });
+    }
+    console.log("done building rules", performance.now() - startTime);
+    const inputStartTime = performance.now();
+    for (const [mainKey, model] of VoxelModelManager.models) {
+        const stateData = BuildStateData(model, VoxelModelManager.geometryPalette);
+        model.stateData = stateData;
+        SchemaRegister.registerModel(mainKey, stateData.schema);
+        syncData.models.push({
+            id: mainKey,
+            schema: stateData.schema,
+            geoLinkMap: stateData.geometryLinkStateMap,
+            shapeStateMap: stateData.shapeStatePalette,
+            shapeStateGeometryMap: stateData.shapeStateGeometryPalette,
+            shapeStateTree: stateData.shapeStateTree,
+            condiotnalStateTree: stateData.condiotnalNodeStateTree,
+            condiotnalStatements: stateData.condiotnalStatements,
+            condiotnalStateMap: stateData.condiotnalShapeStatePalette,
+            condiotnalShapeStateMap: stateData.condiotanlStatePalette,
+            condiotnalShapeStateGeometryMap: stateData.condiotanlGeometryStatePalette,
+            shapeStateRelativeGeometryMap: stateData.shapeStateRelativeGeometryMap,
+            relativeGeometryByteIndexMap: stateData.relativeGeometryByteIndexMap,
+            condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
+        });
+    }
+    for (const [mainKey, geometry] of VoxelModelManager.geometry) {
+        BuildGeomtryInputs(geometry);
+    }
+    for (const [mainKey, model] of VoxelModelManager.models) {
+        const { shapeStateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
+        for (const v in shapeStateVoxelInputs) {
+            const stateData = model.voxelModData.get(v);
+            SchemaRegister.registerVoxel(v, mainKey, stateData.modSchema);
+            syncData.voxels.push({
+                id: v,
+                modelId: mainKey,
+                transparentFaceIndex: transparentVoxelFaceIndexes[v].data,
+                modSchema: stateData.modSchema,
+                modStateTree: stateData.modStateTree,
+                baseGeometryInputMap: shapeStateVoxelInputs[v],
+                condiotnalGeometryInputMap: conditionalShapeStateVoxelInputs[v],
+            });
+        }
+    }
+    data.world.runAsyncTasks("sync-voxel-model-data", syncData);
+    data.constructors.runTasksForAll("sync-voxel-model-data", syncData);
+    console.log("done building inputs", performance.now() - inputStartTime);
+    console.log("init voxel models done | totle time: ", performance.now() - initTime);
+    /*
+    const blob = new Blob([JSON.stringify(output, null, 1)], {});
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "rules.json";
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+   */
+}

package/VoxelModels/Input/BoxVoxelGometryInputs.d.ts

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

package/VoxelModels/Input/BoxVoxelGometryInputs.js

@@ -0,0 +1,33 @@
+import { VoxelFacesArray } from "../../Math";
+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 = {}));
+const getArgs = () => {
+    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],
+    ];
+    return args;
+};
+export class BoxVoxelGometryInputs {
+    static ArgIndexes = ArgIndexes;
+    static CreateArgs() {
+        const base = [];
+        VoxelFacesArray.forEach((_) => (base[_] = getArgs()));
+        return base;
+    }
+}

package/VoxelModels/Input/QuadVoxelGometryInputs.d.ts

@@ -0,0 +1,24 @@
+import { QuadUVData } from "@amodx/meshing/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/VoxelModels/Input/QuadVoxelGometryInputs.js

@@ -0,0 +1,29 @@
+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["DoubleSided"] = 5] = "DoubleSided";
+    ArgIndexes[ArgIndexes["UVs"] = 6] = "UVs";
+})(ArgIndexes || (ArgIndexes = {}));
+export class QuadVoxelGometryInputs {
+    static ArgIndexes = ArgIndexes;
+    static CreateArgs() {
+        const args = [];
+        args[ArgIndexes.Enabled] = true;
+        args[ArgIndexes.Fliped] = false;
+        args[ArgIndexes.Texture] = 0;
+        args[ArgIndexes.Rotation] = 0;
+        args[ArgIndexes.Transparent] = false;
+        args[ArgIndexes.DoubleSided] = false;
+        args[ArgIndexes.UVs] = [
+            [1, 1],
+            [0, 1],
+            [0, 0],
+            [1, 0],
+        ];
+        return args;
+    }
+}

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

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