@divinevoxel/vlox 0.0.77 → 0.0.79

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -2,14 +2,13 @@ import { VoxelLightData } from "./VoxelLightData";
 import { VoxelLevelReader } from "./VoxelLevelReader";
 import { VoxelTagIds, } from "../../Voxels/Data/VoxelTag.types";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+//import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
-import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
 export class VoxelCursorInterface {
     _voxelId = 0;
     id = 0;
     secondaryId = 0;
-    schema;
     tags = {};
     substanceTags = {};
     __readingSecondaryVoxel = false;
@@ -22,8 +21,7 @@ export class VoxelCursorInterface {
         this._voxelId = this.getVoxelId();
         this.tags = VoxelTagsRegister.VoxelTags[this._voxelId];
         this.substanceTags =
-            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this.tags["dve_substance"])];
-        this.schema = SchemaRegister.getVoxelSchemas(this.getStringId());
+            VoxelTagsRegister.SubstanceTags[VoxelLUT.substance.getNumberId(this.tags["dve_substance"])];
     }
     setSecondary(enable) {
         this.__readingSecondaryVoxel = enable;
@@ -193,32 +191,32 @@ export class VoxelCursorInterface {
         return this.getIndexData()[0];
     }
     setVoxelId(id, state = 0, mod = 0) {
-        return this.setId(VoxelPalettesRegister.getVoxelId(id, state, mod));
+        return this.setId(VoxelLUT.getVoxelId(id, state, mod));
     }
     setStringId(id, state = 0, mod = 0) {
-        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(id), state, mod);
+        return this.setVoxelId(VoxelLUT.voxelIds.getNumberId(id), state, mod);
     }
     getStringId() {
-        return VoxelPalettesRegister.voxelIds.getStringId(this.getIndexData()[0]);
+        return VoxelLUT.voxelIds.getStringId(this.getIndexData()[0]);
     }
     setName(name, state = 0, mod = 0) {
-        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(VoxelPalettesRegister.voxelNametoIdMap.get(name)), state, mod);
+        return this.setVoxelId(VoxelLUT.voxelIds.getNumberId(VoxelLUT.voxelNametoIdMap.get(name)), state, mod);
     }
     getName() {
-        return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
+        return VoxelLUT.voxelIdToNameMap.get(this.getStringId());
     }
     getIndexData() {
         if (this.__readingSecondaryVoxel) {
-            return VoxelPalettesRegister.voxels[this.secondary[this._index]];
+            return VoxelLUT.voxels[this.secondary[this._index]];
         }
-        return VoxelPalettesRegister.voxels[this.ids[this._index]];
+        return VoxelLUT.voxels[this.ids[this._index]];
     }
     getMod() {
-        return VoxelPalettesRegister.voxels[this.ids[this._index]][2];
+        return VoxelLUT.voxels[this.ids[this._index]][2];
     }
     setMod(mod) {
-        const index = VoxelPalettesRegister.voxels[this.ids[this._index]];
-        this.setId(VoxelPalettesRegister.getVoxelId(index[0], index[1], mod));
+        const index = VoxelLUT.voxels[this.ids[this._index]];
+        this.setId(VoxelLUT.getVoxelId(index[0], index[1], mod));
         return this;
     }
     getState() {
@@ -226,7 +224,7 @@ export class VoxelCursorInterface {
     }
     setState(state) {
         const index = this.getIndexData();
-        this.setId(VoxelPalettesRegister.getVoxelId(index[0], state, index[2]));
+        this.setId(VoxelLUT.getVoxelId(index[0], state, index[2]));
         return this;
     }
     isSameVoxel(voxel) {

package/Voxels/Cursor/VoxelCursor.js

@@ -1,23 +1,23 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 import { VoxelLevelReader } from "./VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
         let stringId = data.id
             ? data.id
             : data.name
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                ? VoxelLUT.voxelNametoIdMap.get(data.name)
                 : "dve_air";
         let secondaryStringId = data.id
             ? data.id
             : data.name
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                ? VoxelLUT.voxelNametoIdMap.get(data.name)
                 : "dve_air";
         const id = (stringId !== "dve_air" &&
-            VoxelPalettesRegister.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
+            VoxelLUT.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
             0;
         const secondaryId = (secondaryStringId !== "dve_air" &&
-            VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, data.state || 0, data.mod || 0)) ||
+            VoxelLUT.getVoxelIdFromString(secondaryStringId, data.state || 0, data.mod || 0)) ||
             0;
         let levleData = 0;
         if (data.level !== undefined)

package/Voxels/Data/GeometryLUT.d.ts

@@ -0,0 +1,32 @@
+import { AOOcclusionFaceIndex, AOOcclusionFaceIndexData } from "../Geometry/AOOcclusionFaceIndex";
+import { CompiledGeometryNodes } from "../../Mesher/Voxels/Models/Nodes/Types/GeometryNode.types";
+import { CulledOcclusionFaceIndex, CulledOcclusionFaceIndexData } from "../Geometry/CulledOcclusionFaceIndex";
+import { CullingProcedureData } from "../Geometry/VoxelGeometry.types";
+export type GeometryLUTExport = {
+    geometryIndex: number[][];
+    geometryInputsIndex: number[][];
+    geometryInputs: any[][];
+    compiledGeometry: CompiledGeometryNodes[][];
+    rulelessIndex: boolean[];
+    geometryCullingProceduresIndex: number[];
+    geometryCullingProcedures: CullingProcedureData[];
+    faceCullIndex: CulledOcclusionFaceIndexData;
+    aoIndex: AOOcclusionFaceIndexData;
+    faceCullMap: number[][];
+    aoVertexHitMap: number[][][];
+};
+export declare class GeometryLUT {
+    static geometryIndex: number[][];
+    static geometryInputsIndex: number[][];
+    static geometryInputs: any[][];
+    static compiledGeometry: CompiledGeometryNodes[][];
+    static rulelessIndex: boolean[];
+    static geometryCullingProceduresIndex: number[];
+    static geometryCullingProcedures: CullingProcedureData[];
+    static faceCullIndex: CulledOcclusionFaceIndex;
+    static aoIndex: AOOcclusionFaceIndex;
+    static faceCullMap: number[][];
+    static aoVertexHitMap: number[][][];
+    static export(): GeometryLUTExport;
+    static import(exported: GeometryLUTExport): void;
+}

package/Voxels/Data/GeometryLUT.js

@@ -0,0 +1,50 @@
+import { AOOcclusionFaceIndex, } from "../Geometry/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex, } from "../Geometry/CulledOcclusionFaceIndex";
+export class GeometryLUT {
+    //map of geometry indexes to the geometry node id array
+    static geometryIndex = [];
+    //map of geometry indexes to the geometry node input array
+    static geometryInputsIndex = [];
+    //final map of the geometry input index to their inputs
+    static geometryInputs = [];
+    //final map of geo ids to their compiled geometry nodes
+    static compiledGeometry = [];
+    //maps geometry ids to wether it is ruleless
+    static rulelessIndex = [];
+    //maps geometry node indexes to their culling procedure index
+    static geometryCullingProceduresIndex = [];
+    //record of culling procedures
+    static geometryCullingProcedures = [];
+    static faceCullIndex;
+    static aoIndex;
+    static faceCullMap = [];
+    static aoVertexHitMap = [];
+    static export() {
+        return {
+            geometryIndex: this.geometryIndex,
+            geometryInputsIndex: this.geometryInputsIndex,
+            geometryInputs: this.geometryInputs,
+            compiledGeometry: this.compiledGeometry,
+            rulelessIndex: this.rulelessIndex,
+            geometryCullingProceduresIndex: this.geometryCullingProceduresIndex,
+            geometryCullingProcedures: this.geometryCullingProcedures,
+            faceCullIndex: this.faceCullIndex.toJSON(),
+            aoIndex: this.aoIndex.toJSON(),
+            faceCullMap: this.faceCullMap,
+            aoVertexHitMap: this.aoVertexHitMap,
+        };
+    }
+    static import(exported) {
+        this.geometryIndex = exported.geometryIndex;
+        this.geometryInputsIndex = exported.geometryInputsIndex;
+        this.geometryInputs = exported.geometryInputs;
+        this.compiledGeometry = exported.compiledGeometry;
+        this.rulelessIndex = exported.rulelessIndex;
+        this.geometryCullingProceduresIndex = exported.geometryCullingProceduresIndex;
+        this.geometryCullingProcedures = exported.geometryCullingProcedures;
+        this.faceCullIndex = new CulledOcclusionFaceIndex(exported.faceCullIndex);
+        this.aoIndex = new AOOcclusionFaceIndex(exported.aoIndex);
+        this.faceCullMap = exported.faceCullMap;
+        this.aoVertexHitMap = exported.aoVertexHitMap;
+    }
+}

package/Voxels/Data/VoxelLUT.d.ts

@@ -0,0 +1,83 @@
+import { StringPalette } from "../../Util/StringPalette";
+export type VoxelLUTExport = {
+    material: string[];
+    materialMap: number[];
+    substance: string[];
+    substanceMap: number[];
+    voxelIds: string[];
+    voxelNametoIdMap: [key: string, value: string][];
+    voxelIdToNameMap: [key: string, value: string][];
+    models: string[];
+    modelsIndex: number[];
+    totalStates: number[];
+    totalMods: number[];
+    totalReltionalStates: number[];
+    totalReltionalMods: number[];
+    geometryIndex: number[][];
+    geometryInputsIndex: number[][];
+    conditionalGeometryIndex: [
+        geometryId: number,
+        modelState: number,
+        modelReltionalState: boolean[]
+    ][][];
+    conditionalGeometryInputIndex: number[][][];
+    voxels: [voxelId: number, state: number, mod: number][];
+    voxelRecord: number[][][];
+    voxelIdToModelState: number[];
+    reltioanlVoxels: [
+        voxelId: number,
+        reltionalState: number,
+        reltioanlMod: number
+    ][];
+    reltionalVoxelRecord: number[][][];
+};
+export declare class VoxelLUT {
+    static material: StringPalette;
+    static materialMap: number[];
+    static substance: StringPalette;
+    static substanceMap: number[];
+    static voxelIds: StringPalette;
+    static voxelNametoIdMap: Map<string, string>;
+    static voxelIdToNameMap: Map<string, string>;
+    static models: StringPalette;
+    static modelsIndex: number[];
+    static totalStates: number[];
+    static totalMods: number[];
+    static totalReltionalStates: number[];
+    static totalReltionalMods: number[];
+    static geometryIndex: number[][];
+    static geometryInputsIndex: number[][];
+    static conditionalGeometryIndex: [
+        geometryId: number,
+        modelState: number,
+        modelReltionalState: boolean[]
+    ][][];
+    static conditionalGeometryInputIndex: number[][][];
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels: [voxelId: number, state: number, mod: number][];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord: number[][][];
+    static voxelIdToModelState: number[];
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static reltioanlVoxels: [
+        voxelId: number,
+        reltionalState: number,
+        reltioanlMod: number
+    ][];
+    /**Palette of true voxel ids to reltional state then theirreltional  mod then the final reltional palette voxel id */
+    static reltionalVoxelRecord: number[][][];
+    static getVoxelId(id: number, state?: number, mod?: number): number;
+    static getVoxelIdFromString(id: string, state?: number, mod?: number): number;
+    static getVoxelIdFromName(name: string, state?: number, mod?: number): number;
+    static getReltionalVoxelId(id: number, reltioanlState?: number, reltioanlMod?: number): number;
+    static getGeometryIndex(voxelId?: number, reltioanlId?: number): number;
+    static getGeometryInputIndex(voxelId?: number, reltioanlId?: number): number;
+    static getConditionalGeometryNodes(trueVoxelId: number): [
+        geometryId: number,
+        modelState: number,
+        modelReltionalState: boolean[]
+    ][];
+    static getConditionalGeometryInputIndex(getIndex: number, voxelId?: number, reltioanlId?: number): number;
+    static export(): VoxelLUTExport;
+    static import(exported: VoxelLUTExport): void;
+}

package/Voxels/Data/VoxelLUT.js

@@ -0,0 +1,119 @@
+import { StringPalette } from "../../Util/StringPalette";
+export class VoxelLUT {
+    static material = new StringPalette();
+    //maps true voxel ids to their material id
+    static materialMap = [];
+    static substance = new StringPalette();
+    //maps true voxel ids to their substance id
+    static substanceMap = [];
+    //maps voxel string ids to their true id
+    static voxelIds = new StringPalette();
+    //maps voxel names to their ids
+    static voxelNametoIdMap = new Map();
+    //maps voxel ids to their names
+    static voxelIdToNameMap = new Map();
+    //palette of voxel model ids
+    static models = new StringPalette();
+    //maps true voxel ids to their model palette id
+    static modelsIndex = [];
+    //maps true voxel ids to the total number of states
+    static totalStates = [];
+    //maps true voxel ids to the total number of mod states
+    static totalMods = [];
+    //maps true voxel ids to the total number of reltional states
+    static totalReltionalStates = [];
+    //maps true voxel ids to the total number of reltional mod states
+    static totalReltionalMods = [];
+    //maps [voxel id x reltional voxel id] to the geometry index
+    static geometryIndex = [];
+    //maps [voxel id x reltional voxel id] to the geometry inputs index
+    static geometryInputsIndex = [];
+    //maps voxel id to its conditional nodes and the needed voxel id and reltional voxel id
+    static conditionalGeometryIndex = [];
+    //maps [geometry id x voxel id x reltional voxel id] to the geometry index
+    static conditionalGeometryInputIndex = [];
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels = [];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord = [];
+    //Maps the voxel id to the model state
+    static voxelIdToModelState = [];
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static reltioanlVoxels = [];
+    /**Palette of true voxel ids to reltional state then theirreltional  mod then the final reltional palette voxel id */
+    static reltionalVoxelRecord = [];
+    static getVoxelId(id, state = 0, mod = 0) {
+        return this.voxelRecord[id][mod][state];
+    }
+    static getVoxelIdFromString(id, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(id)][mod][state];
+    }
+    static getVoxelIdFromName(name, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(this.voxelNametoIdMap.get(name))][mod][state];
+    }
+    static getReltionalVoxelId(id, reltioanlState = 0, reltioanlMod = 0) {
+        return this.reltionalVoxelRecord[id][reltioanlMod][reltioanlState];
+    }
+    static getGeometryIndex(voxelId = 0, reltioanlId = 0) {
+        return this.geometryIndex[voxelId][reltioanlId];
+    }
+    static getGeometryInputIndex(voxelId = 0, reltioanlId = 0) {
+        return this.geometryInputsIndex[voxelId][reltioanlId];
+    }
+    static getConditionalGeometryNodes(trueVoxelId) {
+        return this.conditionalGeometryIndex[trueVoxelId];
+    }
+    static getConditionalGeometryInputIndex(getIndex, voxelId = 0, reltioanlId = 0) {
+        return this.conditionalGeometryInputIndex[getIndex][voxelId][reltioanlId];
+    }
+    static export() {
+        return {
+            material: this.material._palette,
+            materialMap: this.materialMap,
+            substance: this.substance._palette,
+            substanceMap: this.substanceMap,
+            voxelIds: this.voxelIds._palette,
+            voxelNametoIdMap: [...this.voxelNametoIdMap],
+            voxelIdToNameMap: [...this.voxelIdToNameMap],
+            models: this.models._palette,
+            modelsIndex: this.modelsIndex,
+            totalStates: this.totalStates,
+            totalMods: this.totalMods,
+            totalReltionalStates: this.totalReltionalStates,
+            totalReltionalMods: this.totalReltionalMods,
+            geometryIndex: this.geometryIndex,
+            geometryInputsIndex: this.geometryInputsIndex,
+            conditionalGeometryIndex: this.conditionalGeometryIndex,
+            conditionalGeometryInputIndex: this.conditionalGeometryInputIndex,
+            voxels: this.voxels,
+            voxelRecord: this.voxelRecord,
+            voxelIdToModelState: this.voxelIdToModelState,
+            reltioanlVoxels: this.reltioanlVoxels,
+            reltionalVoxelRecord: this.reltionalVoxelRecord,
+        };
+    }
+    static import(exported) {
+        this.material.load(exported.material);
+        this.materialMap = exported.materialMap;
+        this.substance.load(exported.substance);
+        this.substanceMap = exported.substanceMap;
+        this.voxelIds.load(exported.voxelIds);
+        this.voxelNametoIdMap = new Map(exported.voxelNametoIdMap);
+        this.voxelIdToNameMap = new Map(exported.voxelIdToNameMap);
+        this.models.load(exported.models);
+        this.modelsIndex = exported.modelsIndex;
+        this.totalStates = exported.totalStates;
+        this.totalMods = exported.totalMods;
+        this.totalReltionalStates = exported.totalReltionalStates;
+        this.totalReltionalMods = exported.totalReltionalMods;
+        this.geometryIndex = exported.geometryIndex;
+        this.geometryInputsIndex = exported.geometryInputsIndex;
+        this.conditionalGeometryIndex = exported.conditionalGeometryIndex;
+        this.conditionalGeometryInputIndex = exported.conditionalGeometryInputIndex;
+        this.voxels = exported.voxels;
+        this.voxelRecord = exported.voxelRecord;
+        this.voxelIdToModelState = exported.voxelIdToModelState;
+        this.reltioanlVoxels = exported.reltioanlVoxels;
+        this.reltionalVoxelRecord = exported.reltionalVoxelRecord;
+    }
+}

package/Voxels/Data/VoxelTagsRegister.d.ts

@@ -4,6 +4,6 @@ export declare class VoxelTagsRegister {
     static IncludedSubstnacesTags: string[];
     static VoxelTagDefaults: Record<string, any>;
     static VoxelTags: VoxelTags[];
-    static SubstanceStagDefaults: Record<string, any>;
-    static SubstanceStags: VoxelSubstanceTags[];
+    static SubstanceTagDefaults: Record<string, any>;
+    static SubstanceTags: VoxelSubstanceTags[];
 }

package/Voxels/Data/VoxelTagsRegister.js

@@ -35,6 +35,6 @@ export class VoxelTagsRegister {
         [VoxelTagIds.simulationBehavior]: "dve_default",
     };
     static VoxelTags = [];
-    static SubstanceStagDefaults = {};
-    static SubstanceStags = [];
+    static SubstanceTagDefaults = {};
+    static SubstanceTags = [];
 }

package/Voxels/Functions/BuildLUTs.d.ts

@@ -0,0 +1,6 @@
+import { VoxelModelData } from "../Models/VoxelModel.types";
+import { VoxelData } from "../Types/Voxel.types";
+import { VoxelGeometryData } from "../Geometry/VoxelGeometry.types";
+import { VoxelMaterialData } from "../Types/VoxelMaterial.types";
+import { VoxelSubstanceData } from "../Types/VoxelSubstances.types";
+export declare function BuildLUTs(materials: VoxelMaterialData[], substances: VoxelSubstanceData[], voxels: VoxelData[], geometry: VoxelGeometryData[], models: VoxelModelData[]): void;