@divinevoxel/vlox 0.0.75 → 0.0.77

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/EraseVoxel.js

@@ -17,7 +17,7 @@ export function EraseVoxel(location, updateData) {
     voxel.secondary[voxel._index] = 0;
     voxel.light[voxel._index] = 0;
     voxel.updateVoxel(1);
-    updateArea(tasks, x, y, z, x, y, z);
+    updateArea(tasks, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doPower) {
         if (foundPower > -1) {

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;

package/Tasks/Paint/Erase/EraseVoxelSelection.js

@@ -0,0 +1,33 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
+const tasks = new VoxelUpdateTask();
+export default function EraseVoxelSelection(dimension, [ox, oy, oz], selectionData, updateData) {
+    const selection = VoxelTemplateRegister.createSelection(selectionData);
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const { x: sx, y: sy, z: sz } = selection.bounds.size;
+    for (let x = 0; x < sx; x++) {
+        for (let y = 0; y < sy; y++) {
+            for (let z = 0; z < sz; z++) {
+                const tx = ox + x;
+                const ty = oy + y;
+                const tz = oz + z;
+                if (!selection.isSelected(tx, ty, tz))
+                    continue;
+                if (!canUpdate(tx, ty, tz, updateData))
+                    continue;
+                if (!tasks.sDataCursor.inBounds(tx, ty, tz))
+                    continue;
+                const voxel = tasks.sDataCursor.getVoxel(tx, ty, tz);
+                if (!voxel || voxel.isAir())
+                    continue;
+                voxel.ids[voxel._index] = 0;
+                voxel.level[voxel._index] = 0;
+                voxel.secondary[voxel._index] = 0;
+                voxel.light[voxel._index] = 0;
+                voxel.updateVoxel(1);
+            }
+        }
+    }
+    updateArea(tasks, ox, oy, oz, ox + sx, oy + sy, oz + sz);
+}

package/Tasks/Paint/Erase/EraseVoxelTemplate.js

@@ -1,8 +1,7 @@
 import { VoxelUpdateTask } from "../../VoxelUpdateTask";
 import { canUpdate, updateArea } from "../Common";
-import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
 const tasks = new VoxelUpdateTask();
-const raw = [0, 0, 0, 0];
 export default function EraseVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {
     const voxelTemplate = VoxelTemplateRegister.create(templateData);
     tasks.setOriginAt([dimension, ox, oy, oz]);

package/Tasks/Paint/Paint/PaintVoxelTemplate.js

@@ -1,6 +1,6 @@
 import { VoxelUpdateTask } from "../../VoxelUpdateTask";
 import { canUpdate, updateArea } from "../Common";
-import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
 const tasks = new VoxelUpdateTask();
 const raw = [0, 0, 0, 0];
 export default function PaintVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -35,7 +35,7 @@ export function RGBRemove(tasks) {
     const remove = tasks.rgb.remove;
     const update = tasks.rgb.update;
     const removeMap = tasks.rgb.removeMap;
-    const updateMap = tasks.sun.updateMap;
+    const updateMap = tasks.rgb.updateMap;
     while (remove.length) {
         const x = remove.shift();
         const y = remove.shift();

package/Tasks/Tasks.types.d.ts

@@ -5,6 +5,7 @@ import type EraseVoxelTemplate from "./Paint/Erase/EraseVoxelTemplate.js";
 import type EraseVoxelPath from "./Paint/Erase/EraseVoxelPath.js";
 import { PaintVoxel } from "./Paint/Paint/PaintVoxel.js";
 import PaintVoxelTemplate from "./Paint/Paint/PaintVoxelTemplate.js";
+import EraseVoxelSelection from "./Paint/Erase/EraseVoxelSelection.js";
 export type VoxelUpdateData = {
     /**An array of allowed areas to update in. If not set will be ignored.*/
     includedAreas?: [min: Vec3Array, max: Vec3Array][];
@@ -23,6 +24,7 @@ export type PaintVoxelPathTask = [
 ];
 export type EraseVoxelTask = Parameters<typeof EraseVoxel>;
 export type EraseVoxelTemplateTask = Parameters<typeof EraseVoxelTemplate>;
+export type EraseVoxelSelectionTask = Parameters<typeof EraseVoxelSelection>;
 export type EraseVoxelPathTask = Parameters<typeof EraseVoxelPath>;
 export type WorldLockTasks = [
     dimension: number,

package/Tasks/TasksIds.d.ts

@@ -11,5 +11,6 @@ export declare enum TasksIds {
     PaintVoxelPath = "PaintVoxelPath",
     EraseVoxel = "EraseVoxel",
     EraseVoxelTemplate = "EraseVoxelTemplate",
+    EraseVoxelSelection = "EraseVoxelSelection",
     EraseVoxelPath = "EraseVoxelPath"
 }

package/Tasks/TasksIds.js

@@ -12,5 +12,6 @@ export var TasksIds;
     TasksIds["PaintVoxelPath"] = "PaintVoxelPath";
     TasksIds["EraseVoxel"] = "EraseVoxel";
     TasksIds["EraseVoxelTemplate"] = "EraseVoxelTemplate";
+    TasksIds["EraseVoxelSelection"] = "EraseVoxelSelection";
     TasksIds["EraseVoxelPath"] = "EraseVoxelPath";
 })(TasksIds || (TasksIds = {}));

package/Tasks/WorldGeneration/InitTasks.js

@@ -6,5 +6,7 @@ import { WorldGenRegister } from "./WorldGenRegister";
 export default function (props) {
     WorldGenRegister._worldThread = props.worldThread;
     Threads.registerBinaryTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "generate", resolve)));
-    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "decorate", resolve)));
+    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => {
+        WorldGeneration.generate(getLocationData(data), "decorate", resolve);
+    }));
 }

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -1,4 +1,4 @@
-import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { ArchivedVoxelTemplateData } from "./ArchivedVoxelTemplate.types";
 import type { RawVoxelData } from "../../Voxels/Types/Voxel.types";
 import { NumberPalette } from "../../Util/NumberPalette";
@@ -11,9 +11,7 @@ type TemplateCursor = {
     raw: RawVoxelData;
 };
 export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
-    private _data;
     index: Flat3DIndex;
-    position: Vector3Like;
     bounds: BoundingBox;
     ids: BinaryBuffer;
     level: BinaryBuffer;
@@ -21,8 +19,9 @@ export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
     voxelPalette: VoxelPaletteArchiveReader;
     levelPalette: NumberPalette;
     secondaryPalette: NumberPalette;
-    constructor(_data: ArchivedVoxelTemplateData);
-    setPosition(x: number, y: number, z: number): void;
+    private data;
+    constructor(data: ArchivedVoxelTemplateData);
+    inBounds(x: number, y: number, z: number): boolean;
     isAir(index: number): boolean;
     isIncluded(index: number): boolean;
     getIndex(x: number, y: number, z: number): number;
@@ -31,7 +30,9 @@ export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
     getLight(index: number): number;
     getSecondary(index: number): number;
     traverse(curosr?: TemplateCursor): Generator<TemplateCursor>;
+    clone(): ArchivedVoxelTemplate;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     toJSON(): ArchivedVoxelTemplateData;
+    fromJSON(data: ArchivedVoxelTemplateData): void;
 }
 export {};

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -1,14 +1,13 @@
-import { Flat3DIndex } from "@amodx/math";
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { NumberPalette } from "../../Util/NumberPalette";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
 import { BinaryBuffer, BinaryBufferFormat, } from "../../Util/BinaryBuffer/index";
 import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class ArchivedVoxelTemplate {
-    _data;
     index = Flat3DIndex.GetXZYOrder();
-    position;
     bounds;
     ids;
     level;
@@ -16,52 +15,15 @@ export class ArchivedVoxelTemplate {
     voxelPalette;
     levelPalette;
     secondaryPalette;
-    constructor(_data) {
-        this._data = _data;
-        this.bounds = new BoundingBox();
-        this.position = { ..._data.position };
-        this.bounds.setMinPositionAndSize(_data.position, _data.bounds);
-        this.index.setBounds(_data.bounds.x, _data.bounds.y, _data.bounds.z);
-        this.voxelPalette = new VoxelPaletteArchiveReader(_data.palettes);
-        if (_data.palettes.level) {
-            this.levelPalette = new NumberPalette(BinaryBuffer.ToTypedArray(_data.palettes.level));
-        }
-        else {
-            this.levelPalette = new NumberPalette([0]);
-        }
-        if (_data.palettes.secondary) {
-            this.secondaryPalette = new NumberPalette(BinaryBuffer.ToTypedArray(_data.palettes.secondary));
-        }
-        else {
-            this.secondaryPalette = new NumberPalette([0]);
-        }
-        const volume = this.index.size;
-        this.ids = _data.buffers.ids
-            ? new BinaryBuffer(_data.buffers.ids)
-            : new BinaryBuffer(BinaryBuffer.Create({
-                format: BinaryBufferFormat.Uint16,
-                byteLength: volume,
-                buffer: 0,
-            }));
-        this.level = _data.buffers.level
-            ? new BinaryBuffer(_data.buffers.level)
-            : new BinaryBuffer(BinaryBuffer.Create({
-                format: BinaryBufferFormat.Uint8,
-                byteLength: volume,
-                buffer: 0,
-            }));
-        this.secondary = _data.buffers.secondary
-            ? new BinaryBuffer(_data.buffers.secondary)
-            : new BinaryBuffer(BinaryBuffer.Create({
-                format: BinaryBufferFormat.Uint16,
-                byteLength: volume,
-                buffer: 0,
-            }));
+    data;
+    constructor(data) {
+        this.fromJSON(data);
     }
-    setPosition(x, y, z) {
-        this.position.x = x;
-        this.position.y = y;
-        this.position.z = z;
+    inBounds(x, y, z) {
+        point.x = x + 0.5;
+        point.y = y + 0.5;
+        point.z = z + 0.5;
+        return this.bounds.intersectsPoint(point);
     }
     isAir(index) {
         return this.getId(index) === 0;
@@ -111,6 +73,10 @@ export class ArchivedVoxelTemplate {
             }
         }
     }
+    clone() {
+        const newTemplate = new ArchivedVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     getRaw(index, rawRef = [0, 0, 0, 0]) {
         rawRef[0] = this.getId(index);
         rawRef[1] = this.getLight(index);
@@ -119,6 +85,47 @@ export class ArchivedVoxelTemplate {
         return rawRef;
     }
     toJSON() {
-        return this._data;
+        return this.data;
+    }
+    fromJSON(data) {
+        this.data = data;
+        this.bounds = new BoundingBox();
+        this.bounds.setSize(data.bounds);
+        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
+        this.voxelPalette = new VoxelPaletteArchiveReader(data.palettes);
+        if (data.palettes.level) {
+            this.levelPalette = new NumberPalette(BinaryBuffer.ToTypedArray(data.palettes.level));
+        }
+        else {
+            this.levelPalette = new NumberPalette([0]);
+        }
+        if (data.palettes.secondary) {
+            this.secondaryPalette = new NumberPalette(BinaryBuffer.ToTypedArray(data.palettes.secondary));
+        }
+        else {
+            this.secondaryPalette = new NumberPalette([0]);
+        }
+        const volume = this.index.size;
+        this.ids = data.buffers.ids
+            ? new BinaryBuffer(data.buffers.ids)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: volume,
+                buffer: 0,
+            }));
+        this.level = data.buffers.level
+            ? new BinaryBuffer(data.buffers.level)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: volume,
+                buffer: 0,
+            }));
+        this.secondary = data.buffers.secondary
+            ? new BinaryBuffer(data.buffers.secondary)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: volume,
+                buffer: 0,
+            }));
     }
 }

package/Templates/Archive/Functions/CreateArchivedTemplate.js

@@ -147,14 +147,16 @@ export default function CreateArchivedTemplate(dataCursor, bounds) {
     const palettes = {
         ...voxelPalette.toJSON(),
     };
-    if (!(levelPalette.size == 1 && levelPalette._palette[0] === 0)) {
+    if (levelPalette.size > 0 &&
+        !(levelPalette.size == 1 && levelPalette._palette[0] === 0)) {
         palettes.level = BinaryBuffer.Create({
             format: BinaryBufferFormat.Uint8,
             byteLength: levelPalette._palette.length,
             buffer: Uint8Array.from(levelPalette._palette).buffer,
         });
     }
-    if (!(secondaryPalette.size == 1 && secondaryPalette._palette[0] === 0)) {
+    if (secondaryPalette.size > 0 &&
+        !(secondaryPalette.size == 1 && secondaryPalette._palette[0] === 0)) {
         palettes.secondary = BinaryBuffer.Create({
             format: BinaryBufferFormat.Uint16,
             byteLength: secondaryPalette._palette.length,
@@ -173,12 +175,10 @@ export default function CreateArchivedTemplate(dataCursor, bounds) {
                 secondary: "YXZ",
             },
         },
-        position: Vector3Like.Create(),
         bounds: Vector3Like.Create(...index.getBounds()),
         palettes,
         buffers,
     };
-    console.log(data);
     const archived = new ArchivedVoxelTemplate(data);
     return archived;
 }

package/Templates/Archive/Functions/ExportArchiedTemplateJSON.js

@@ -35,7 +35,6 @@ export default async function ExportArchiedTemplateJSON(templateData) {
         engineVersion: templateData.engineVersion,
         formatVersion: templateData.formatVersion,
         dataKey: templateData.dataKey,
-        position: templateData.position,
         bounds: templateData.bounds,
         type: templateData.type,
         buffers,

package/Templates/Archive/Functions/ImportArchivedTemplateJSON.js

@@ -27,11 +27,9 @@ export default async function ImportArchivedTemplateJSON(jsonData) {
         formatVersion: jsonData.formatVersion,
         dataKey: jsonData.dataKey,
         type: jsonData.type,
-        position: jsonData.position,
         bounds: jsonData.bounds,
         buffers,
         palettes,
     };
-    console.warn("IMPORT TEMPLATE", data, jsonData);
     return data;
 }

package/Templates/Cursor/TemplateCursor.d.ts

@@ -2,12 +2,17 @@ import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
 import { TemplateProxy } from "./TemplateProxy";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
     _proxy: TemplateProxy | null;
+    private _airCursor;
+    baseLightValue: number;
     private voxel;
+    volumeBounds: BoundingBox;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setTemplate(template: IVoxelTemplate): void;
-    getVoxel(x: number, y: number, z: number): TemplateVoxelCursor | null;
+    getVoxel(x: number, y: number, z: number): TemplateVoxelCursor;
     clone(): DataCursorInterface;
 }

package/Templates/Cursor/TemplateCursor.js

@@ -1,18 +1,31 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
 import { TemplateProxy } from "./TemplateProxy";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const raw = [0, 0, 0, 0];
 export class TemplateCursor {
     _voxelIndex = 0;
     _proxy = null;
+    _airCursor = new VoxelCursor();
+    baseLightValue = 0xf;
     voxel = new TemplateVoxelCursor(this);
+    volumeBounds = new BoundingBox();
+    constructor() { }
     inBounds(x, y, z) {
-        return true;
+        if (!this._proxy)
+            return false;
+        return this._proxy.inBounds(x, y, z);
     }
     setTemplate(template) {
         this._proxy = new TemplateProxy(template);
+        this.volumeBounds.setMinMax(template.bounds.min, template.bounds.max);
     }
     getVoxel(x, y, z) {
-        if (!this._proxy)
-            return null;
+        if (!this._proxy || !this._proxy.inBounds(x, y, z)) {
+            raw[1] = this.baseLightValue;
+            this._airCursor.setRaw(raw);
+            return this._airCursor;
+        }
         this._voxelIndex = this._proxy.template.index.getIndexXYZ(x, y, z);
         this.voxel.loadIn();
         return this.voxel;

package/Templates/Cursor/TemplateProxy.d.ts

@@ -7,4 +7,5 @@ export declare class TemplateProxy {
     secondary: NumberArray;
     light: NumberArray;
     constructor(template: IVoxelTemplate);
+    inBounds(x: number, y: number, z: number): boolean;
 }

package/Templates/Cursor/TemplateProxy.js

@@ -19,4 +19,13 @@ export class TemplateProxy {
             get: (_, index) => this.template.getSecondary(Number(index)),
         });
     }
+    inBounds(x, y, z) {
+        const inBounds = this.template.inBounds(x, y, z);
+        if (!inBounds)
+            return false;
+        const index = this.template.getIndex(x, y, z);
+        if (!this.template.isIncluded(index))
+            return false;
+        return true;
+    }
 }

package/Templates/Cursor/TemplateVoxelCursor.d.ts

@@ -9,5 +9,6 @@ export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     get secondary(): import("../../Util/Util.types").NumberArray;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
+    getLight(): number;
     updateVoxel(mode: 0 | 1): void;
 }

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -25,5 +25,11 @@ export class TemplateVoxelCursor extends VoxelCursorInterface {
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
+    getLight() {
+        const light = super.getLight();
+        if (light <= 0)
+            return this.dataCursor.baseLightValue;
+        return light;
+    }
     updateVoxel(mode) { }
 }

package/Templates/Full/FullVoxelTemplate.d.ts

@@ -1,12 +1,11 @@
-import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { IVoxelTemplate } from "../VoxelTemplates.types";
 import { FullVoxelTemplateData } from "./FullVoxelTemplate.types";
 import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export declare class FullVoxelTemplate implements IVoxelTemplate {
+export declare class FullVoxelTemplate implements IVoxelTemplate<"full"> {
     static CreateNew(bounds: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
     index: Flat3DIndex;
-    position: Vector3Like;
     bounds: BoundingBox;
     ids: Uint16Array;
     level: Uint8Array;
@@ -14,7 +13,7 @@ export declare class FullVoxelTemplate implements IVoxelTemplate {
     secondary: Uint16Array;
     mask?: Uint8Array;
     constructor(data: FullVoxelTemplateData);
-    setPosition(x: number, y: number, z: number): void;
+    inBounds(x: number, y: number, z: number): boolean;
     isAir(index: number): boolean;
     isIncluded(index: number): boolean;
     getIndex(x: number, y: number, z: number): number;
@@ -23,5 +22,7 @@ export declare class FullVoxelTemplate implements IVoxelTemplate {
     getLevel(index: number): number;
     getSecondary(index: number): number;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    clone(): FullVoxelTemplate;
     toJSON(): FullVoxelTemplateData;
+    fromJSON(data: FullVoxelTemplateData): void;
 }