@divinevoxel/vlox 0.0.74 → 0.0.76

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

@@ -1,20 +1,14 @@
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
-import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
-    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform): GeoemtryNode<Data, Args>;
+    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data): GeoemtryNode<Data, Args>;
 }
 export declare abstract class GeoemtryNode<Data = any, Args = any> {
     geometryPaletteId: number;
     geomtry: VoxelGeometryConstructor;
     data: Data;
-    transform: VoxelGeometryTransform;
-    faceIndex: number;
-    vertexIndex: number;
-    faceCount: number;
-    vertexCount: number;
     builder: VoxelModelBuilder;
-    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform);
+    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data);
     abstract init(): void;
     abstract add(args: Args): boolean;
 }

package/Mesher/Models/Nodes/GeometryNode.js

@@ -2,16 +2,10 @@ export class GeoemtryNode {
     geometryPaletteId;
     geomtry;
     data;
-    transform;
-    faceIndex = -1;
-    vertexIndex = -1;
-    faceCount = -1;
-    vertexCount = -1;
     builder;
-    constructor(geometryPaletteId, geomtry, data, transform) {
+    constructor(geometryPaletteId, geomtry, data) {
         this.geometryPaletteId = geometryPaletteId;
         this.geomtry = geomtry;
         this.data = data;
-        this.transform = transform;
     }
 }

package/Mesher/Models/Nodes/Types/GeomtryNode.types.d.ts

@@ -0,0 +1,7 @@
+import { CompiledQuadVoxelGeomtryNode } from "./QuadVoxelGometryNodeTypes";
+import { CompiledTriangleVoxelGeomtryNode } from "./TriangleVoxelGometryNodeTypes";
+export type CompiledCustomGeomtryNode = {
+    type: "custom";
+    id: string;
+};
+export type CompiledGeomtryNodes = CompiledQuadVoxelGeomtryNode | CompiledTriangleVoxelGeomtryNode | CompiledCustomGeomtryNode;

package/Mesher/Models/Nodes/Types/GeomtryNode.types.js

@@ -0,0 +1 @@
+export {};

package/Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes.d.ts

@@ -0,0 +1,29 @@
+import { Vec3Array, Vec4Array } from "@amodx/math";
+import { QuadUVData } from "../../../Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../../Math";
+export type QuadVoxelGometryArgs = [
+    enabled: boolean,
+    texture: number,
+    rotation: number,
+    doubleSided: boolean,
+    uvs: QuadUVData
+];
+declare enum ArgIndexes {
+    Enabled = 0,
+    Texture = 1,
+    Rotation = 2,
+    DoubleSided = 3,
+    UVs = 4
+}
+export type CompiledQuadVoxelGeomtryNode = {
+    type: "quad";
+    positions: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+    weights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+};
+export declare class QuadVoxelGometryInputs {
+    static ArgIndexes: typeof ArgIndexes;
+    static CreateArgs(): QuadVoxelGometryArgs;
+}
+export {};

package/{Models/Input/QuadVoxelGometryInputs.js → Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes.js}

@@ -1,22 +1,18 @@
 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["Texture"] = 1] = "Texture";
+    ArgIndexes[ArgIndexes["Rotation"] = 2] = "Rotation";
+    ArgIndexes[ArgIndexes["DoubleSided"] = 3] = "DoubleSided";
+    ArgIndexes[ArgIndexes["UVs"] = 4] = "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],

package/Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes.d.ts

@@ -0,0 +1,28 @@
+import { Vec2Array, Vec3Array, Vec4Array } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+export type TriangleVoxelGometryArgs = [
+    enabled: boolean,
+    texture: number,
+    rotation: number,
+    doubleSided: boolean,
+    uvs: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array]
+];
+declare enum ArgIndexes {
+    Enabled = 0,
+    Texture = 1,
+    Rotation = 2,
+    DoubleSided = 3,
+    UVs = 4
+}
+export type CompiledTriangleVoxelGeomtryNode = {
+    type: "triangle";
+    positions: [Vec3Array, Vec3Array, Vec3Array];
+    weights: [Vec4Array, Vec4Array, Vec4Array];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+};
+export declare class TriangleVoxelGometryInputs {
+    static ArgIndexes: typeof ArgIndexes;
+    static CreateArgs(): TriangleVoxelGometryArgs;
+}
+export {};

package/Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes.js

@@ -0,0 +1,24 @@
+var ArgIndexes;
+(function (ArgIndexes) {
+    ArgIndexes[ArgIndexes["Enabled"] = 0] = "Enabled";
+    ArgIndexes[ArgIndexes["Texture"] = 1] = "Texture";
+    ArgIndexes[ArgIndexes["Rotation"] = 2] = "Rotation";
+    ArgIndexes[ArgIndexes["DoubleSided"] = 3] = "DoubleSided";
+    ArgIndexes[ArgIndexes["UVs"] = 4] = "UVs";
+})(ArgIndexes || (ArgIndexes = {}));
+export class TriangleVoxelGometryInputs {
+    static ArgIndexes = ArgIndexes;
+    static CreateArgs() {
+        const args = [];
+        args[ArgIndexes.Enabled] = true;
+        args[ArgIndexes.Texture] = 0;
+        args[ArgIndexes.Rotation] = 0;
+        args[ArgIndexes.DoubleSided] = false;
+        args[ArgIndexes.UVs] = [
+            [1, 1],
+            [0, 1],
+            [0, 0],
+        ];
+        return args;
+    }
+}

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

@@ -1,13 +1,9 @@
-import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
-import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelGeometrySyncData } from "../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNode } from "./GeometryNode";
+import { CullingProcedureData } from "../../../Voxels/Models/VoxelModel.types";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
     nodes: GeoemtryNode<any, any>[];
-    faceCullMap: number[][];
-    vertexHitMap: number[][];
-    cullIndex: VoxelFaceCullResultsIndex;
-    aoIndex: VoxelAOResultsIndex;
-    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData);
+    cullingProcedure: CullingProcedureData;
+    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData);
 }

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -1,68 +1,32 @@
-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 { QuadVoxelGometryNode } from "./Default/QuadVoxelGeometryNode";
+import { TriangleVoxelGeometryNode } from "./Default/TriangleVoxelGeometryNode";
 import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
 export class VoxelGeometryConstructor {
     geometryPaletteId;
     nodes = [];
-    faceCullMap;
-    vertexHitMap;
-    cullIndex;
-    aoIndex;
+    cullingProcedure;
     constructor(geometryPaletteId, data) {
         this.geometryPaletteId = geometryPaletteId;
+        this.cullingProcedure = data.cullingProcedure;
         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);
+            if (node.type == "custom") {
+                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.id);
+                const newNode = new nodeClass(geometryPaletteId, this, node);
                 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);
-                }
+        for (const node of data.nodes) {
+            if (node.type == "quad") {
+                const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node);
+                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);
-                }
+            if (node.type == "triangle") {
+                const newNode = new TriangleVoxelGeometryNode(geometryPaletteId, this, node);
+                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/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -0,0 +1,25 @@
+import { Vec3Array, Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+interface VoxelGeometryConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "consistent-rotation";
+    texture: TextureId | number;
+    /**
+     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
+     */
+    rotations: (0 | 90 | 180 | 270)[];
+    rotationBounds?: Vec3Array;
+}
+export declare class ConsistentRotationTextureProcedure extends TextureProcedure<VoxelGeometryConsistentRotationTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.js

@@ -0,0 +1,44 @@
+import { Vector3Like } from "@amodx/math";
+import { TextureProcedure, } from "../TextureProcedure";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { GetYXZOrderArrayIndex } from "../../../../Math/Indexing";
+const voxelPos = Vector3Like.Create();
+const defaultBounds = [4, 4, 4];
+export class ConsistentRotationTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) {
+        const bounds = data.rotationBounds ? data.rotationBounds : defaultBounds;
+        WorldSpaces.voxel.getPositionFromIndex(builder.voxel._index, voxelPos);
+        const x = voxelPos.x - Math.floor(voxelPos.x / bounds[0]) * bounds[0];
+        const y = voxelPos.y - Math.floor(voxelPos.y / bounds[1]) * bounds[1];
+        const z = voxelPos.z - Math.floor(voxelPos.z / bounds[2]) * bounds[2];
+        const rotationIndex = GetYXZOrderArrayIndex(x, y, z, ...bounds) % data.rotations.length;
+        const rotation = data.rotations[rotationIndex];
+        for (const v of primitive.uvs.vertices) {
+            const oldX = v.x;
+            const oldY = v.y;
+            switch (rotation) {
+                case 90:
+                    v.x = 1 - oldY;
+                    v.y = oldX;
+                    break;
+                case 180:
+                    v.x = 1 - oldX;
+                    v.y = 1 - oldY;
+                    break;
+                case 270:
+                    v.x = oldY;
+                    v.y = 1 - oldX;
+                    break;
+                case 0:
+                default:
+                    break;
+            }
+        }
+    }
+}

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.d.ts

@@ -0,0 +1,28 @@
+import { Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "../../../../Math/index.js";
+interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "outlined";
+    texture: TextureId | number;
+    textureRecrod: {
+        top: TextureId | number;
+        "corner-top-right": TextureId | number;
+        "corner-top-left": TextureId | number;
+        "corner-top-left-top-right": TextureId | number;
+        bottom: TextureId | number;
+        "corner-bottom-right": TextureId | number;
+        "corner-bottom-left": TextureId | number;
+        "corner-bottom-left-bottom-right": TextureId | number;
+        right: TextureId | number;
+        left: TextureId | number;
+    };
+}
+export declare class OutlinedTextureProcedure extends TextureProcedure<OutlinedTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -0,0 +1,162 @@
+import { TextureProcedure } from "../TextureProcedure";
+import { VoxelFaces } from "../../../../Math/index.js";
+const textureMap = [
+    "top",
+    "corner-top-right",
+    "corner-top-left",
+    "corner-top-left-top-right",
+    "bottom",
+    "corner-bottom-right",
+    "corner-bottom-left",
+    "corner-bottom-left-bottom-right",
+    "right",
+    "left",
+];
+/*
+0 -> normal direction
+1 -> top right
+2 -> top left
+*/
+const uvsSets = {
+    //top bottom faces
+    north: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    south: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    east: {
+        0b0: 8,
+    },
+    west: {
+        0b0: 9,
+    },
+    //side faces
+    top: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    bottom: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    right: {
+        0b0: 8,
+    },
+    left: {
+        0b0: 9,
+    },
+};
+const topAndDown = {
+    north: [
+        [0, 0, 1],
+        [1, 0, 1],
+        [-1, 0, 1],
+    ],
+    south: [
+        [0, 0, -1],
+        [1, 0, -1],
+        [-1, 0, -1],
+    ],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
+};
+const eastAndWest = {
+    north: [
+        [0, 1, 0],
+        [0, 1, 1],
+        [0, 1, -1],
+    ],
+    south: [
+        [0, -1, 0],
+        [0, -1, 1],
+        [0, -1, -1],
+    ],
+    east: [[0, 0, 1]],
+    west: [[0, 0, -1]],
+};
+const northAndSouth = {
+    north: [
+        [0, 1, 0],
+        [1, 1, 0],
+        [-1, 1, 0],
+    ],
+    south: [
+        [0, -1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+    ],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
+};
+const CheckSets = {
+    [VoxelFaces.Up]: topAndDown,
+    [VoxelFaces.Down]: topAndDown,
+    [VoxelFaces.North]: northAndSouth,
+    [VoxelFaces.South]: northAndSouth,
+    [VoxelFaces.East]: eastAndWest,
+    [VoxelFaces.West]: eastAndWest,
+};
+const generateCheck = (direction, tool, normal, sets) => {
+    const { x, y, z } = tool.position;
+    let key = 0b0;
+    for (let i = 0; i < sets.length; i++) {
+        const set = sets[i];
+        const cx = x + set[0];
+        const cy = y + set[1];
+        const cz = z + set[2];
+        const sameLevelCheck = tool.nVoxel
+            .getVoxel(cx, cy, cz)
+            ?.isSameVoxel(tool.voxel);
+        let normalCheck = true;
+        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
+        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
+            normalCheck = false;
+        }
+        if (sameLevelCheck && normalCheck) {
+            key |= 0b1 << i;
+        }
+        else {
+            key |= 0b0 << i;
+            if (i == 0)
+                break;
+        }
+    }
+    if (uvsSets[direction][key] == undefined)
+        return 0;
+    const index = uvsSets[direction][key];
+    return textureMap[index];
+};
+const normal = [0, 0, 0];
+export class OutlinedTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        const set = CheckSets[closestFace];
+        const x = generateCheck("north", builder, normal, set.north);
+        if (x)
+            ref.x = data.textureRecrod[x];
+        const y = generateCheck("south", builder, normal, set.south);
+        if (y)
+            ref.y = data.textureRecrod[y];
+        const z = generateCheck("east", builder, normal, set.east);
+        if (z)
+            ref.z = data.textureRecrod[z];
+        const w = generateCheck("west", builder, normal, set.west);
+        if (w)
+            ref.w = data.textureRecrod[w];
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) { }
+}

package/Mesher/Models/Procedures/TextureProcedure.d.ts

@@ -0,0 +1,16 @@
+import { Vector4Like } from "@amodx/math";
+import { Quad, Triangle } from "../../Geomtry";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
+import { VoxelFaces } from "../../../Math";
+import { TextureId } from "../../../Textures";
+export interface BaseVoxelGeomtryTextureProcedureData {
+    type: string;
+    texture?: TextureId | number;
+    textureRecrod?: Record<string, TextureId | number>;
+    [key: string]: any;
+}
+export declare abstract class TextureProcedure<Data = any> {
+    abstract getTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): number;
+    abstract getOverlayTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle, ref: Vector4Like): Vector4Like;
+    abstract transformUVs(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): void;
+}

package/Mesher/Models/Procedures/TextureProcedure.js

@@ -0,0 +1,2 @@
+export class TextureProcedure {
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.d.ts

@@ -0,0 +1,6 @@
+import { TextureProcedure } from "./TextureProcedure";
+export declare class TextureProcedureRegister {
+    static procedures: Map<string, TextureProcedure<any>>;
+    static register(id: string, procedure: TextureProcedure): void;
+    static get(id: string): TextureProcedure<any>;
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.js

@@ -0,0 +1,16 @@
+import { ConsistentRotationTextureProcedure } from "./Default/ConsistentRotationTextureProcedure";
+import { OutlinedTextureProcedure } from "./Default/OutlinedTextureProcedure";
+export class TextureProcedureRegister {
+    static procedures = new Map();
+    static register(id, procedure) {
+        this.procedures.set(id, procedure);
+    }
+    static get(id) {
+        const procedure = this.procedures.get(id);
+        if (!procedure)
+            throw new Error(`Procedure with id ${id} does not exist`);
+        return procedure;
+    }
+}
+TextureProcedureRegister.register("consistent-rotation", new ConsistentRotationTextureProcedure());
+TextureProcedureRegister.register("outlined", new OutlinedTextureProcedure());

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,8 +1,7 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 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 {
@@ -13,7 +12,6 @@ export declare class VoxelConstructor {
     geometries: number[][];
     modSchema: StateSchema;
     modTree: StateTreeReader;
-    transparentIndex: VoxelFaceTransparentResultsIndex;
     baseInputMap: any[];
     conditonalInputMap: any[];
     schema: StateSchema;
@@ -21,7 +19,5 @@ export declare class VoxelConstructor {
     stateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    isShapeStateFaceTransparent(modState: number, stateTree: number, geoId: number, faceIndex: number): boolean;
-    isCondtionalStateFaceTransparent(modState: number, state: number, geoId: number, faceIndex: number): boolean;
     process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -1,7 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 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 {
@@ -12,7 +11,6 @@ export class VoxelConstructor {
     geometries = [];
     modSchema;
     modTree;
-    transparentIndex;
     baseInputMap;
     conditonalInputMap;
     schema;
@@ -25,7 +23,6 @@ export class VoxelConstructor {
         this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
-        this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
         this.schema = new StateSchema(data.schema);
         this.stateTree = new StateTreeReader(this.schema, 0, data.stateTree);
         this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
@@ -33,12 +30,6 @@ export class VoxelConstructor {
         this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.effects = new VoxelModelEffect(this);
     }
-    isShapeStateFaceTransparent(modState, stateTree, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.stateRelativeGeometryMap[stateTree][geoId]], faceIndex) == 1);
-    }
-    isCondtionalStateFaceTransparent(modState, state, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[state][geoId]], faceIndex) == 1);
-    }
     process() {
         let added = false;
         const builder = this.builder;
@@ -73,9 +64,8 @@ export class VoxelConstructor {
                 const geometriesLength = geometries.length;
                 const inputs = this.conditonalInputMap[modState][c];
                 for (let i = 0; i < geometriesLength; i++) {
-                    const nodeId = geometries[i];
                     const geoInputs = inputs[i];
-                    const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
+                    const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
                         const geo = geomtry.nodes[k];