@divinevoxel/vlox 0.0.0

package/Mesher/Calc/Light/LightGradient.js

@@ -0,0 +1,255 @@
+import { OverrideManager } from "../../Rules/Overrides/OverridesManager.js";
+import { LightData } from "../../../Data/LightData";
+import { QuadScalarVertexData, QuadVec3ArrayVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { SubstanceRules } from "../../Rules/SubstanceRules.js";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { VoxelFaces, VoxelFaceDirections } from "../../../Math";
+import { Vector3Like } from "@amodx/math";
+import { GradientCheckSets } from "../CalcConstants";
+const LD = LightData;
+const LightValue = new QuadScalarVertexData();
+const AOValue = new QuadScalarVertexData();
+const AOGeometryValues = new QuadVec3ArrayVertexData();
+const isMax = (num, v1, v2) => {
+    return num >= v1 && num >= v2;
+};
+const isAllEqual = (num, v1, v2, v3) => {
+    return num == v1 && v1 == v2 && v2 == v3;
+};
+const shouldSunFlip = (face) => {
+    const upRight = LD.getS(LightValue.vertices[QuadVerticies.TopRight]);
+    const upLeft = LD.getS(LightValue.vertices[QuadVerticies.TopLeft]);
+    const downLeft = LD.getS(LightValue.vertices[QuadVerticies.BottomLeft]);
+    const downRight = LD.getS(LightValue.vertices[QuadVerticies.BottomRight]);
+    if (isAllEqual(upRight, upLeft, downLeft, downRight))
+        return false;
+    const t1 = downLeft > upLeft && downLeft > upRight && downLeft > downRight;
+    const t2 = upRight > upLeft && upRight > downLeft && upRight > downRight;
+    const t3 = upLeft < downLeft && upLeft < upRight && upLeft < downRight;
+    const t4 = downRight < upLeft && downRight < upRight && downRight < upLeft;
+    if (t1 && !t2)
+        return true;
+    if (t2 && !t1)
+        return true;
+    if (t3)
+        return true;
+    if (t4)
+        return true;
+    return false;
+};
+const shouldRGBFlip = (face) => {
+    const upRight = LD.getRGB(LightValue.vertices[QuadVerticies.TopRight]);
+    const upLeft = LD.getRGB(LightValue.vertices[QuadVerticies.TopLeft]);
+    const downLeft = LD.getRGB(LightValue.vertices[QuadVerticies.BottomLeft]);
+    const downRight = LD.getRGB(LightValue.vertices[QuadVerticies.BottomRight]);
+    if (isAllEqual(upRight, upLeft, downLeft, downRight))
+        return false;
+    const t1 = downLeft > upLeft && downLeft > upRight && downLeft > downRight;
+    const t2 = upRight > upLeft && upRight > downLeft && upRight > downRight;
+    const t3 = upLeft < downLeft && upLeft < upRight && upLeft < downRight;
+    const t4 = downRight < upLeft && downRight < upRight && downRight < upLeft;
+    if (t1 && !t2)
+        return true;
+    if (t2 && !t1)
+        return true;
+    if (t3)
+        return true;
+    if (t4)
+        return true;
+    return false;
+};
+const shouldAOFlip = (face) => {
+    if (states.ignoreAO)
+        return false;
+    LightGradient.tool.faceDataOverride.face = face;
+    LightGradient.tool.faceDataOverride.default = false;
+    if (OverrideManager.AOFlipFace.run(LightGradient.tool.voxel.getShapeId(), OverrideManager.ANY, LightGradient.tool.faceDataOverride)) {
+        return false;
+    }
+    const upRight = AOValue.vertices[QuadVerticies.TopRight];
+    const upLeft = AOValue.vertices[QuadVerticies.TopLeft];
+    const downRight = AOValue.vertices[QuadVerticies.BottomRight];
+    const downLeft = AOValue.vertices[QuadVerticies.BottomLeft];
+    if (isAllEqual(upRight, upLeft, downLeft, downRight))
+        return false;
+    const t1 = isMax(upRight, upLeft, downRight);
+    const t2 = isMax(downLeft, upLeft, downRight);
+    if (t1 || t2)
+        return true;
+    return false;
+};
+const flipCheck = (face) => {
+    if (shouldAOFlip(face))
+        return true;
+    if (shouldRGBFlip(face))
+        return true;
+    return shouldSunFlip(face);
+};
+/**
+ *
+2       1
+|    /  |
+|   /   |
+|  /    |
+| /     |
+3       4
+
+
+ */
+const states = { ignoreAO: false };
+const newRGBValues = [];
+const RGBValues = { r: 0, g: 0, b: 0 };
+const sunValues = { s: 0 };
+const nlValues = { s: 0, r: 0, g: 0, b: 0 };
+const AOValues = { a: 0 };
+export const LightGradient = {
+    tool: {},
+    settings: {
+        doAO: true,
+        doRGB: true,
+        doSun: true,
+    },
+    aoOffset: Vector3Like.Create(),
+    calculate(face, tool, ignoreAO) {
+        tool.setFaceFlipped(false).getWorldLight().setAll(0);
+        tool.getWorldAO().setAll(0);
+        this.tool = tool;
+        const voxelSubstance = SubstanceRules.getSubstanceParent(tool.voxel.getSubstance());
+        const isLightSource = tool.voxel.isLightSource();
+        let light = tool.voxel.getLight();
+        let aoOverRide = -1;
+        AOValue.setAll(1);
+        if (this.settings.doAO && !ignoreAO) {
+            states.ignoreAO = false;
+        }
+        else {
+            states.ignoreAO = true;
+        }
+        let baseAO = 0;
+        const faceNormal = VoxelFaceDirections[face];
+        tool.nVoxel.loadInAt(tool.voxel.x + faceNormal[0], tool.voxel.y + faceNormal[1], tool.voxel.z + faceNormal[2]);
+        light = tool.nVoxel.getLight();
+        if (light < 0) {
+            if (tool.voxel.getLight() >= 0) {
+                light = tool.voxel.getLight();
+            }
+            else {
+                light = 0;
+            }
+        }
+        if (face == VoxelFaces.Up) {
+            if (tool.nVoxel.isRenderable() && !tool.nVoxel.isLightSource()) {
+                tool.faceDataOverride.face = face;
+                tool.faceDataOverride.default = false;
+                if (OverrideManager.DarkenFaceUnderneath.run(tool.nVoxel.getShapeId(), OverrideManager.ANY, tool.faceDataOverride)) {
+                    aoOverRide = 1;
+                }
+            }
+        }
+        for (let vertex = 0; vertex < 4; vertex++) {
+            const checkSet = GradientCheckSets[face][vertex];
+            if (this.settings.doRGB || this.settings.doSun) {
+                const values = LD.getLightValues(light);
+                if (this.settings.doSun) {
+                    sunValues.s = values[0];
+                }
+                if (this.settings.doRGB) {
+                    RGBValues.r = values[1];
+                    RGBValues.g = values[2];
+                    RGBValues.b = values[3];
+                }
+            }
+            AOValues.a = 0;
+            let checkSetIndex = 0;
+            for (let i = 0; i < 9; i += 3) {
+                if (this.settings.doRGB || this.settings.doSun) {
+                    if (!tool.nVoxel.loadInAt(checkSet[i] + tool.voxel.x, checkSet[i + 1] + tool.voxel.y, checkSet[i + 2] + tool.voxel.z))
+                        continue;
+                    const nl = tool.nVoxel.getLight();
+                    if (nl >= 0) {
+                        const values = LD.getLightValues(nl);
+                        nlValues.s = values[0];
+                        nlValues.r = values[1];
+                        nlValues.g = values[2];
+                        nlValues.b = values[3];
+                        if (this.settings.doRGB) {
+                            if (LD.removeS(nl)) {
+                                if (nlValues.r > RGBValues.r && RGBValues.r < 15) {
+                                    RGBValues.r = nlValues.r;
+                                }
+                                if (nlValues.g > RGBValues.g && RGBValues.g < 15) {
+                                    RGBValues.g = nlValues.g;
+                                }
+                                if (nlValues.b > RGBValues.b && RGBValues.b < 15) {
+                                    RGBValues.b = nlValues.b;
+                                }
+                            }
+                        }
+                        if (this.settings.doSun) {
+                            if (LD.getS(nl)) {
+                                if (sunValues.s < nlValues.s && sunValues.s < 15) {
+                                    sunValues.s = nlValues.s;
+                                }
+                            }
+                        }
+                    }
+                }
+                /*
+            Do AO
+            */
+                if (!states.ignoreAO) {
+                    if (!tool.nVoxel.loadInAt(tool.nVoxel.x + this.aoOffset.x, tool.nVoxel.y + this.aoOffset.y, tool.nVoxel.z + this.aoOffset.z))
+                        continue;
+                    if (aoOverRide > 0) {
+                        AOValues.a = aoOverRide;
+                    }
+                    else if (!tool.nVoxel.isRenderable()) {
+                    }
+                    else {
+                        const neighborVoxelSubstance = SubstanceRules.getSubstanceParent(tool.nVoxel.getSubstance());
+                        const neightLightSource = tool.nVoxel.isLightSource();
+                        let finalResult = true;
+                        if (neighborVoxelSubstance != voxelSubstance) {
+                            finalResult = false;
+                        }
+                        if (isLightSource || neightLightSource) {
+                            finalResult = false;
+                        }
+                        tool.faceDataOverride.face = face;
+                        tool.faceDataOverride.default = finalResult;
+                        finalResult = OverrideManager.AO.run(tool.voxel.getShapeId(), tool.nVoxel.getShapeId(), tool.faceDataOverride);
+                        if (finalResult) {
+                            AOValues.a++;
+                        }
+                    }
+                }
+                checkSetIndex++;
+            }
+            /*
+         Light End
+         */
+            if (this.settings.doSun || this.settings.doRGB) {
+                newRGBValues[0] = sunValues.s;
+                newRGBValues[1] = RGBValues.r;
+                newRGBValues[2] = RGBValues.g;
+                newRGBValues[3] = RGBValues.b;
+                LightValue.setVertex(vertex, LD.setLightValues(newRGBValues));
+            }
+            /*
+         AO End
+         */
+            if (this.settings.doAO) {
+                AOValue.setVertex(vertex, Math.ceil((AOValues.a / 3) * 15));
+            }
+        }
+        tool
+            .setFaceFlipped(flipCheck(face))
+            .getWorldLight()
+            .set(LightValue.vertices[QuadVerticies.TopRight], LightValue.vertices[QuadVerticies.TopLeft], LightValue.vertices[QuadVerticies.BottomLeft], LightValue.vertices[QuadVerticies.BottomRight]);
+        if (!states.ignoreAO) {
+            tool
+                .getWorldAO()
+                .set(AOValue.vertices[QuadVerticies.TopRight], AOValue.vertices[QuadVerticies.TopLeft], AOValue.vertices[QuadVerticies.BottomLeft], AOValue.vertices[QuadVerticies.BottomRight]);
+        }
+    },
+};

package/Mesher/Constructors/Voxel/Classes/Cube/ModCube.constructor.d.ts

@@ -0,0 +1,13 @@
+import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
+import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
+import { VoxelFaces } from "../../../../../Math/index.js";
+export declare class ModCubeVoxelConstructor extends VoxelConstructor {
+    id: string;
+    textureData: ConstructorTextureData[] | Record<VoxelFaces, ConstructorTextureData[]>;
+    textures: Record<VoxelFaces, number[]>;
+    constructor(id: string, textureData: ConstructorTextureData[] | Record<VoxelFaces, ConstructorTextureData[]>);
+    process(tool: VoxelMesherDataTool): void;
+    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+}

package/Mesher/Constructors/Voxel/Classes/Cube/ModCube.constructor.js

@@ -0,0 +1,77 @@
+import { CubeVoxelShape } from "../../../../Shapes/default/Cube/Cube.voxel.shape.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { VoxelFaces, VoxelFacesArray } from "../../../../../Math/index.js";
+export class ModCubeVoxelConstructor extends VoxelConstructor {
+    id;
+    textureData;
+    textures = {
+        [VoxelFaces.Up]: [],
+        [VoxelFaces.Down]: [],
+        [VoxelFaces.North]: [],
+        [VoxelFaces.South]: [],
+        [VoxelFaces.East]: [],
+        [VoxelFaces.West]: [],
+    };
+    constructor(id, textureData) {
+        super();
+        this.id = id;
+        this.textureData = textureData;
+    }
+    process(tool) {
+        tool.getOverlayTextures().setAll(0);
+        const shapeState = tool.voxel.getMod();
+        if (tool.isFaceExposed(VoxelFaces.Up)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.Up][shapeState])
+                .calculateLight(VoxelFaces.Up);
+            CubeVoxelShape.add.up();
+        }
+        if (tool.isFaceExposed(VoxelFaces.Down)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.Down][shapeState])
+                .calculateLight(VoxelFaces.Down);
+            CubeVoxelShape.add.down();
+        }
+        if (tool.isFaceExposed(VoxelFaces.East)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.East][shapeState])
+                .calculateLight(VoxelFaces.East);
+            CubeVoxelShape.add.east();
+        }
+        if (tool.isFaceExposed(VoxelFaces.West)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.West][shapeState])
+                .calculateLight(VoxelFaces.West);
+            CubeVoxelShape.add.west();
+        }
+        if (tool.isFaceExposed(VoxelFaces.South)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.South][shapeState])
+                .calculateLight(VoxelFaces.South);
+            CubeVoxelShape.add.south();
+        }
+        if (tool.isFaceExposed(VoxelFaces.North)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.North][shapeState])
+                .calculateLight(VoxelFaces.North);
+            CubeVoxelShape.add.north();
+        }
+    }
+    onTexturesRegistered(textureManager) {
+        const textures = this.textureData;
+        const push = (direction, ...textureIndex) => {
+            this.textures[direction].push(...textureIndex);
+        };
+        if (Array.isArray(textures)) {
+            for (const texture of textures) {
+                for (const face of VoxelFacesArray) {
+                    push(face, textureManager.getTextureUV(texture));
+                }
+            }
+            return;
+        }
+        for (const face of VoxelFacesArray) {
+            push(face, ...textures[face].map((_) => textureManager.getTextureUV(_)));
+        }
+    }
+}

package/Mesher/Constructors/Voxel/Classes/Cube/PillarCube.constructor.d.ts

@@ -0,0 +1,27 @@
+import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
+import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
+export type PillarCubeVoxelConstructorData = {
+    top: ConstructorTextureData;
+    bottom: ConstructorTextureData;
+    sideMiddle: ConstructorTextureData;
+    sideBottom: ConstructorTextureData;
+    sideTop: ConstructorTextureData;
+    sideFloat: ConstructorTextureData;
+};
+export declare class PillarCubeVoxelConstructor extends VoxelConstructor {
+    id: string;
+    textureData: PillarCubeVoxelConstructorData;
+    textures: [
+        up: number,
+        down: number,
+        sideMiddle: number,
+        sideDown: number,
+        sideUp: number,
+        sideFloat: number
+    ];
+    constructor(id: string, textureData: PillarCubeVoxelConstructorData);
+    process(tool: VoxelMesherDataTool): void;
+    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+}

package/Mesher/Constructors/Voxel/Classes/Cube/PillarCube.constructor.js

@@ -0,0 +1,75 @@
+import { CubeVoxelShape } from "../../../../Shapes/default/Cube/Cube.voxel.shape.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { VoxelFaces } from "../../../../../Math";
+export class PillarCubeVoxelConstructor extends VoxelConstructor {
+    id;
+    textureData;
+    textures;
+    constructor(id, textureData) {
+        super();
+        this.id = id;
+        this.textureData = textureData;
+    }
+    process(tool) {
+        const upCheck = tool.nVoxel.loadInAt(tool.voxel.x, tool.voxel.y + 1, tool.voxel.z) &&
+            tool.voxel.isSameVoxel(tool.nVoxel);
+        const downCheck = tool.nVoxel.loadInAt(tool.voxel.x, tool.voxel.y - 1, tool.voxel.z) &&
+            tool.voxel.isSameVoxel(tool.nVoxel);
+        let side = -1;
+        determineText: if (side) {
+            if (upCheck && downCheck) {
+                side = this.textures[2];
+                break determineText;
+            }
+            if (upCheck && !downCheck) {
+                side = this.textures[3];
+                break determineText;
+            }
+            if (!upCheck && downCheck) {
+                side = this.textures[4];
+                break determineText;
+            }
+            if (!upCheck && !downCheck) {
+                side = this.textures[5];
+                break determineText;
+            }
+            side = 0;
+        }
+        tool.getOverlayTextures().setAll(0);
+        if (tool.isFaceExposed(VoxelFaces.Up)) {
+            tool.setTexture(this.textures[0]).calculateLight(VoxelFaces.Up);
+            CubeVoxelShape.add.up();
+        }
+        if (tool.isFaceExposed(VoxelFaces.Down)) {
+            tool.setTexture(this.textures[1]).calculateLight(VoxelFaces.Down);
+            CubeVoxelShape.add.down();
+        }
+        if (tool.isFaceExposed(VoxelFaces.East)) {
+            tool.setTexture(side).calculateLight(VoxelFaces.East);
+            CubeVoxelShape.add.east();
+        }
+        if (tool.isFaceExposed(VoxelFaces.West)) {
+            tool.setTexture(side).calculateLight(VoxelFaces.West);
+            CubeVoxelShape.add.west();
+        }
+        if (tool.isFaceExposed(VoxelFaces.South)) {
+            tool.setTexture(side).calculateLight(VoxelFaces.South);
+            CubeVoxelShape.add.south();
+        }
+        if (tool.isFaceExposed(VoxelFaces.North)) {
+            tool.setTexture(side).calculateLight(VoxelFaces.North);
+            CubeVoxelShape.add.north();
+        }
+    }
+    onTexturesRegistered(textureManager) {
+        this.textures = [
+            textureManager.getTextureUV(this.textureData.top),
+            textureManager.getTextureUV(this.textureData.bottom),
+            textureManager.getTextureUV(this.textureData.sideMiddle),
+            textureManager.getTextureUV(this.textureData.sideBottom),
+            textureManager.getTextureUV(this.textureData.sideTop),
+            textureManager.getTextureUV(this.textureData.sideFloat),
+        ];
+        this.textureData = null;
+    }
+}

package/Mesher/Constructors/Voxel/Classes/Cube/SimpleCube.constructor.d.ts

@@ -0,0 +1,13 @@
+import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
+import { DirectionNames } from "../../../../../Types";
+import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
+export declare class SimpleCubeVoxelConstructor extends VoxelConstructor {
+    id: string;
+    textureData: ConstructorTextureData | Record<DirectionNames, ConstructorTextureData>;
+    textures: number[];
+    constructor(id: string, textureData: ConstructorTextureData | Record<DirectionNames, ConstructorTextureData>);
+    process(tool: VoxelMesherDataTool): void;
+    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+}

package/Mesher/Constructors/Voxel/Classes/Cube/SimpleCube.constructor.js

@@ -0,0 +1,56 @@
+import { CubeVoxelShape } from "../../../../Shapes/default/Cube/Cube.voxel.shape.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { VoxelFaces } from "../../../../../Math/index.js";
+export class SimpleCubeVoxelConstructor extends VoxelConstructor {
+    id;
+    textureData;
+    textures = [];
+    constructor(id, textureData) {
+        super();
+        this.id = id;
+        this.textureData = textureData;
+    }
+    process(tool) {
+        tool.getOverlayTextures().setAll(0);
+        if (tool.isFaceExposed(VoxelFaces.Up)) {
+            tool.setTexture(this.textures[0]).calculateLight(VoxelFaces.Up);
+            CubeVoxelShape.add.up();
+        }
+        if (tool.isFaceExposed(VoxelFaces.Down)) {
+            tool.setTexture(this.textures[1]).calculateLight(VoxelFaces.Down);
+            CubeVoxelShape.add.down();
+        }
+        if (tool.isFaceExposed(VoxelFaces.East)) {
+            tool.setTexture(this.textures[2]).calculateLight(VoxelFaces.East);
+            CubeVoxelShape.add.east();
+        }
+        if (tool.isFaceExposed(VoxelFaces.West)) {
+            tool.setTexture(this.textures[3]).calculateLight(VoxelFaces.West);
+            CubeVoxelShape.add.west();
+        }
+        if (tool.isFaceExposed(VoxelFaces.South)) {
+            tool.setTexture(this.textures[4]).calculateLight(VoxelFaces.South);
+            CubeVoxelShape.add.south();
+        }
+        if (tool.isFaceExposed(VoxelFaces.North)) {
+            tool.setTexture(this.textures[5]).calculateLight(VoxelFaces.North);
+            CubeVoxelShape.add.north();
+        }
+    }
+    onTexturesRegistered(textureManager) {
+        const textures = this.textureData;
+        if (Array.isArray(textures)) {
+            let i = 6;
+            while (i--) {
+                this.textures.push(textureManager.getTextureUV(textures));
+            }
+            return;
+        }
+        this.textures.push(textureManager.getTextureUV(textures.up));
+        this.textures.push(textureManager.getTextureUV(textures.down));
+        this.textures.push(textureManager.getTextureUV(textures.east));
+        this.textures.push(textureManager.getTextureUV(textures.west));
+        this.textures.push(textureManager.getTextureUV(textures.south));
+        this.textures.push(textureManager.getTextureUV(textures.north));
+    }
+}

package/Mesher/Constructors/Voxel/Classes/HalfCube/ModHalfCube.constructor.d.ts

@@ -0,0 +1,13 @@
+import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
+import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
+import { VoxelFaces } from "../../../../../Math/index.js";
+export declare class ModHalfCubeVoxelConstructor extends VoxelConstructor {
+    id: string;
+    textureData: ConstructorTextureData[];
+    textures: Record<VoxelFaces, number[]>;
+    constructor(id: string, textureData: ConstructorTextureData[]);
+    process(tool: VoxelMesherDataTool): void;
+    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+}

package/Mesher/Constructors/Voxel/Classes/HalfCube/ModHalfCube.constructor.js

@@ -0,0 +1,80 @@
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { VoxelFaces, VoxelFacesArray } from "../../../../../Math/index.js";
+import { HalfCubeStates, HalfCubeVoxelShape, } from "../../../../Shapes/default/Cube/HalfCube.voxel.shape.js";
+import { LightGradient } from "../../../../Calc/Light/LightGradient.js";
+export class ModHalfCubeVoxelConstructor extends VoxelConstructor {
+    id;
+    textureData;
+    textures = {
+        [VoxelFaces.Up]: [],
+        [VoxelFaces.Down]: [],
+        [VoxelFaces.North]: [],
+        [VoxelFaces.South]: [],
+        [VoxelFaces.East]: [],
+        [VoxelFaces.West]: [],
+    };
+    constructor(id, textureData) {
+        super();
+        this.id = id;
+        this.textureData = textureData;
+    }
+    process(tool) {
+        HalfCubeVoxelShape.start();
+        tool.getOverlayTextures().setAll(0);
+        const modState = tool.voxel.getMod();
+        const shapeState = tool.voxel.getShapeState();
+        if (tool.isFaceExposed(VoxelFaces.Up)) {
+            if (shapeState == HalfCubeStates.Down)
+                LightGradient.aoOffset.y = -1;
+            tool
+                .setTexture(this.textures[VoxelFaces.Up][modState])
+                .calculateLight(VoxelFaces.Up);
+            HalfCubeVoxelShape.add.up();
+            LightGradient.aoOffset.y = 0;
+        }
+        if (tool.isFaceExposed(VoxelFaces.Down)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.Down][modState])
+                .calculateLight(VoxelFaces.Down);
+            HalfCubeVoxelShape.add.down();
+        }
+        if (tool.isFaceExposed(VoxelFaces.East)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.East][modState])
+                .calculateLight(VoxelFaces.East);
+            HalfCubeVoxelShape.add.east();
+        }
+        if (tool.isFaceExposed(VoxelFaces.West)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.West][modState])
+                .calculateLight(VoxelFaces.West);
+            HalfCubeVoxelShape.add.west();
+        }
+        if (tool.isFaceExposed(VoxelFaces.South)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.South][modState])
+                .calculateLight(VoxelFaces.South);
+            HalfCubeVoxelShape.add.south();
+        }
+        if (tool.isFaceExposed(VoxelFaces.North)) {
+            tool
+                .setTexture(this.textures[VoxelFaces.North][modState])
+                .calculateLight(VoxelFaces.North);
+            HalfCubeVoxelShape.add.north();
+        }
+    }
+    onTexturesRegistered(textureManager) {
+        const textures = this.textureData;
+        const push = (direction, ...textureIndex) => {
+            this.textures[direction].push(...textureIndex);
+        };
+        if (Array.isArray(textures)) {
+            for (const texture of textures) {
+                for (const face of VoxelFacesArray) {
+                    push(face, textureManager.getTextureUV(texture));
+                }
+            }
+            return;
+        }
+    }
+}

package/Mesher/Constructors/Voxel/Classes/HalfCube/SimpleHalfCube.constructor.d.ts

@@ -0,0 +1,16 @@
+import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
+import { VoxelConstructor } from "../VoxelConstructor.js";
+import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
+import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
+export type SimpleHalfCubeVoxelConstructorData = ConstructorTextureData | {
+    sides: ConstructorTextureData;
+    downAndUp: ConstructorTextureData;
+};
+export declare class SimpleHalfCubeVoxelConstructor extends VoxelConstructor {
+    id: string;
+    textureData: SimpleHalfCubeVoxelConstructorData;
+    textures: number[];
+    constructor(id: string, textureData: SimpleHalfCubeVoxelConstructorData);
+    process(tool: VoxelMesherDataTool): void;
+    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+}