@divinevoxel/vlox 0.0.1 → 0.0.3

package/VoxelModels/Constructor/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.js

@@ -1,138 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { Quad } from "@amodx/meshing/Classes/Quad";
-import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
-import { BoxVoxelGometryInputs, } from "../../../Input/BoxVoxelGometryInputs";
-import { addQuadWeights, getInterpolationValue, shouldCauseFlip, } from "../../../../Mesher/Calc/CalcConstants";
-import { LightData } from "../../../../Data/LightData";
-import { RulelessGeoemtryNode } from "../RulelessGeometryNode";
-import { TransformBox } from "../../../Shared/Transform";
-const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
-export class RulelessBoxVoxelGeometryNode extends RulelessGeoemtryNode {
-    data;
-    quads = [];
-    vertexWeights = [];
-    worldLight;
-    worldAO;
-    constructor(geometryPaletteId, geometry, data, transform) {
-        super(geometryPaletteId, geometry);
-        this.data = data;
-        const [start, end] = data.points.map((_) => Vector3Like.Create(..._));
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        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(_)), transform);
-        this.quads[VoxelFaces.Up] = tranformed[VoxelFaces.Up];
-        tranformed[VoxelFaces.Up].orientation = 0;
-        this.vertexWeights[VoxelFaces.Up] = addQuadWeights(this.quads[VoxelFaces.Up], VoxelFaces.Up);
-        this.quads[VoxelFaces.Down] = tranformed[VoxelFaces.Down];
-        tranformed[VoxelFaces.Down].orientation = 0;
-        this.vertexWeights[VoxelFaces.Down] = addQuadWeights(this.quads[VoxelFaces.Down], VoxelFaces.Down);
-        this.quads[VoxelFaces.North] = tranformed[VoxelFaces.North];
-        tranformed[VoxelFaces.North].orientation = 0;
-        this.vertexWeights[VoxelFaces.North] = addQuadWeights(this.quads[VoxelFaces.North], VoxelFaces.North);
-        this.quads[VoxelFaces.South] = tranformed[VoxelFaces.South];
-        tranformed[VoxelFaces.South].orientation = 0;
-        this.vertexWeights[VoxelFaces.South] = addQuadWeights(this.quads[VoxelFaces.South], VoxelFaces.South);
-        this.quads[VoxelFaces.East] = tranformed[VoxelFaces.East];
-        tranformed[VoxelFaces.East].orientation = 0;
-        this.vertexWeights[VoxelFaces.East] = addQuadWeights(this.quads[VoxelFaces.East], VoxelFaces.East);
-        this.quads[VoxelFaces.West] = tranformed[VoxelFaces.West];
-        tranformed[VoxelFaces.West].orientation = 0;
-        this.vertexWeights[VoxelFaces.West] = addQuadWeights(this.quads[VoxelFaces.West], VoxelFaces.West);
-    }
-    determineShading(face) {
-        const tool = this.tool;
-        const lightData = tool.lightData[face];
-        const noAO = this.tool.voxel.isLightSource() || this.tool.voxel.noAO();
-        const worldLight = this.worldLight;
-        const worldAO = this.worldAO;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[face][v]);
-            if (noAO)
-                continue;
-        }
-    }
-    shouldFlip() {
-        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
-            return true;
-        return (shouldCauseFlip(LightData.getS(this.worldLight.vertices[0]), LightData.getS(this.worldLight.vertices[1]), LightData.getS(this.worldLight.vertices[2]), LightData.getS(this.worldLight.vertices[3])) ||
-            shouldCauseFlip(LightData.sumRGB(this.worldLight.vertices[0]), LightData.sumRGB(this.worldLight.vertices[1]), LightData.sumRGB(this.worldLight.vertices[2]), LightData.sumRGB(this.worldLight.vertices[3])));
-    }
-    add(tool, originHash, origin, args) {
-        this.tool = tool;
-        this.origin = tool.voxel;
-        this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
-        for (let face = 0; face < 6; face++) {
-            if (args[face][ArgIndexes.Enabled]) {
-                tool.calculateFaceData(face);
-                this.determineShading(face);
-                const faceArgs = args[face];
-                const quad = this.quads[face];
-                quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.setTexture(faceArgs[ArgIndexes.Texture]);
-                const uvs = faceArgs[ArgIndexes.UVs];
-                //1
-                quad.uvs.vertices[0].x = uvs[0][0];
-                quad.uvs.vertices[0].y = uvs[0][1];
-                //2
-                quad.uvs.vertices[1].x = uvs[1][0];
-                quad.uvs.vertices[1].y = uvs[1][1];
-                //3
-                quad.uvs.vertices[2].x = uvs[2][0];
-                quad.uvs.vertices[2].y = uvs[2][1];
-                //4
-                quad.uvs.vertices[3].x = uvs[3][0];
-                quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometry.addQuad(tool, origin, quad);
-            }
-        }
-        this.worldLight.setAll(0);
-        this.worldAO.setAll(0);
-    }
-}

package/VoxelModels/Constructor/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -1,22 +0,0 @@
-import { Vec4Array, Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "@amodx/meshing";
-import { VoxelQuadGeometryNode } from "../../../VoxelModel.types";
-import { Quad } from "@amodx/meshing/Classes/Quad";
-import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
-import { VoxelGeometryRulelessConstructor } from "../../Register/VoxelGeometryRulelessConstructor";
-import { QuadVoxelGometryArgs } from "../../../Input/QuadVoxelGometryInputs";
-import { RulelessGeoemtryNode } from "../RulelessGeometryNode";
-import { VoxelGeometryTransform } from "../../../../VoxelModels/VoxelModelRules.types";
-export declare class RulelessQuadVoxelGeometryNode extends RulelessGeoemtryNode<QuadVoxelGometryArgs> {
-    data: VoxelQuadGeometryNode;
-    quad: Quad;
-    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
-    closestFace: VoxelFaces;
-    constructor(geometryPaletteId: number, geometry: VoxelGeometryRulelessConstructor, data: VoxelQuadGeometryNode, transform: VoxelGeometryTransform);
-    determineShading(): void;
-    shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
-}

package/VoxelModels/Constructor/Nodes/RulelessGeometryNode.d.ts

@@ -1,15 +0,0 @@
-import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
-import { Vector3Like } from "@amodx/math";
-import { VoxelGeometryRulelessConstructor } from "../Register/VoxelGeometryRulelessConstructor";
-export declare abstract class RulelessGeoemtryNode<Args> {
-    geometryPaletteId: number;
-    geomtry: VoxelGeometryRulelessConstructor;
-    faceIndex: number;
-    vertexIndex: number;
-    faceCount: number;
-    vertexCount: number;
-    tool: VoxelMesherDataTool;
-    origin: Vector3Like;
-    constructor(geometryPaletteId: number, geomtry: VoxelGeometryRulelessConstructor);
-    abstract add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: Args): void;
-}

package/VoxelModels/Constructor/Nodes/RulelessGeometryNode.js

@@ -1,14 +0,0 @@
-export class RulelessGeoemtryNode {
-    geometryPaletteId;
-    geomtry;
-    faceIndex = -1;
-    vertexIndex = -1;
-    faceCount = -1;
-    vertexCount = -1;
-    tool;
-    origin;
-    constructor(geometryPaletteId, geomtry) {
-        this.geometryPaletteId = geometryPaletteId;
-        this.geomtry = geomtry;
-    }
-}

package/VoxelModels/Constructor/Register/VoxelGeometryConstructor.d.ts

@@ -1,13 +0,0 @@
-import { VoxelFaceCullResultsIndex } from "../../Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
-import { VoxelGeometrySyncData } from "../../VoxelModelRules.types";
-import { BoxVoxelGometryNode } from "../Nodes/Ruled/BoxVoxelGeometryNode";
-import { QuadVoxelGometryNode } from "../Nodes/Ruled/QuadVoxelGeometryNode";
-export declare class VoxelGeometryConstructor {
-    geometryPaletteId: number;
-    data: VoxelGeometrySyncData;
-    nodes: (BoxVoxelGometryNode | QuadVoxelGometryNode)[];
-    cullIndex: VoxelFaceCullResultsIndex;
-    aoIndex: VoxelAOResultsIndex;
-    constructor(geometryPaletteId: number, data: VoxelGeometrySyncData);
-}

package/VoxelModels/Constructor/Register/VoxelGeometryConstructor.js

@@ -1,33 +0,0 @@
-import { VoxelFaceCullResultsIndex } from "../../Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
-import { BoxVoxelGometryNode } from "../Nodes/Ruled/BoxVoxelGeometryNode";
-import { QuadVoxelGometryNode } from "../Nodes/Ruled/QuadVoxelGeometryNode";
-export class VoxelGeometryConstructor {
-    geometryPaletteId;
-    data;
-    nodes = [];
-    cullIndex;
-    aoIndex;
-    constructor(geometryPaletteId, data) {
-        this.geometryPaletteId = geometryPaletteId;
-        this.data = data;
-        this.cullIndex = new VoxelFaceCullResultsIndex(data.cullIndex);
-        this.aoIndex = new VoxelAOResultsIndex(data.aoIndex);
-        for (const node of data.nodes) {
-            if (node.node.type == "box") {
-                this.nodes.push(new BoxVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform));
-            }
-            if (node.node.type == "quad") {
-                this.nodes.push(new QuadVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform));
-            }
-        }
-        let faceCount = 0;
-        let vertexCount = 0;
-        for (const node of this.nodes) {
-            node.faceIndex = faceCount;
-            node.vertexIndex = vertexCount;
-            faceCount += node.faceCount;
-            vertexCount += node.vertexCount;
-        }
-    }
-}

package/VoxelModels/Constructor/Register/VoxelGeometryRulelessConstructor.d.ts

@@ -1,9 +0,0 @@
-import { VoxelGeometryRulelessSyncData } from "../../VoxelModelRules.types";
-import { RulelessBoxVoxelGeometryNode } from "../Nodes/Ruleless/RulelessBoxVoxelGeometryNode";
-import { RulelessQuadVoxelGeometryNode } from "../Nodes//Ruleless/RulelessQuadVoxelGeometryNode";
-export declare class VoxelGeometryRulelessConstructor {
-    geometryPaletteId: number;
-    data: VoxelGeometryRulelessSyncData;
-    nodes: (RulelessBoxVoxelGeometryNode | RulelessQuadVoxelGeometryNode)[];
-    constructor(geometryPaletteId: number, data: VoxelGeometryRulelessSyncData);
-}

package/VoxelModels/Constructor/Register/VoxelGeometryRulelessConstructor.js

@@ -1,27 +0,0 @@
-import { RulelessBoxVoxelGeometryNode } from "../Nodes/Ruleless/RulelessBoxVoxelGeometryNode";
-import { RulelessQuadVoxelGeometryNode } from "../Nodes//Ruleless/RulelessQuadVoxelGeometryNode";
-export class VoxelGeometryRulelessConstructor {
-    geometryPaletteId;
-    data;
-    nodes = [];
-    constructor(geometryPaletteId, data) {
-        this.geometryPaletteId = geometryPaletteId;
-        this.data = data;
-        for (const node of data.nodes) {
-            if (node.node.type == "box") {
-                this.nodes.push(new RulelessBoxVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform));
-            }
-            if (node.node.type == "quad") {
-                this.nodes.push(new RulelessQuadVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform));
-            }
-        }
-        let faceCount = 0;
-        let vertexCount = 0;
-        for (const node of this.nodes) {
-            node.faceIndex = faceCount;
-            node.vertexIndex = vertexCount;
-            faceCount += node.faceCount;
-            vertexCount += node.vertexCount;
-        }
-    }
-}

package/VoxelModels/Constructor/Register/VoxelModelConstructorRegister.d.ts

@@ -1,14 +0,0 @@
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
-import { VoxelGeometryRulelessSyncData, VoxelGeometrySyncData, VoxelModelSyncData } from "../../VoxelModelRules.types";
-import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
-import { VoxelModelConstructor } from "./VoxelModelsConstructor";
-import { VoxelGeometryRulelessConstructor } from "./VoxelGeometryRulelessConstructor";
-export declare class VoxelModelConstructorRegister {
-    static geometryPalette: StringPalette;
-    static geometry: (VoxelGeometryConstructor | VoxelGeometryRulelessConstructor)[];
-    static rulesless: boolean[];
-    static setGeometryPalette(palette: string[]): void;
-    static models: Map<string, VoxelModelConstructor>;
-    static registerModels(models: VoxelModelSyncData[]): void;
-    static registerGeometry(geometries: (VoxelGeometrySyncData | VoxelGeometryRulelessSyncData)[]): void;
-}

package/VoxelModels/Constructor/Register/VoxelModelConstructorRegister.js

@@ -1,31 +0,0 @@
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
-import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
-import { VoxelModelConstructor } from "./VoxelModelsConstructor";
-import { VoxelGeometryRulelessConstructor } from "./VoxelGeometryRulelessConstructor";
-export class VoxelModelConstructorRegister {
-    static geometryPalette;
-    static geometry = [];
-    static rulesless = [];
-    static setGeometryPalette(palette) {
-        this.geometryPalette = new StringPalette(palette);
-    }
-    static models = new Map();
-    static registerModels(models) {
-        for (const model of models) {
-            this.models.set(model.id, new VoxelModelConstructor(model));
-        }
-    }
-    static registerGeometry(geometries) {
-        for (const geometry of geometries) {
-            const paletteId = this.geometryPalette.getNumberId(geometry.id);
-            if (geometry.ruleless == true) {
-                this.geometry[paletteId] = new VoxelGeometryRulelessConstructor(paletteId, geometry);
-                this.rulesless[paletteId] = true;
-            }
-            else {
-                this.geometry[paletteId] = new VoxelGeometryConstructor(paletteId, geometry);
-                this.rulesless[paletteId] = false;
-            }
-        }
-    }
-}

package/VoxelModels/Constructor/Register/VoxelModelsConstructor.d.ts

@@ -1,13 +0,0 @@
-import { StateSchema } from "../../State/Schema/StateSchema";
-import { CondtionalTreeReader } from "../../State/CondiotnalTreeReader";
-import { StateTreeReader } from "../../State/StateTreeReader";
-import { VoxelModelSyncData } from "../../VoxelModelRules.types";
-export declare class VoxelModelConstructor {
-    data: VoxelModelSyncData;
-    schema: StateSchema;
-    shapeStateTree: StateTreeReader;
-    condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(data: VoxelModelSyncData);
-    getShapeStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
-    getCondtionalStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
-}

package/VoxelModels/Constructor/Register/VoxelModelsConstructor.js

@@ -1,21 +0,0 @@
-import { StateSchema } from "../../State/Schema/StateSchema";
-import { CondtionalTreeReader } from "../../State/CondiotnalTreeReader";
-import { StateTreeReader } from "../../State/StateTreeReader";
-export class VoxelModelConstructor {
-    data;
-    schema;
-    shapeStateTree;
-    condtioanlShapeStateTree;
-    constructor(data) {
-        this.data = data;
-        this.schema = new StateSchema(data.schema);
-        this.shapeStateTree = new StateTreeReader(this.schema, 0, data.shapeStateTree);
-        this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
-    }
-    getShapeStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
-    getCondtionalStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
-}

package/VoxelModels/Constructor/VoxelModelVoxelConstructor.d.ts

@@ -1,24 +0,0 @@
-import { VoxelConstructor } from "../../Mesher/Constructors/Voxel/Classes/VoxelConstructor";
-import { TextureRegister } from "../../Textures/TextureRegister";
-import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
-import { VoxelModelConstructor } from "./Register/VoxelModelsConstructor";
-import { VoxelInputsSyncData } from "../VoxelModelRules.types";
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../Indexing/VoxelFaceTransparentResultsIndex";
-export declare class VoxelModelVoxelConstructor extends VoxelConstructor {
-    id: string;
-    model: VoxelModelConstructor;
-    isModel: true;
-    geometries: number[][];
-    modSchema: StateSchema;
-    modTree: StateTreeReader;
-    transparentIndex: VoxelFaceTransparentResultsIndex;
-    baseInputMap: any[];
-    conditonalInputMap: any[];
-    constructor(id: string, model: VoxelModelConstructor, voxleData: VoxelInputsSyncData);
-    isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    process(tool: VoxelMesherDataTool): void;
-    onTexturesRegistered(textureManager: typeof TextureRegister): void;
-}

package/VoxelModels/InitVoxelModels.d.ts

@@ -1,10 +0,0 @@
-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/Rules/Classes/VoxelRulesGeometry.d.ts

@@ -1,19 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { OcclusionFaceContainer } from "./OcclusionFace";
-import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
-import { BuildStateData } from "../Functions/BuildStateData";
-import { PrcoessedVoxelGeometryData } from "../../VoxelModelRules.types";
-export declare class VoxelRuleGeometry {
-    id: string;
-    data: PrcoessedVoxelGeometryData;
-    position?: Vec3Array | undefined;
-    scale?: Vec3Array | undefined;
-    rotation?: Vec3Array | undefined;
-    occlusionPlane: OcclusionFaceContainer;
-    faceCount: number;
-    vertexCount: number;
-    state: ReturnType<typeof BuildStateData>;
-    inputs: ReturnType<typeof BuildGeomtryInputs>;
-    constructor(id: string, data: PrcoessedVoxelGeometryData, position?: Vec3Array | undefined, scale?: Vec3Array | undefined, rotation?: Vec3Array | undefined);
-    clone(): VoxelRuleGeometry;
-}

package/VoxelModels/State/Schema/BinarySchema.js

@@ -1,52 +0,0 @@
-import { BinarySchemaNode } from "./BinarySchemaNode";
-export class BinarySchema {
-    nodeMap = new Map();
-    nodes = [];
-    constructor(schema) {
-        for (const node of schema) {
-            if (node.type == "binary") {
-                const newNode = new BinarySchemaNode(node);
-                this.nodes.push(newNode);
-                this.nodeMap.set(node.id, newNode);
-            }
-        }
-    }
-    _value = 0;
-    startEncoding() {
-        this._value = 0;
-        return this;
-    }
-    getNmber(id) {
-        const node = this.nodeMap.get(id);
-        if (!node)
-            throw new Error(`Node with ${id} does not exist.`);
-        return node.getValue(this._value);
-    }
-    getValue(id) {
-        const node = this.nodeMap.get(id);
-        if (!node)
-            throw new Error(`Node with ${id} does not exist.`);
-        if (!node.valuePalette)
-            throw new Error(`Node with ${id} does not have a value palette.`);
-        return node.valuePalette.getStringId(node.getValue(this._value));
-    }
-    setNumber(id, value) {
-        const node = this.nodeMap.get(id);
-        if (!node)
-            throw new Error(`Node with ${id} does not exist.`);
-        this._value = node.setValue(this._value, value);
-        return this;
-    }
-    setValue(id, value) {
-        const node = this.nodeMap.get(id);
-        if (!node)
-            throw new Error(`Node with ${id} does not exist.`);
-        if (!node.valuePalette)
-            throw new Error(`Node with ${id} does not have a value palette.`);
-        this._value = node.setValue(this._value, node.valuePalette.getNumberId(value));
-        return this;
-    }
-    getEncoded() {
-        return this._value;
-    }
-}

package/VoxelModels/State/Schema/Conditions/SameVoxelConditions.js

@@ -1,13 +0,0 @@
-import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
-export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
-    data;
-    constructor(schema, data) {
-        super(schema);
-        this.data = data;
-    }
-    evulate() {
-        if (!this.schema.nVoxel.loadInAt(this.schema.voxel.x + this.data.direction[0], this.schema.voxel.y + this.data.direction[1], this.schema.voxel.z + this.data.direction[2]))
-            return false;
-        return this.schema.voxel.getId() == this.schema.nVoxel.getId();
-    }
-}

package/VoxelModels/State/SchemaRegister.js

@@ -1,50 +0,0 @@
-import { BinarySchema } from "./Schema/BinarySchema";
-export class SchemaRegister {
-    static modelStaeSchemaData = new Map();
-    static voxelModSchemaData = new Map();
-    static modelStaeSchemas = new Map();
-    static voxelModSchemas = new Map();
-    static voxelModelMap = new Map();
-    static getVoxelSchemas(id) {
-        const modelId = this.voxelModelMap.get(id);
-        if (!modelId)
-            throw new Error(`Voxel with ${id} is not registered`);
-        let modelSchema = this.modelStaeSchemas.get(modelId);
-        if (!modelSchema) {
-            const schemaData = this.modelStaeSchemaData.get(modelId);
-            if (!schemaData)
-                throw new Error(`Model with ${modelId} is not registered`);
-            modelSchema = new BinarySchema(schemaData);
-        }
-        let voxelSchema = this.voxelModSchemas.get(modelId);
-        if (!voxelSchema) {
-            const schemaData = this.voxelModSchemaData.get(id);
-            if (!schemaData)
-                throw new Error(`Voxel with ${id} is not registered`);
-            voxelSchema = new BinarySchema(schemaData);
-        }
-        return {
-            modelSchema,
-            voxelSchema,
-        };
-    }
-    static registerModel(id, data) {
-        const binaryData = [];
-        for (const node of data) {
-            if (node.type == "binary") {
-                binaryData.push(node);
-            }
-        }
-        this.modelStaeSchemaData.set(id, binaryData);
-    }
-    static registerVoxel(id, modelId, data) {
-        this.voxelModelMap.set(id, modelId);
-        const binaryData = [];
-        for (const node of data) {
-            if (node.type == "binary") {
-                binaryData.push(node);
-            }
-        }
-        this.voxelModSchemaData.set(id, binaryData);
-    }
-}

package/VoxelModels/Tags/TagsOverrides.d.ts

@@ -1,5 +0,0 @@
-import { StateTreeReader } from "../State/StateTreeReader";
-export declare class TagOverrides {
-    static isLightSource: StateTreeReader[];
-    static lightValue: StateTreeReader[];
-}

package/VoxelModels/Tags/TagsOverrides.js

@@ -1,4 +0,0 @@
-export class TagOverrides {
-    static isLightSource = [];
-    static lightValue = [];
-}

package/VoxelModels/World/InitVoxelModelsWorld.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineWorld } from "../../Contexts/World";
-export default function (DVEW: DivineVoxelEngineWorld): void;

package/VoxelModels/World/InitVoxelModelsWorld.js

@@ -1,11 +0,0 @@
-import { SchemaRegister } from "../State/SchemaRegister";
-export default function (DVEW) {
-    DVEW.TC.registerTasks("sync-voxel-model-data", (data) => {
-        for (const model of data.models) {
-            SchemaRegister.registerModel(model.id, model.schema);
-        }
-        for (const voxel of data.voxels) {
-            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-        }
-    });
-}

package/WorldGeneration/WorldGenBrush.d.ts

@@ -1,75 +0,0 @@
-import type { Vec3Array } from "@amodx/math";
-import { RichDataTool } from "../Tools/Data/RichDataTool.js";
-import { BrushTool } from "../Tools/Brush/Brush.js";
-export declare class WorldGenBrush extends BrushTool {
-    constructor();
-    requestsId: "";
-    tasks: {
-        rebuildQueMap: Map<string, boolean>;
-        comm: import("@amodx/threads").Thread;
-        priority: import("../Types/Tasks.types.js").Priorities;
-        LOD: number;
-        syncQueue: import("../Math/index.js").LocationData[];
-        aSyncQueue: import("../Math/index.js").LocationData[];
-        buildMode: "sync" | "async";
-        buildTasks: import("../Types/Tasks.types.js").PriorityTask<import("../Types/Tasks.types.js").BuildTasks>;
-        trackedChunks: Map<string, Vec3Array>;
-        keepTrackOfChunks: boolean;
-        rebuildTasks: import("../Types/Tasks.types.js").AddToRebuildQueue;
-        tasksType: string;
-        origin: import("../Math/index.js").LocationData;
-        data: null;
-        buildQueue: string;
-        originThread: string;
-        queues: {
-            flow: {
-                update: {
-                    queue: number[][];
-                    map: import("../Util/VisistedMap.js").VisitedMap;
-                };
-                remove: {
-                    queue: number[][];
-                    map: import("../Util/VisistedMap.js").VisitedMap;
-                    noRemoveMap: import("../Util/VisistedMap.js").VisitedMap;
-                };
-            };
-            rgb: {
-                update: number[];
-                remove: number[];
-                map: import("../Util/VisistedMap.js").VisitedMap;
-            };
-            sun: {
-                update: number[];
-                remove: number[];
-                updateMap: import("../Util/VisistedMap.js").VisitedMap;
-                remvoeMap: import("../Util/VisistedMap.js").VisitedMap;
-            };
-        };
-        start(): any;
-        stop(): any;
-        setPriority(priority: import("../Types/Tasks.types.js").Priorities): any;
-        getData(): null;
-        getOriginThread(): import("../Math/index.js").LocationData;
-        getBuildQueue(): string;
-        getOrigin(): import("../Math/index.js").LocationData;
-        needsRebuild(): boolean;
-        needsToUpdateOriginThread(): boolean;
-        clearBuildQueue(): void;
-        setBuldMode(mode: "sync" | "async"): any;
-        addToRebuildQueue(x: number, y: number, z: number): boolean;
-        addNeighborsToRebuildQueue(x: number, y: number, z: number): false | any | undefined;
-        runRebuildQueue(): any;
-        clear(): void;
-    };
-    richData: RichDataTool;
-    setDimension(dimensionId: string): this;
-    get keepTrackOfChunksToBuild(): boolean;
-    set keepTrackOfChunksToBuild(value: boolean);
-    paint(): this;
-    getUpdatedChunks(): Vec3Array[];
-    update(): false | undefined;
-    erase(): this;
-    runUpdates(): void;
-    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
-    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
-}