@divinevoxel/vlox 0.0.76 → 0.0.77

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

@@ -0,0 +1,205 @@
+import { TextureProcedure, } from "../TextureProcedure";
+import { VoxelFaceDirections, 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 CheckSets = {
+    [VoxelFaces.Up]: {
+        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]],
+    },
+    [VoxelFaces.Down]: {
+        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]],
+    },
+    [VoxelFaces.North]: {
+        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]],
+    },
+    [VoxelFaces.South]: {
+        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]],
+    },
+    [VoxelFaces.East]: {
+        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]],
+    },
+    [VoxelFaces.West]: {
+        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 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];
+};
+export class OutlinedTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        const set = CheckSets[closestFace];
+        const normal = VoxelFaceDirections[closestFace];
+        const isTopOrBottom = closestFace === VoxelFaces.Up || closestFace === VoxelFaces.Down;
+        // For top/bottom faces, use north/south/east/west sets.
+        // For side faces (north/south/east/west), use top/bottom/right/left sets.
+        const dirNorth = isTopOrBottom ? "north" : "top";
+        const dirSouth = isTopOrBottom ? "south" : "bottom";
+        const dirEast = isTopOrBottom ? "east" : "right";
+        const dirWest = isTopOrBottom ? "west" : "left";
+        const x = generateCheck(dirNorth, builder, normal, set.north);
+        if (x)
+            ref.x = data.textureRecrod[x];
+        const y = generateCheck(dirSouth, builder, normal, set.south);
+        if (y)
+            ref.y = data.textureRecrod[y];
+        const z = generateCheck(dirEast, builder, normal, set.east);
+        if (z)
+            ref.z = data.textureRecrod[z];
+        const w = generateCheck(dirWest, builder, normal, set.west);
+        if (w)
+            ref.w = data.textureRecrod[w];
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) { }
+}

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.d.ts

@@ -0,0 +1,28 @@
+import { Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/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.
+ */
+export interface PillarTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "pillar";
+    texture: TextureId | number;
+    textureRecrod: {
+        sideConnectedTex: TextureId | number;
+        sideDisconnectedTex: TextureId | number;
+        sideUpTex: TextureId | number;
+        sideDownTex: TextureId | number;
+        upTex: TextureId | number;
+        downTex: TextureId | number;
+    };
+    direction: "up-down" | "north-south" | "east-west";
+}
+export declare class PillarTextureProcedure extends TextureProcedure<PillarTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.js

@@ -0,0 +1,109 @@
+import { TextureProcedure, } from "../TextureProcedure";
+import { VoxelFaces } from "../../../../../Math";
+export class PillarTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        if (data.direction == "up-down") {
+            if (closestFace == VoxelFaces.Up)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.Down)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const topVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y + 1, builder.position.z);
+            const topSame = topVoxel ? builder.voxel.isSameVoxel(topVoxel) : false;
+            const bottomVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y - 1, builder.position.z);
+            const bottomSame = bottomVoxel
+                ? builder.voxel.isSameVoxel(bottomVoxel)
+                : false;
+            if (topSame && !bottomSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!topSame && bottomSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (topSame && bottomSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.North ||
+                closestFace == VoxelFaces.South ||
+                closestFace == VoxelFaces.East ||
+                closestFace == VoxelFaces.West)
+                return sideTexture;
+        }
+        if (data.direction == "north-south") {
+            if (closestFace == VoxelFaces.North)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.South)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const northVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z + 1);
+            const northSame = northVoxel
+                ? builder.voxel.isSameVoxel(northVoxel)
+                : false;
+            const southVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z - 1);
+            const southSame = southVoxel
+                ? builder.voxel.isSameVoxel(southVoxel)
+                : false;
+            if (northSame && !southSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!northSame && southSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (northSame && southSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.Up ||
+                closestFace == VoxelFaces.Down ||
+                closestFace == VoxelFaces.East ||
+                closestFace == VoxelFaces.West)
+                return sideTexture;
+        }
+        if (data.direction == "east-west") {
+            if (closestFace == VoxelFaces.East)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.West)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const eastVoxel = builder.nVoxel.getVoxel(builder.position.x + 1, builder.position.y, builder.position.z);
+            const northSame = eastVoxel
+                ? builder.voxel.isSameVoxel(eastVoxel)
+                : false;
+            const westVoxel = builder.nVoxel.getVoxel(builder.position.x - 1, builder.position.y, builder.position.z);
+            const westSame = westVoxel ? builder.voxel.isSameVoxel(westVoxel) : false;
+            if (northSame && !westSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!northSame && westSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (northSame && westSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.Up ||
+                closestFace == VoxelFaces.Down ||
+                closestFace == VoxelFaces.North ||
+                closestFace == VoxelFaces.South)
+                return sideTexture;
+        }
+        throw new Error(`Invalid direction for pillar box texture procedure | ${data.direction}`);
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) {
+        if ((data.direction == "north-south" &&
+            (closestFace == VoxelFaces.East || closestFace == VoxelFaces.West)) ||
+            (data.direction == "east-west" &&
+                (closestFace == VoxelFaces.North ||
+                    closestFace == VoxelFaces.South ||
+                    closestFace == VoxelFaces.Up ||
+                    closestFace == VoxelFaces.Down))) {
+            for (const v of primitive.uvs.vertices) {
+                const oldX = v.x;
+                const oldY = v.y;
+                v.x = 1 - oldY;
+                v.y = oldX;
+            }
+        }
+    }
+}

package/Mesher/{Models → Voxels/Models}/Procedures/TextureProcedure.d.ts

@@ -1,8 +1,8 @@
 import { Vector4Like } from "@amodx/math";
-import { Quad, Triangle } from "../../Geomtry";
+import { Quad, Triangle } from "../../../Geomtry";
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
-import { VoxelFaces } from "../../../Math";
-import { TextureId } from "../../../Textures";
+import { VoxelFaces } from "../../../../Math";
+import { TextureId } from "../../../../Textures";
 export interface BaseVoxelGeomtryTextureProcedureData {
     type: string;
     texture?: TextureId | number;

package/Mesher/{Models → Voxels/Models}/Procedures/TextureProcedureRegister.js

@@ -1,5 +1,6 @@
 import { ConsistentRotationTextureProcedure } from "./Default/ConsistentRotationTextureProcedure";
 import { OutlinedTextureProcedure } from "./Default/OutlinedTextureProcedure";
+import { PillarTextureProcedure } from "./Default/PillarTextureProcedure";
 export class TextureProcedureRegister {
     static procedures = new Map();
     static register(id, procedure) {
@@ -14,3 +15,4 @@ export class TextureProcedureRegister {
 }
 TextureProcedureRegister.register("consistent-rotation", new ConsistentRotationTextureProcedure());
 TextureProcedureRegister.register("outlined", new OutlinedTextureProcedure());
+TextureProcedureRegister.register("pillar", new PillarTextureProcedure());

package/Mesher/{Models → Voxels/Models}/VoxelConstructor.d.ts

@@ -1,9 +1,9 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
-import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
+import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
     builder: VoxelModelBuilder;

package/Mesher/{Models → Voxels/Models}/VoxelConstructor.js

@@ -1,8 +1,8 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
     id;
     builder;

package/Mesher/{Models → Voxels/Models}/VoxelGeometryBuilderCacheSpace.d.ts

@@ -1,6 +1,6 @@
-import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;

package/Mesher/{Models → Voxels/Models}/VoxelGeometryBuilderCacheSpace.js

@@ -1,6 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
+import { GetYXZOrderArrayIndex } from "../../../Math/Indexing";
 export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;

package/Mesher/{Models → Voxels/Models}/VoxelModelBuilder.d.ts

@@ -1,11 +1,11 @@
-import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
-import { VoxelFaces } from "../../Math";
-import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { VoxelMesh } from "../Geomtry/VoxelMesh";
+import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { VoxelFaces } from "../../../Math";
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
 import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface.js";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface.js";
 import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     textureIndex: number;
@@ -26,7 +26,7 @@ export declare class VoxelModelBuilder {
     position: Vector3Like;
     /**The current local origin  */
     origin: Vector3Like;
-    mesh: VoxelMesh;
+    mesh: ProtoMesh;
     bvhTool: VoxelMeshBVHBuilder | null;
     vars: VoxelVars;
     dataCalculated: Record<VoxelFaces, boolean>;

package/Mesher/{Models → Voxels/Models}/VoxelModelBuilder.js

@@ -1,11 +1,12 @@
 //tools
 //data
-import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
-import { VoxelFaces, VoxelFacesArray } from "../../Math";
-import { QuadVerticies } from "../Geomtry/Geometry.types";
+import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { VoxelFaces, VoxelFacesArray } from "../../../Math";
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
 import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
-import { VoxelMesh } from "../Geomtry/VoxelMesh";
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
 class VoxelVars {
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();
@@ -31,7 +32,7 @@ export class VoxelModelBuilder {
     position = Vector3Like.Create();
     /**The current local origin  */
     origin = Vector3Like.Create();
-    mesh = new VoxelMesh();
+    mesh = new ProtoMesh(VoxelMeshVertexStructCursor.VertexFloatSize);
     bvhTool = null;
     vars = new VoxelVars();
     dataCalculated;

package/Mesher/{Models → Voxels/Models}/VoxelModelConstructorRegister.d.ts

@@ -1,10 +1,10 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
+import { StringPalette } from "../../../Util/StringPalette";
+import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { AOOcclusionFaceIndex } from "../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndex } from "../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
+import { AOOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
     static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];

package/Mesher/{Models → Voxels/Models}/VoxelModelConstructorRegister.js

@@ -1,6 +1,6 @@
-import { StringPalette } from "../../Util/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];

package/Mesher/{Models → Voxels/Models}/VoxelModelEffect.d.ts

@@ -1,5 +1,5 @@
 import { VoxelConstructor } from "./VoxelConstructor";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 export declare class VoxelModelEffect {
     model: VoxelConstructor;

package/Mesher/{Models → Voxels/Models}/VoxelModelEffect.js

@@ -1,4 +1,4 @@
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 export class VoxelModelEffect {
     model;
     effects = [];

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -1,5 +1,5 @@
 import { SectionMesh } from "./SectionMesh";
-import { CompactedSectionVoxelMesh } from "../../Mesher/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../../Mesher/Voxels/Geomtry/CompactedSectionVoxelMesh";
 export declare abstract class DVESectionMeshes {
     abstract updateVertexData(section: SectionMesh, data: CompactedSectionVoxelMesh): SectionMesh;
     abstract returnMesh(mesh: any): void;

package/Renderer/MeshManager.js

@@ -1,5 +1,5 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { CompactedSectionVoxelMesh } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../Mesher/Voxels/Geomtry/CompactedSectionVoxelMesh";
 const added = new Set();
 const compacted = new CompactedSectionVoxelMesh();
 const location = [0, 0, 0, 0];

package/Settings/EngineSettings.types.d.ts

@@ -13,8 +13,9 @@ export interface RenderSettingsData {
 export declare class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
-    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
+    /**Renderer will not dispose of buffers to keep them renderering. */
     cpuBound: boolean;
+    bufferMode: "single" | "multi";
 }
 export interface UpdatingSettings {
 }

package/Settings/EngineSettings.types.js

@@ -9,8 +9,10 @@ export class MesherSettingsData {
 export class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
-    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
+    /**Renderer will not dispose of buffers to keep them renderering. */
     cpuBound = false;
+    /* Single buffer mode will store vertex and indicies in single big buffer. While multi will store a buffer for each section mesh.*/
+    bufferMode = "multi";
 }
 export class UpdatingSettings {
     /**Sector sections are marked as dirty so they can be processed later. */

package/Tasks/Paint/Common.js

@@ -61,7 +61,7 @@ export const checkLightUpdate = (x, y, z, tasks) => {
     let needSunUpdate = false;
     let needRGBRemove = false;
     let needRGBUpdate = false;
-    const voxel = tasks.nDataCursor.getVoxel(x, y, z);
+    let voxel = tasks.nDataCursor.getVoxel(x, y, z);
     const lightValue = voxel.getLight();
     const sunValue = lightData.getS(lightValue);
     if (sunValue == 15) {
@@ -109,7 +109,7 @@ export const checkLightUpdate = (x, y, z, tasks) => {
         }
         if (hasRGBLight) {
             const nRedValue = lightData.getR(nLight);
-            if (nRedValue > lowestRedValue) {
+            if (nRedValue < lowestRedValue) {
                 lowestRedValue = nRedValue;
             }
             if (nRedValue > redValue) {
@@ -123,16 +123,16 @@ export const checkLightUpdate = (x, y, z, tasks) => {
                 foundHigherGreen = true;
             }
             const nBlueValue = lightData.getB(nLight);
-            if (nBlueValue > lowestBlueValue) {
+            if (nBlueValue < lowestBlueValue) {
                 lowestBlueValue = nBlueValue;
             }
-            if (nBlueValue < blueValue) {
+            if (nBlueValue > blueValue) {
                 foundHigherBlue = true;
             }
         }
     }
     if (hasSunLight) {
-        //sun
+        // sun
         if (sunValue != 15 && sunValue != 0 && !foundHigherSun) {
             needSunRemove = true;
         }
@@ -141,15 +141,16 @@ export const checkLightUpdate = (x, y, z, tasks) => {
             needSunUpdate = true;
         }
     }
-    if (hasRGBLight) {
-        //red
+    voxel = tasks.nDataCursor.getVoxel(x, y, z);
+    if (hasRGBLight && !voxel.isLightSource()) {
+        // red
         if (redValue != 15 && !foundHigherRed) {
             needRGBRemove = true;
         }
         if ((foundHigherRed || redValue == 15) && lowestRedValue < redValue - 1) {
             needRGBUpdate = true;
         }
-        //green
+        // green
         if (greenValue != 15 && !foundHigherGreen) {
             needRGBRemove = true;
         }
@@ -157,7 +158,7 @@ export const checkLightUpdate = (x, y, z, tasks) => {
             lowestGreenValue < greenValue - 1) {
             needRGBUpdate = true;
         }
-        //blue
+        // blue
         if (blueValue != 15 && !foundHigherBlue) {
             needRGBRemove = true;
         }
@@ -166,6 +167,10 @@ export const checkLightUpdate = (x, y, z, tasks) => {
             needRGBUpdate = true;
         }
     }
+    else if (voxel.isLightSource()) {
+        needRGBUpdate = true;
+        needRGBRemove = false;
+    }
     if (needSunRemove) {
         tasks.sun.remove.push(x, y, z);
     }

package/Tasks/Paint/Erase/EraseVoxelSelection.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types";
+import { Vec3Array } from "@amodx/math";
+import { IVoxelSelectionData } from "../../../Templates/Selection/VoxelSelection";
+export default function EraseVoxelSelection(dimension: number, [ox, oy, oz]: Vec3Array, selectionData: IVoxelSelectionData<any>, updateData: VoxelUpdateData): void;