@divinevoxel/vlox 0.0.4 → 0.0.5

package/{Data/Cursor/Interfaces → Voxels/Cursor}/VoxelCursor.interface.d.ts

@@ -1,6 +1,7 @@
-import { VoxelStruct } from "../../Structs/VoxelStruct";
-import { DataTool } from "../../../Tools/Data/DataTool";
-import { RawVoxelData } from "../../../Voxels/Voxel.types";
+import { VoxelLightData } from "./VoxelLightData";
+import { VoxelStruct } from "../Structs/VoxelStruct";
+import { RawVoxelData } from "../Types/Voxel.types";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool";
 interface WritableArrayLike<T> {
     length: number;
     [index: number]: T;
@@ -14,9 +15,12 @@ export declare abstract class VoxelCursorInterface {
     _index: number;
     abstract ids: WritableArrayLike<number>;
     abstract light: WritableArrayLike<number>;
+    abstract level: WritableArrayLike<number>;
     abstract state: WritableArrayLike<number>;
     abstract secondary: WritableArrayLike<number>;
     abstract mod: WritableArrayLike<number>;
+    _lightData: VoxelLightData;
+    _substanceData: SubstanceDataTool;
     process(): void;
     abstract loadIn(): void;
     setSecondary(enable: boolean): this;
@@ -24,7 +28,11 @@ export declare abstract class VoxelCursorInterface {
     getRenderedMaterialStringId(): string;
     getMaterial(): number;
     getMaterialStringId(): string;
+    checkCollisions(): boolean;
+    getCollider(): number;
+    getColliderStringId(): string | null;
     getSubstance(): number;
+    getSubstanceData(): SubstanceDataTool;
     getSubstanceStringId(): string;
     isOpaque(): boolean;
     getMod(): number;
@@ -33,8 +41,8 @@ export declare abstract class VoxelCursorInterface {
     setLevel(level: number): this;
     getLevelState(): number;
     setLevelState(state: number): this;
-    getShapeState(): number;
-    setShapeState(state: number): this;
+    getState(): number;
+    setState(state: number): this;
     hasSecondaryVoxel(): boolean;
     canHaveSecondaryVoxel(): boolean;
     hasRGBLight(): boolean;
@@ -47,14 +55,13 @@ export declare abstract class VoxelCursorInterface {
     isRenderable(): boolean;
     isAir(): boolean;
     setAir(): this;
-    isBarrier(): boolean;
     getId(): number;
     setId(id: number): this;
     setStringId(id: string): this;
     getStringId(): string;
     setName(name: string): void;
     getName(): string;
-    isSameVoxel(voxel: VoxelCursorInterface | DataTool): boolean;
+    isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;
     copyRaw(raw: RawVoxelData): this;
     getRaw(): RawVoxelData;

package/{Data/Cursor/Interfaces → Voxels/Cursor}/VoxelCursor.interface.js

@@ -1,19 +1,23 @@
-import { VoxelStructIds } from "../../../Voxels/Voxel.types";
-import { LightData } from "../../../Voxels/LightData";
-import { VoxelStruct } from "../../Structs/VoxelStruct";
-import { VoxelStateReader } from "../../../Voxels/VoxelStateReader";
-import { VoxelTagStates } from "../../../Voxels/State/VoxelTagStates";
-import { VoxelPalette } from "../../Palettes/VoxelPalette";
-import { SubstancePalette } from "../../Palettes/SubstancePalette";
-import { MaterialPalette } from "../../../Data/Palettes/MaterialPalette";
+import { VoxelStructIds } from "../Types/Voxel.types";
+import { VoxelLightData } from "./VoxelLightData";
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
+import { VoxelStruct } from "../Structs/VoxelStruct";
+import { VoxelStateReader } from "../VoxelStateReader";
+import { VoxelTagStates } from "../State/VoxelTagStates";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { SubstancePalette } from "../Palettes/SubstancePalette";
+import { MaterialPalette } from "../Palettes/MaterialPalette";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool";
 export class VoxelCursorInterface {
     _loadedId = 0;
     id = 0;
     secondaryId = 0;
     __struct;
     __secondary = false;
-    // private _chunk: Chunk;
+    // private _section: Section;
     _index = 0;
+    _lightData = new VoxelLightData();
+    _substanceData = new SubstanceDataTool();
     process() {
         if (!this.__struct)
             this.__struct = VoxelStruct.clone();
@@ -51,9 +55,21 @@ export class VoxelCursorInterface {
     getMaterialStringId() {
         return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.voxelMaterial]);
     }
+    checkCollisions() {
+        return this.__struct[VoxelStructIds.checkCollisions] == 1;
+    }
+    getCollider() {
+        return this.__struct[VoxelStructIds.colliderID];
+    }
+    getColliderStringId() {
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructIds.colliderID, this.__struct[VoxelStructIds.colliderID]);
+    }
     getSubstance() {
         return this.__struct[VoxelStructIds.substance];
     }
+    getSubstanceData() {
+        return this._substanceData.setSubstance(this.getSubstance());
+    }
     getSubstanceStringId() {
         return SubstancePalette.id.stringFromNumber(this.getSubstance());
     }
@@ -68,24 +84,24 @@ export class VoxelCursorInterface {
         return this;
     }
     getLevel() {
-        return VoxelStateReader.getLevel(this.state[this._index]);
+        return VoxelStateReader.getLevel(this.level[this._index]);
     }
     setLevel(level) {
-        this.state[this._index] = VoxelStateReader.setLevel(this.state[this._index], level);
+        this.level[this._index] = VoxelStateReader.setLevel(this.level[this._index], level);
         return this;
     }
     getLevelState() {
-        return VoxelStateReader.getLevelState(this.state[this._index]);
+        return VoxelStateReader.getLevelState(this.level[this._index]);
     }
     setLevelState(state) {
-        this.state[this._index] = VoxelStateReader.setLevelState(this.state[this._index], state);
+        this.level[this._index] = VoxelStateReader.setLevelState(this.level[this._index], state);
         return this;
     }
-    getShapeState() {
-        return VoxelStateReader.getShapeState(this.state[this._index]);
+    getState() {
+        return this.state[this._index];
     }
-    setShapeState(state) {
-        this.state[this._index] = VoxelStateReader.setShapeState(this.state[this._index], state);
+    setState(state) {
+        this.state[this._index] = state;
         return this;
     }
     hasSecondaryVoxel() {
@@ -98,20 +114,17 @@ export class VoxelCursorInterface {
         const light = this.getLight();
         if (light <= 0)
             false;
-        return LightData.hasRGBLight(light);
+        return this._lightData.hasRGBLight(light);
     }
     hasSunLight() {
         const light = this.getLight();
         if (light <= 0)
             false;
-        return LightData.hasSunLight(light);
+        return this._lightData.hasSunLight(light);
     }
     getLight() {
-        const vID = this._loadedId;
-        if (vID == 0)
+        if (this._loadedId == 0)
             return this.light[this._index];
-        if (vID < 2)
-            return -1;
         const lightValue = this.__struct[VoxelStructIds.lightValue];
         if (this.isOpaque()) {
             if (this.isLightSource() && lightValue) {
@@ -122,7 +135,7 @@ export class VoxelCursorInterface {
             }
         }
         if (this.isLightSource() && lightValue) {
-            return LightData.mixLight(this.light[this._index], lightValue);
+            return this._lightData.mixLight(this.light[this._index], lightValue);
         }
         return this.light[this._index];
     }
@@ -131,29 +144,28 @@ export class VoxelCursorInterface {
         return this;
     }
     isLightSource() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return false;
         return VoxelTagStates.isRegistered(this._loadedId, VoxelStructIds.isLightSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getShapeState()) === true
+            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getState()) === true
             : this.__struct[VoxelStructIds.isLightSource] == 1;
     }
     getLightSourceValue() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return 0;
         return this.__struct[VoxelStructIds.lightValue];
     }
     noAO() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return false;
         return this.__struct[VoxelStructIds.noAO] == 1;
     }
     isRenderable() {
-        if (this.id < 2 && this.secondaryId < 2)
-            return false;
-        return true;
+        if (this.id > 0)
+            return true;
+        if (this.canHaveSecondaryVoxel() && this.secondary[this._index] > 0)
+            return true;
+        return false;
     }
     isAir() {
         return 0 == this.ids[this._index];
@@ -162,9 +174,6 @@ export class VoxelCursorInterface {
         this.ids[0] = 0;
         return this;
     }
-    isBarrier() {
-        return 1 == this.ids[this._index];
-    }
     getId() {
         if (this.__secondary) {
             return this.secondaryId;
@@ -200,34 +209,38 @@ export class VoxelCursorInterface {
     copy(cursor) {
         this.ids[this._index] = cursor.ids[cursor._index];
         this.light[this._index] = cursor.light[cursor._index];
+        this.level[this._index] = cursor.level[cursor._index];
         this.state[this._index] = cursor.state[cursor._index];
-        this.secondary[this._index] = cursor.secondary[cursor._index];
         this.mod[this._index] = cursor.mod[cursor._index];
+        this.secondary[this._index] = cursor.secondary[cursor._index];
         return this;
     }
     copyRaw(raw) {
         this.ids[this._index] = raw[0];
         this.light[this._index] = raw[1];
-        this.state[this._index] = raw[2];
-        this.secondary[this._index] = raw[3];
-        this.mod[this._index] = raw[4];
+        this.level[this._index] = raw[2];
+        this.state[this._index] = raw[3];
+        this.secondary[this._index] = raw[4];
+        this.mod[this._index] = raw[5];
         return this;
     }
     getRaw() {
         return [
             this.ids[this._index],
             this.light[this._index],
+            this.level[this._index],
             this.state[this._index],
-            this.secondary[this._index],
             this.mod[this._index],
+            this.secondary[this._index],
         ];
     }
     getRawToRef(raw) {
         raw[0] = this.ids[this._index];
         raw[1] = this.light[this._index];
-        raw[2] = this.state[this._index];
-        raw[3] = this.secondary[this._index];
+        raw[2] = this.level[this._index];
+        raw[3] = this.state[this._index];
         raw[4] = this.mod[this._index];
+        raw[5] = this.secondary[this._index];
         return raw;
     }
 }

package/{Data → Voxels}/Cursor/VoxelCursor.js

@@ -1,5 +1,5 @@
-import { VoxelCursorInterface } from "./Interfaces/VoxelCursor.interface";
-import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
 import { VoxelStateReader } from "../../Voxels/VoxelStateReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
@@ -7,17 +7,16 @@ export class VoxelCursor extends VoxelCursorInterface {
         const secondaryId = (data.secondaryVoxelId !== undefined &&
             VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
             0;
-        let stateData = 0;
+        let levleData = 0;
         if (data.level !== undefined)
-            stateData = VoxelStateReader.setLevel(stateData, data.level);
+            levleData = VoxelStateReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
-            stateData = VoxelStateReader.setLevelState(stateData, data.levelState);
-        if (data.shapeState !== undefined)
-            stateData = VoxelStateReader.setShapeState(stateData, data.shapeState);
-        return [id, light, stateData, secondaryId, data.mod || 0];
+            levleData = VoxelStateReader.setLevelState(levleData, data.levelState);
+        return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
     ids = [0];
     light = [0];
+    level = [0];
     state = [0];
     secondary = [0];
     mod = [0];

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -0,0 +1,45 @@
+type AllLight = [s: number, r: number, g: number, b: number];
+/**# Light Data
+ * ---
+ * Used to decode light color info.
+ */
+export declare class VoxelLightData {
+    _lightValues: AllLight;
+    sumRGB(value: number): number;
+    getS(value: number): number;
+    getR(value: number): number;
+    getG(value: number): number;
+    getB(value: number): number;
+    setS(value: number, sl: number): number;
+    setR(value: number, sl: number): number;
+    setG(value: number, sl: number): number;
+    setB(value: number, sl: number): number;
+    removeS(sl: number): number;
+    hasRGBLight(sl: number): boolean;
+    hasSunLight(sl: number): boolean;
+    mixLight(l1: number, l2: number): number;
+    getRGB(sl: number): number;
+    setRGB(value: number, sl: number): number;
+    decodeLightFromVoxelData(voxelData: number): number;
+    encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
+    /**# Set Light Values
+     * ---
+     * Give an array of light values it will return an encoded light number.
+     * @param values
+     */
+    setLightValues(values: ArrayLike<number>): number;
+    /**# Get Light Values
+     * ---
+     * Given an encoded light number it will return an array of its values.
+     * - 0: Sun Light
+     * - 1: Red Light
+     * - 2: Green Light
+     * - 3: Blue Light
+     * @param value
+     */
+    getLightValues(value: number): AllLight;
+    getLightValuesToRef(value: number, values: AllLight): AllLight;
+    addLightValues(sl: number, sl2: number): number;
+    divideLightValue(sl: number, divisor: number): number;
+}
+export {};

package/Voxels/Cursor/VoxelLightData.js

@@ -0,0 +1,146 @@
+/**# Light Data
+ * ---
+ * Used to decode light color info.
+ */
+export class VoxelLightData {
+    _lightValues = new Uint16Array([0, 0, 0, 0]);
+    sumRGB(value) {
+        return this.getR(value) + this.getG(value) + this.getB(value);
+    }
+    getS(value) {
+        return value & 0xf;
+    }
+    getR(value) {
+        return (value & (0xf << 4)) >> 4;
+    }
+    getG(value) {
+        return (value & (0xf << 8)) >> 8;
+    }
+    getB(value) {
+        return (value & (0xf << 12)) >> 12;
+    }
+    setS(value, sl) {
+        return (sl & ~0xf) | value;
+    }
+    setR(value, sl) {
+        return (sl & ~(0xf << 4)) | (value << 4);
+    }
+    setG(value, sl) {
+        return (sl & ~(0xf << 8)) | (value << 8);
+    }
+    setB(value, sl) {
+        return (sl & ~(0xf << 12)) | (value << 12);
+    }
+    removeS(sl) {
+        return this.setS(0, sl);
+    }
+    hasRGBLight(sl) {
+        if (sl <= 0)
+            return false;
+        if (this.getR(sl) > 0)
+            return true;
+        if (this.getG(sl) > 0)
+            return true;
+        if (this.getB(sl) > 0)
+            return true;
+        return false;
+    }
+    hasSunLight(sl) {
+        if (sl <= 0)
+            return false;
+        if (this.getS(sl) > 0)
+            return true;
+        return false;
+    }
+    mixLight(l1, l2) {
+        const s1 = this.getS(l1);
+        const s2 = this.getS(l2);
+        const s = s1 < s2 ? s2 : s1;
+        const r1 = this.getR(l1);
+        const r2 = this.getR(l2);
+        const r = r1 < r2 ? r2 : r1;
+        const g1 = this.getG(l1);
+        const g2 = this.getG(l2);
+        const g = g1 < g2 ? g2 : g1;
+        const b1 = this.getB(l1);
+        const b2 = this.getB(l2);
+        const b = b1 < b2 ? b2 : b1;
+        let nl = this.setS(s, 0);
+        nl = this.setR(r, nl);
+        nl = this.setG(g, nl);
+        nl = this.setB(b, nl);
+        return nl;
+    }
+    getRGB(sl) {
+        if (sl < 0)
+            return 0;
+        return (sl & 0xfff0) >> 4;
+    }
+    setRGB(value, sl) {
+        if (sl < 0)
+            return 0;
+        return (sl & ~0xfff0) | (value << 4);
+    }
+    decodeLightFromVoxelData(voxelData) {
+        return (voxelData & (0xffff << 0)) >> 0;
+    }
+    encodeLightIntoVoxelData(voxelData, encodedLight) {
+        return (voxelData & ~(0xffff << 0)) | (encodedLight << 0);
+    }
+    /**# Set Light Values
+     * ---
+     * Give an array of light values it will return an encoded light number.
+     * @param values
+     */
+    setLightValues(values) {
+        let value = this.setS(values[0], 0);
+        value = this.setR(values[1], value);
+        value = this.setG(values[2], value);
+        return this.setB(values[3], value);
+    }
+    /**# Get Light Values
+     * ---
+     * Given an encoded light number it will return an array of its values.
+     * - 0: Sun Light
+     * - 1: Red Light
+     * - 2: Green Light
+     * - 3: Blue Light
+     * @param value
+     */
+    getLightValues(value) {
+        this._lightValues[0] = this.getS(value);
+        this._lightValues[1] = this.getR(value);
+        this._lightValues[2] = this.getG(value);
+        this._lightValues[3] = this.getB(value);
+        return this._lightValues;
+    }
+    getLightValuesToRef(value, values) {
+        values[0] = this.getS(value);
+        values[1] = this.getR(value);
+        values[2] = this.getG(value);
+        values[3] = this.getB(value);
+        return values;
+    }
+    addLightValues(sl, sl2) {
+        this._lightValues[0] = this.getS(sl) + this.getS(sl2);
+        this._lightValues[1] = this.getR(sl) + this.getR(sl2);
+        this._lightValues[2] = this.getG(sl) + this.getG(sl2);
+        this._lightValues[3] = this.getB(sl) + this.getB(sl2);
+        if (this._lightValues[0] > 15)
+            this._lightValues[0] = 15;
+        if (this._lightValues[1] > 15)
+            this._lightValues[1] = 15;
+        if (this._lightValues[2] > 15)
+            this._lightValues[2] = 15;
+        if (this._lightValues[3] > 15)
+            this._lightValues[3] = 15;
+        return this.setLightValues(this._lightValues);
+    }
+    divideLightValue(sl, divisor) {
+        this._lightValues[0] = Math.ceil(this.getS(sl) / divisor);
+        this._lightValues[1] = Math.ceil(this.getR(sl) / divisor);
+        this._lightValues[2] = Math.ceil(this.getG(sl) / divisor);
+        this._lightValues[3] = Math.ceil(this.getB(sl) / divisor);
+        return this.setLightValues(this._lightValues);
+    }
+}

package/Voxels/Effects/VoxelEffect.d.ts

@@ -1,11 +1,11 @@
-import { ChunkMesh } from "../../Renderer/Classes/ChunkMesh";
+import { SectionMesh } from "../../Renderer/Classes/SectionMesh";
 export interface VoxelEffectConstructor {
     id: string;
-    new (mesh: ChunkMesh): VoxelEffect;
+    new (mesh: SectionMesh): VoxelEffect;
 }
 export declare abstract class VoxelEffect {
-    mesh: ChunkMesh;
-    constructor(mesh: ChunkMesh);
+    mesh: SectionMesh;
+    constructor(mesh: SectionMesh);
     abstract init(): void;
     abstract setPoints(pointss: Float32Array): void;
     abstract dispose(): void;

package/Voxels/Functions/BuildStateData.js

@@ -2,7 +2,7 @@ import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/St
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
 import { VoxelTagStates } from "../State/VoxelTagStates";
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { StateSchema } from "../State/Schema/StateSchema";
 function bitsNeeded(n) {
     if (n < 0)

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -1,5 +1,5 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
-import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Voxel.types";
+import { PaintVoxelData } from "../Types/Voxel.types";
+import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Types/Voxel.types";
 export declare class VoxelNamedState {
     voxelId: string;
     data: VoxelNamedStateData;

package/Voxels/Indexes/VoxelIndex.js

@@ -1,6 +1,6 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
+import { PaintVoxelData } from "../Types/Voxel.types";
 import { SchemaRegister } from "../State/SchemaRegister";
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 export class VoxelNamedState {
     voxelId;
     data;
@@ -23,13 +23,13 @@ export class VoxelNamedState {
                 this.compiled.shapeStateAny = true;
             }
             else if (this.data.state) {
-                this.compiled.shapeState = schema.shapeState.readString(this.data.state);
+                this.compiled.shapeState = schema.state.readString(this.data.state);
             }
             if (this.data.mod == "*") {
                 this.compiled.modAny = true;
             }
             else if (this.data.mod) {
-                this.compiled.mod = schema.modState.readString(this.data.mod);
+                this.compiled.mod = schema.mod.readString(this.data.mod);
             }
         }
         else {
@@ -43,7 +43,7 @@ export class VoxelNamedState {
             id: this.voxelId,
             level: 0,
             levelState: 0,
-            shapeState: this.compiled.shapeState,
+            state: this.compiled.shapeState,
             mod: this.compiled.mod,
         });
     }
@@ -108,7 +108,7 @@ export class VoxelIndex {
         const conatiner = this.states.get(data.id);
         if (!conatiner)
             return false;
-        const { mod, shapeState } = data;
+        const { mod, state: shapeState } = data;
         for (const state of conatiner?.stateArray) {
             if ((mod == state.compiled.mod || state.compiled.modAny) &&
                 (shapeState == state.compiled.shapeState ||

package/Voxels/InitVoxelData.d.ts

@@ -1,9 +1,13 @@
 import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
-import { VoxelData } from "./Voxel.types";
-import { ConstructorVoxelModelSyncData } from "./VoxelSyncData";
+import { VoxelData } from "./Types/Voxel.types";
+import { CompiledVoxelData } from "./Types/VoxelModelCompiledData.types";
+import { VoxelMaterialData } from "./Types/VoxelMaterial.types";
+import { VoxelSubstanceData } from "./Types/VoxelSubstances.types";
 export type InitVoxelDataProps = {
     geometry?: VoxelGeometryData[];
     models?: VoxelModelData[];
     voxels: VoxelData[];
+    materials?: VoxelMaterialData[];
+    substances?: VoxelSubstanceData[];
 };
-export declare function InitVoxelData(data: InitVoxelDataProps): ConstructorVoxelModelSyncData;
+export declare function InitVoxelData(data: InitVoxelDataProps): CompiledVoxelData;