@divinevoxel/vlox 0.0.2 → 0.0.4

package/{VoxelModels/Constructor → Mesher/Models}/Nodes/Ruled/QuadVoxelGeometryNode.js

@@ -1,74 +1,43 @@
 import { VoxelFaces } from "../../../../Math";
-import { Quad } from "@amodx/meshing/Classes/Quad";
 import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
 import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
-import { addQuadWeights, closestUnitNormal, getInterpolationValue, shouldCauseFlip, } from "../../../../Mesher/Calc/CalcConstants";
-import { LightData } from "../../../../Data/LightData";
-import { VoxelRelativeCubeIndexPositionMap } from "../../../Indexing/VoxelRelativeCubeIndex";
-import { QuadVoxelGometryInputs, } from "../../../Input/QuadVoxelGometryInputs";
-import { TransformQuad } from "../../../Shared/Transform";
+import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
+import { LightData } from "../../../../Voxels/LightData";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
+import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
+import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
+import { UpdateBounds } from "../../Common/BoundsFunctions";
 const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
 export class QuadVoxelGometryNode extends GeoemtryNode {
-    data;
     quad;
+    quadBounds = [
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
     vertexWeights;
     worldLight;
     worldAO;
     closestFace;
-    constructor(geometryPaletteId, geometry, data, transform) {
-        super(geometryPaletteId, geometry);
-        this.data = data;
+    init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
-        this.quad = TransformQuad(Quad.Create(data.points), transform);
-        this.quad.orientation = 0;
-        const normals = this.quad.normals.getAsArray();
-        const averageNormal = [0, 0, 0];
-        for (let i = 0; i < normals.length; i++) {
-            averageNormal[0] += normals[i].x;
-            averageNormal[1] += normals[i].y;
-            averageNormal[2] += normals[i].z;
-        }
-        averageNormal[0] /= normals.length;
-        averageNormal[1] /= normals.length;
-        averageNormal[2] /= 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;
-        }
-        const unitNormal = closestUnitNormal(averageNormal);
-        let closestFace = VoxelFaces.Up;
-        if (unitNormal[0] == 1)
-            closestFace = VoxelFaces.East;
-        if (unitNormal[0] == -1)
-            closestFace = VoxelFaces.West;
-        if (unitNormal[1] == 1)
-            closestFace = VoxelFaces.Up;
-        if (unitNormal[1] == -1)
-            closestFace = VoxelFaces.Down;
-        if (unitNormal[2] == 1)
-            closestFace = VoxelFaces.North;
-        if (unitNormal[2] == -1)
-            closestFace = VoxelFaces.South;
-        this.vertexWeights = addQuadWeights(this.quad, closestFace);
+        const { quad, quadBounds, closestFace, vertexWeights } = GetQuadGeometryData(this.data, this.transform);
+        this.quad = quad;
+        this.quadBounds = quadBounds;
+        this.vertexWeights = vertexWeights;
         this.closestFace = closestFace;
     }
     isExposed() {
         const trueFaceIndex = this.faceIndex;
-        const faceIndexes = this.geomtry.data.faceCullMap[trueFaceIndex];
+        const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
         const tool = this.tool;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+            const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
             const offsetBaseGometry = VoxelGeometryLookUp.geometryCache[hashed];
             const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
             if (offsetBaseGometry) {
@@ -106,13 +75,13 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             if (noAO)
                 continue;
             const trueVertexIndex = this.vertexIndex + 4 + v;
-            const aoIndexes = this.geomtry.data.vertexHitMap[trueVertexIndex];
+            const aoIndexes = this.geomtry.vertexHitMap[trueVertexIndex];
             if (!aoIndexes)
                 continue;
             for (let positionIndex = 0; positionIndex < aoIndexes.length; positionIndex++) {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-                const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+                const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
                 if (VoxelGeometryLookUp.noCastAO[hashed] === true)
                     continue;
                 const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
@@ -154,7 +123,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
-        this.origin = tool.voxel;
+        this.origin = tool.position;
         this.worldAO = tool.getWorldAO();
         this.worldLight = tool.getWorldLight();
         if (args[ArgIndexes.Enabled] && this.isExposed()) {
@@ -178,6 +147,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             quad.uvs.vertices[3].x = uvs[3][0];
             quad.uvs.vertices[3].y = uvs[3][1];
             VoxelGeometry.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, this.quadBounds);
         }
         this.worldLight.setAll(0);
         this.worldAO.setAll(0);

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.d.ts

@@ -0,0 +1,19 @@
+import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
+import { GeoemtryNode } from "../GeometryNode";
+export declare class RulelessBoxVoxelGeometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
+    quads: Record<VoxelFaces, Quad>;
+    quadBounds: [Vec3Array, Vec3Array][];
+    vertexWeights: Record<VoxelFaces, [Vec4Array, Vec4Array, Vec4Array, Vec4Array]>;
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    init(): void;
+    determineShading(face: VoxelFaces): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
+}

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.js

@@ -0,0 +1,75 @@
+import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
+import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
+import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
+import { LightData } from "../../../../Voxels/LightData";
+import { GeoemtryNode } from "../GeometryNode";
+import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
+import { UpdateBounds } from "../../Common/BoundsFunctions";
+const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
+export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
+    quads;
+    quadBounds = [];
+    vertexWeights;
+    worldLight;
+    worldAO;
+    init() {
+        this.faceCount = 6;
+        this.vertexCount = this.faceCount * 4;
+        const { quads, vertexWeights, quadBounds } = GetBoxGeometryNodeData(this.data.points, this.transform);
+        this.quads = quads;
+        this.quadBounds = quadBounds;
+        this.vertexWeights = vertexWeights;
+    }
+    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.position;
+        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);
+                UpdateBounds(tool, origin, this.quadBounds[face]);
+            }
+        }
+        this.worldLight.setAll(0);
+        this.worldAO.setAll(0);
+    }
+}

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -0,0 +1,20 @@
+import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
+import { GeoemtryNode } from "../GeometryNode";
+export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
+    quad: Quad;
+    quadBounds: [Vec3Array, Vec3Array];
+    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    closestFace: VoxelFaces;
+    init(): void;
+    determineShading(): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
+}

package/{VoxelModels/Constructor → Mesher/Models}/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.js

@@ -1,60 +1,29 @@
 import { VoxelFaces } from "../../../../Math";
-import { Quad } from "@amodx/meshing/Classes/Quad";
 import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
-import { addQuadWeights, closestUnitNormal, getInterpolationValue, shouldCauseFlip, } from "../../../../Mesher/Calc/CalcConstants";
-import { LightData } from "../../../../Data/LightData";
-import { QuadVoxelGometryInputs, } from "../../../Input/QuadVoxelGometryInputs";
-import { RulelessGeoemtryNode } from "../RulelessGeometryNode";
-import { TransformQuad } from "../../../Shared/Transform";
+import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
+import { LightData } from "../../../../Voxels/LightData";
+import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
+import { GeoemtryNode } from "../GeometryNode";
+import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
+import { UpdateBounds } from "../../Common/BoundsFunctions";
 const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
-export class RulelessQuadVoxelGeometryNode extends RulelessGeoemtryNode {
-    data;
+export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
     quad;
+    quadBounds = [
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
     vertexWeights;
     worldLight;
     worldAO;
     closestFace;
-    constructor(geometryPaletteId, geometry, data, transform) {
-        super(geometryPaletteId, geometry);
-        this.data = data;
+    init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
-        this.quad = TransformQuad(Quad.Create(data.points), transform);
-        this.quad.orientation = 0;
-        const normals = this.quad.normals.getAsArray();
-        const averageNormal = [0, 0, 0];
-        for (let i = 0; i < normals.length; i++) {
-            averageNormal[0] += normals[i].x;
-            averageNormal[1] += normals[i].y;
-            averageNormal[2] += normals[i].z;
-        }
-        averageNormal[0] /= normals.length;
-        averageNormal[1] /= normals.length;
-        averageNormal[2] /= 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;
-        }
-        const unitNormal = closestUnitNormal(averageNormal);
-        let closestFace = VoxelFaces.Up;
-        if (unitNormal[0] == 1)
-            closestFace = VoxelFaces.East;
-        if (unitNormal[0] == -1)
-            closestFace = VoxelFaces.West;
-        if (unitNormal[1] == 1)
-            closestFace = VoxelFaces.Up;
-        if (unitNormal[1] == -1)
-            closestFace = VoxelFaces.Down;
-        if (unitNormal[2] == 1)
-            closestFace = VoxelFaces.North;
-        if (unitNormal[2] == -1)
-            closestFace = VoxelFaces.South;
-        this.vertexWeights = addQuadWeights(this.quad, closestFace);
+        const { quad, closestFace, vertexWeights, quadBounds } = GetQuadGeometryData(this.data, this.transform);
+        this.quad = quad;
+        this.quadBounds = quadBounds;
+        this.vertexWeights = vertexWeights;
         this.closestFace = closestFace;
     }
     determineShading() {
@@ -78,7 +47,7 @@ export class RulelessQuadVoxelGeometryNode extends RulelessGeoemtryNode {
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
-        this.origin = tool.voxel;
+        this.origin = tool.position;
         this.worldAO = tool.getWorldAO();
         this.worldLight = tool.getWorldLight();
         if (args[ArgIndexes.Enabled]) {
@@ -102,6 +71,7 @@ export class RulelessQuadVoxelGeometryNode extends RulelessGeoemtryNode {
             quad.uvs.vertices[3].x = uvs[3][0];
             quad.uvs.vertices[3].y = uvs[3][1];
             VoxelGeometry.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, this.quadBounds);
         }
         this.worldLight.setAll(0);
         this.worldAO.setAll(0);

package/Mesher/Models/Nodes/VoxelGeometryConstructor.d.ts

@@ -0,0 +1,13 @@
+import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
+import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
+import { VoxelGeometryRulelessSyncData, VoxelGeometrySyncData } from "../../../Voxels/VoxelSyncData";
+import { GeoemtryNode } from "./GeometryNode";
+export declare class VoxelGeometryConstructor {
+    geometryPaletteId: number;
+    nodes: GeoemtryNode<any, any>[];
+    faceCullMap: number[][];
+    vertexHitMap: number[][];
+    cullIndex: VoxelFaceCullResultsIndex;
+    aoIndex: VoxelAOResultsIndex;
+    constructor(geometryPaletteId: number, data: VoxelGeometrySyncData | VoxelGeometryRulelessSyncData);
+}

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -0,0 +1,68 @@
+import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
+import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
+import { BoxVoxelGometryNode } from "./Ruled/BoxVoxelGeometryNode";
+import { QuadVoxelGometryNode } from "./Ruled/QuadVoxelGeometryNode";
+import { RulelessQuadVoxelGeometryNode } from "./Ruleless/RulelessQuadVoxelGeometryNode";
+import { RulelessBoxVoxelGeometryNode } from "./Ruleless/RulelessBoxVoxelGeometryNode";
+import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
+export class VoxelGeometryConstructor {
+    geometryPaletteId;
+    nodes = [];
+    faceCullMap;
+    vertexHitMap;
+    cullIndex;
+    aoIndex;
+    constructor(geometryPaletteId, data) {
+        this.geometryPaletteId = geometryPaletteId;
+        for (const node of data.nodes) {
+            if (node.node.type == "custom") {
+                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.node.id);
+                const newNode = new nodeClass(geometryPaletteId, this, node.node, node.tranform);
+                newNode.init();
+                this.nodes.push(newNode);
+            }
+        }
+        if (data?.ruleless) {
+            data = data;
+            for (const node of data.nodes) {
+                if (node.node.type == "box") {
+                    const newNode = new RulelessBoxVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
+                    newNode.init();
+                    this.nodes.push(newNode);
+                }
+                if (node.node.type == "quad") {
+                    const newNode = new RulelessQuadVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
+                    newNode.init();
+                    this.nodes.push(newNode);
+                }
+            }
+        }
+        else {
+            data = data;
+            this.faceCullMap = data.faceCullMap;
+            this.vertexHitMap = data.vertexHitMap;
+            this.cullIndex = new VoxelFaceCullResultsIndex(data.cullIndex);
+            this.aoIndex = new VoxelAOResultsIndex(data.aoIndex);
+            for (const node of data.nodes) {
+                if (node.node.type == "box") {
+                    const newNode = new BoxVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
+                    newNode.init();
+                    this.nodes.push(newNode);
+                }
+                if (node.node.type == "quad") {
+                    const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
+                    newNode.init();
+                    this.nodes.push(newNode);
+                }
+            }
+        }
+        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/Mesher/Models/VoxelConstructor.d.ts

@@ -0,0 +1,30 @@
+import { TextureRegister } from "../../Textures/TextureRegister";
+import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
+import { VoxelInputsSyncData, VoxelModelSyncData } from "../../Voxels/VoxelSyncData";
+import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelEffect } from "./VoxelModelEffect";
+import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+export declare class VoxelConstructor {
+    id: string;
+    data: VoxelModelSyncData;
+    isModel: true;
+    geometries: number[][];
+    modSchema: StateSchema;
+    modTree: StateTreeReader;
+    transparentIndex: VoxelFaceTransparentResultsIndex;
+    baseInputMap: any[];
+    conditonalInputMap: any[];
+    schema: StateSchema;
+    effects: VoxelModelEffect;
+    shapeStateTree: StateTreeReader;
+    condtioanlShapeStateTree: CondtionalTreeReader;
+    constructor(id: string, data: VoxelModelSyncData, voxleData: VoxelInputsSyncData);
+    getShapeStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
+    getCondtionalStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
+    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/Constructor/VoxelModelVoxelConstructor.js → Mesher/Models/VoxelConstructor.js}

@@ -1,13 +1,13 @@
-import { VoxelConstructor } from "../../Mesher/Constructors/Voxel/Classes/VoxelConstructor";
-import { VoxelModelConstructorRegister } from "./Register/VoxelModelConstructorRegister";
-import { ShapeTool } from "../../Mesher/Shapes/ShapeTool";
+import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { VoxelGeometryLookUp } from "./VoxelGeometryLookUp";
-import { StateSchema } from "../State/Schema/StateSchema";
-import { StateTreeReader } from "../State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../Indexing/VoxelFaceTransparentResultsIndex";
-export class VoxelModelVoxelConstructor extends VoxelConstructor {
+import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelEffect } from "./VoxelModelEffect";
+import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+export class VoxelConstructor {
     id;
-    model;
+    data;
     isModel = true;
     geometries = [];
     modSchema;
@@ -15,29 +15,42 @@ export class VoxelModelVoxelConstructor extends VoxelConstructor {
     transparentIndex;
     baseInputMap;
     conditonalInputMap;
-    constructor(id, model, voxleData) {
-        super();
+    schema;
+    effects;
+    shapeStateTree;
+    condtioanlShapeStateTree;
+    constructor(id, data, voxleData) {
         this.id = id;
-        this.model = model;
+        this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
         this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
         this.modSchema = new StateSchema(voxleData.modSchema);
         this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
+        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);
+        this.effects = new VoxelModelEffect(this);
+    }
+    getShapeStateTransaprentByteIndex(shapeState, geomtryId) {
+        return this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geomtryId]];
+    }
+    getCondtionalStateTransaprentByteIndex(shapeState, geomtryId) {
+        return this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geomtryId]];
     }
     isShapeStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.model.getShapeStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.getShapeStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
     }
     isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.model.getCondtionalStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.getCondtionalStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
     }
     process(tool) {
-        const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x, tool.voxel.y, tool.voxel.z);
+        const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
         const treeState = VoxelGeometryLookUp.stateCache[hashed];
         const modState = VoxelGeometryLookUp.modCache[hashed];
         if (treeState !== undefined && treeState > -1) {
-            const geoLinks = this.model.data.shapeStateMap[treeState];
-            const geometries = this.model.data.shapeStateGeometryMap[treeState];
+            const geoLinks = this.data.shapeStateMap[treeState];
+            const geometries = this.data.shapeStateGeometryMap[treeState];
             const geometriesLength = geoLinks.length;
             const inputs = this.baseInputMap[modState][treeState];
             for (let i = 0; i < geometriesLength; i++) {
@@ -46,13 +59,13 @@ export class VoxelModelVoxelConstructor extends VoxelConstructor {
                 const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                 const nodesLength = geomtry.nodes.length;
                 for (let k = 0; k < nodesLength; k++) {
-                    geomtry.nodes[k].add(tool, hashed, ShapeTool.origin, geoInputs[k]);
+                    geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
                 }
             }
         }
         const conditonalTreeState = VoxelGeometryLookUp.conditonalStateCache[hashed];
         if (conditonalTreeState !== undefined && conditonalTreeState > -1) {
-            const condiotnalNodes = this.model.data.condiotnalShapeStateMap[conditonalTreeState];
+            const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
             for (let c = 0; c < condiotnalNodesLength; c++) {
                 const geometries = condiotnalNodes[c];
@@ -61,14 +74,15 @@ export class VoxelModelVoxelConstructor extends VoxelConstructor {
                 for (let i = 0; i < geometriesLength; i++) {
                     const nodeId = geometries[i];
                     const geoInputs = inputs[i];
-                    const geomtry = VoxelModelConstructorRegister.geometry[this.model.data.geoLinkMap[nodeId]];
+                    const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
-                        geomtry.nodes[k].add(tool, hashed, ShapeTool.origin, geoInputs[k]);
+                        geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
                     }
                 }
             }
         }
+        this.effects.addEffects(tool.voxel.getShapeState(), tool.origin, tool.effects);
         tool.clearCalculatedData();
     }
     onTexturesRegistered(textureManager) { }

package/{VoxelModels/Constructor → Mesher/Models}/VoxelGeometryLookUp.d.ts

@@ -1,9 +1,9 @@
-import { DataTool } from "../../Tools/Data/DataTool";
-import { VoxelModelVoxelConstructor } from "./VoxelModelVoxelConstructor";
+import { DataCursorInterface } from "../../Data/Cursor/Interfaces/DataCursor.interface";
+import { VoxelConstructor } from "./VoxelConstructor";
 import { Vec3Array } from "@amodx/math";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
 export declare class VoxelGeometryLookUp {
-    static dataTool: DataTool;
-    static voxelHash: VoxelModelVoxelConstructor[];
+    static voxelHash: VoxelConstructor[];
     static modCache: number[];
     static stateCache: number[];
     static conditonalStateCache: number[];
@@ -11,10 +11,11 @@ export declare class VoxelGeometryLookUp {
     static conditionalGeometryCache: number[][][];
     static noCastAO: boolean[];
     static offset: Vec3Array;
+    static voxelCursor: VoxelCursor;
     static init(): void;
     static start(dimension: string, x: number, y: number, z: number): void;
     static isRulesless(geoId: number): boolean;
     static stop(): void;
-    static getHash(x: number, y: number, z: number): number;
+    static getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
     private static hashState;
 }