@divinevoxel/vlox 0.0.74 → 0.0.76

package/Voxels/Types/PaintVoxelData.js

@@ -0,0 +1,159 @@
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { VoxelLevelReader } from "../Cursor/VoxelLevelReader";
+import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
+export class PaintVoxelData {
+    id;
+    name;
+    state;
+    stateString;
+    mod;
+    modString;
+    level;
+    levelState;
+    secondaryVoxelId;
+    secondaryName;
+    secondaryMod;
+    secondaryModString;
+    secondaryState;
+    secondaryStateString;
+    static Create(data = {}) {
+        return new PaintVoxelData(data.id, data.name, data.state, data.stateString, data.mod, data.modString, data.level, data.levelState, data.secondaryVoxelId, data.secondaryName, data.secondaryMod, data.secondaryModString, data.secondaryState, data.secondaryModString);
+    }
+    /**Transforms numeric voxel data into a PaintVoxelData object */
+    static FromRaw(data, paintData = PaintVoxelData.Create()) {
+        const [trueVoxelId, state, mod] = VoxelPalettesRegister.voxels[data[0]];
+        paintData.id = VoxelPalettesRegister.voxelIds.getStringId(trueVoxelId);
+        paintData.state = state;
+        paintData.mod = mod;
+        paintData.name =
+            VoxelPalettesRegister.voxelIdToNameMap.get(paintData.id) || "";
+        if (data[3] !== 0) {
+            const [trueVoxelId, state, mod] = VoxelPalettesRegister.voxels[data[3]];
+            paintData.secondaryVoxelId =
+                VoxelPalettesRegister.voxelIds.getStringId(trueVoxelId);
+            paintData.secondaryState = state;
+            paintData.secondaryMod = mod;
+            paintData.secondaryName =
+                VoxelPalettesRegister.voxelIdToNameMap.get(paintData.secondaryVoxelId) || "";
+        }
+        paintData.level = VoxelLevelReader.getLevel(data[2]);
+        paintData.levelState = VoxelLevelReader.getLevel(data[2]);
+        return paintData;
+    }
+    /**Transforms the voxel data into numeric voxel data */
+    static ToRaw(data, light = 0) {
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.secondaryName
+            ? data.secondaryVoxelId
+            : data.secondaryName
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
+                : "dve_air";
+        let state = data.state || 0;
+        let mod = data.mod || 0;
+        let secondaryState = data.secondaryState || 0;
+        let secondaryMod = data.secondaryMod || 0;
+        if (SchemaRegister.hasVoxelSchema(stringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(stringId);
+            if (data.stateString && data.stateString !== "") {
+                state = schema.state.readString(data.stateString);
+            }
+            if (data.modString && data.modString !== "") {
+                mod = schema.mod.readString(data.modString);
+            }
+        }
+        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
+            if (data.secondaryStateString && data.secondaryStateString !== "") {
+                secondaryState = schema.state.readString(data.secondaryStateString);
+            }
+            if (data.secondaryModString && data.secondaryModString !== "") {
+                secondaryMod = schema.mod.readString(data.secondaryModString);
+            }
+        }
+        const id = stringId !== "dve_air"
+            ? VoxelPalettesRegister.getVoxelIdFromString(stringId, state || 0, mod || 0)
+            : 0;
+        const secondaryId = secondaryStringId !== "dve_air"
+            ? secondaryStringId
+                ? VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, secondaryState || 0, secondaryMod || 0)
+                : 0
+            : 0;
+        let levleData = 0;
+        if (data.level !== undefined)
+            levleData = VoxelLevelReader.setLevel(levleData, data.level);
+        if (data.levelState !== undefined)
+            levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
+        return [id, light, levleData, secondaryId];
+    }
+    /**Restores the data to the default state of being dve_air */
+    static Clear(data) {
+        data.id = "dve_air";
+        data.name = "";
+        data.state = 0;
+        data.stateString = "";
+        data.mod = 0;
+        data.modString = "";
+        data.level = 0;
+        data.levelState = 0;
+        data.secondaryVoxelId = "dve_air";
+        data.secondaryName = "";
+        data.secondaryMod = 0;
+        data.secondaryModString = "";
+        data.secondaryState = 0;
+        data.secondaryStateString = "";
+        return data;
+    }
+    /**Clears the target data and then copies properties from source to target. */
+    static Set(target, source) {
+        PaintVoxelData.Clear(target);
+        if (source.id !== undefined)
+            target.id = source.id;
+        if (source.name !== undefined)
+            target.name = source.name;
+        if (source.state !== undefined)
+            target.state = source.state;
+        if (source.stateString !== undefined)
+            target.stateString = source.stateString;
+        if (source.mod !== undefined)
+            target.mod = source.mod;
+        if (source.modString !== undefined)
+            target.modString = source.modString;
+        if (source.level !== undefined)
+            target.level = source.level;
+        if (source.levelState !== undefined)
+            target.levelState = source.levelState;
+        if (source.secondaryVoxelId !== undefined)
+            target.secondaryVoxelId = source.secondaryVoxelId;
+        if (source.secondaryName !== undefined)
+            target.secondaryName = source.secondaryName;
+        if (source.secondaryMod !== undefined)
+            target.secondaryMod = source.secondaryMod;
+        if (source.secondaryModString !== undefined)
+            target.secondaryModString = source.secondaryModString;
+        if (source.secondaryState !== undefined)
+            target.secondaryState = source.secondaryState;
+        if (source.secondaryStateString !== undefined)
+            target.secondaryStateString = source.secondaryStateString;
+        return target;
+    }
+    constructor(id = "dve_air", name = "", state = 0, stateString = "", mod = 0, modString = "", level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryName = "", secondaryMod = 0, secondaryModString = "", secondaryState = 0, secondaryStateString = "") {
+        this.id = id;
+        this.name = name;
+        this.state = state;
+        this.stateString = stateString;
+        this.mod = mod;
+        this.modString = modString;
+        this.level = level;
+        this.levelState = levelState;
+        this.secondaryVoxelId = secondaryVoxelId;
+        this.secondaryName = secondaryName;
+        this.secondaryMod = secondaryMod;
+        this.secondaryModString = secondaryModString;
+        this.secondaryState = secondaryState;
+        this.secondaryStateString = secondaryStateString;
+    }
+}

package/Voxels/Types/Voxel.types.d.ts

@@ -1,7 +1,8 @@
 import { TextureId } from "../../Textures/index";
-import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
+import { VoxelModelConstructorData } from "../Models/VoxelModel.types";
 import { VoxelTags } from "../Data/VoxelTag.types";
 import { VoxelLogicData } from "../Logic/VoxelLogic.types";
+import { VoxelPlacingStrategyData } from "Voxels/Interaction/Placing/VoxelPlacingStrategy.types";
 export interface VoxelDataArrays {
     /**The runtime numeric voxel ids */
     ids: Uint16Array;
@@ -9,12 +10,7 @@ export interface VoxelDataArrays {
     light: Uint16Array;
     /**The levels of the voxel. Used mainly for waterflow now. */
     level: Uint8Array;
-    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
-    state: Uint16Array;
-    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
-    mod: Uint16Array;
     /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
-     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
      */
     secondary: Uint16Array;
 }
@@ -28,6 +24,8 @@ export type VoxelNamedStateData = {
     };
     display: {
         type: "texture";
+        /**The id of the texture type to pull from  */
+        textureType?: string;
         source: TextureId | string;
     } | {
         type: "model";
@@ -35,18 +33,6 @@ export type VoxelNamedStateData = {
         mod?: string;
     };
 };
-export declare class PaintVoxelData {
-    id: string;
-    name: string;
-    mod: number;
-    state: number;
-    level: number;
-    levelState: number;
-    secondaryVoxelId: string;
-    secondaryVoxeName: string;
-    static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
-    private constructor();
-}
 /**
  * An array representing the raw data of a voxel.
  */
@@ -57,18 +43,20 @@ export type RawVoxelData = [
     light: number,
     /**The level of the voxel */
     level: number,
-    /**The state of the voxel */
-    state: number,
-    /**The mod of the voxel */
-    mod: number,
     /**The secondary id of the voxel */
     secondary: number
 ];
-interface VoxelProperties extends Partial<VoxelTags> {
+export interface VoxelBaseProperties extends Partial<VoxelTags> {
     [key: string]: any;
     /**Logic data for a the voxel */
     dve_logic_data?: VoxelLogicData[];
-    /** Named states associated with the voxel. */
+    /**map mod states of the voxel to particle textures */
+    dve_particle_data?: Record<string, TextureId>;
+    /**Define a strategy for placing the model. */
+    dve_placing_strategy?: VoxelPlacingStrategyData[] | string;
+}
+export interface VoxelProperties extends VoxelBaseProperties {
+    /** Named states associated with the voxel. Used for indexing. */
     dve_named_states?: VoxelNamedStateData[];
     /** Model data used to construct the voxel's appearance. */
     dve_model_data?: VoxelModelConstructorData;
@@ -83,4 +71,3 @@ export interface VoxelData {
     /**The properties of the voxel. */
     properties: VoxelProperties;
 }
-export {};

package/Voxels/Types/Voxel.types.js

@@ -1,23 +1 @@
-export class PaintVoxelData {
-    id;
-    name;
-    mod;
-    state;
-    level;
-    levelState;
-    secondaryVoxelId;
-    secondaryVoxeName;
-    static Create(data) {
-        return new PaintVoxelData(data.id, data.name, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId, data.secondaryVoxeName);
-    }
-    constructor(id = "dve_air", name = "", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryVoxeName = "") {
-        this.id = id;
-        this.name = name;
-        this.mod = mod;
-        this.state = state;
-        this.level = level;
-        this.levelState = levelState;
-        this.secondaryVoxelId = secondaryVoxelId;
-        this.secondaryVoxeName = secondaryVoxeName;
-    }
-}
+export {};

package/Voxels/Types/VoxelModelCompiledData.types.d.ts

@@ -1,18 +1,14 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelAOResultsIndexData } from "../../Models/Indexing/VoxelAOResultsIndex";
-import { VoxelFaceCullResultsIndexData } from "../../Models/Indexing/VoxelFaceCullResultsIndex";
-import { VoxelFaceTransparentResultsIndexData } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
-import { VoxelModelStateSchemaData, StateLogicStatement } from "../State/State.types";
-import { VoxelGeometryData, VoxelGeometryNodes } from "../../Models/VoxelModel.types";
-import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
-import { VoxelTagStatesData } from "../Data/VoxelTagStates";
 import { VoxelSubstanceTags, VoxelTags } from "../Data/VoxelTag.types";
-import { VoxelLogicData } from "../../Voxels/Logic/VoxelLogic.types";
+import { VoxelLogicData } from "../Logic/VoxelLogic.types";
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { FinalCompiledVoxelModelData } from "../Models/CompiledVoxelModel.types";
 export type CompiledVoxelTagAndPaletteData = {
     data: {
         logic: Record<string, VoxelLogicData[]>;
         tags: VoxelTags[];
-        palette: string[];
+        idPalette: string[];
+        palette: typeof VoxelPalettesRegister.voxels;
+        record: typeof VoxelPalettesRegister.voxelRecord;
         nameToIdMap: [string, string][];
         idToNameMap: [string, string][];
     };
@@ -27,67 +23,3 @@ export type CompiledVoxelTagAndPaletteData = {
 export type CompiledVoxelData = {
     models: FinalCompiledVoxelModelData;
 } & CompiledVoxelTagAndPaletteData;
-export interface CompiledVoxelGeometryNodes {
-    node: VoxelGeometryNodes;
-    tranform: VoxelGeometryTransform;
-}
-export interface VoxelGeometryTransform {
-    position?: Vec3Array;
-    scale?: Vec3Array;
-    rotation?: Vec3Array;
-    rotationPivot?: Vec3Array;
-    lockUVs?: true;
-    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
-}
-export interface CompiledVoxelGeometryData {
-    id: string;
-    ogData: VoxelGeometryData;
-    nodes: CompiledVoxelGeometryNodes[];
-}
-export type CompiledVoxelGeometrySyncData = {
-    id: string;
-    nodes: CompiledVoxelGeometryNodes[];
-    faceCullMap?: number[][];
-    vertexHitMap?: number[][];
-    aoIndex?: VoxelAOResultsIndexData;
-    cullIndex?: VoxelFaceCullResultsIndexData;
-};
-export interface CompiledVoxelGeometryRulessData {
-    id: string;
-    nodes: CompiledVoxelGeometryNodes[];
-    ruleless: true;
-}
-export interface CompiledVoxelModelData {
-    id: string;
-    schema: VoxelModelStateSchemaData[];
-    effects: VoxelEffectSyncData[];
-    geoLinkMap: number[];
-    stateTree: any[];
-    stateMap: number[][];
-    stateGeometryMap: number[][];
-    stateRelativeGeometryMap: number[][];
-    relativeGeometryByteIndexMap: number[];
-    condiotnalStatements: StateLogicStatement[];
-    condiotnalStateMap: number[][];
-    condiotnalShapeStateMap: number[][][];
-    condiotnalShapeStateGeometryMap: number[][][];
-    condiotnalShapeStateRelativeGeometryMap: number[][];
-    condiotnalStateTree: any[];
-}
-export interface CompiledVoxelModelInputData {
-    id: string;
-    materialId: string;
-    modelId: string;
-    transparentFaceIndex: VoxelFaceTransparentResultsIndexData;
-    modSchema: VoxelModelStateSchemaData[];
-    modStateTree: any[];
-    baseGeometryInputMap: any[][];
-    condiotnalGeometryInputMap: any[][];
-}
-export interface FinalCompiledVoxelModelData {
-    geometryPalette: string[];
-    geometry: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[];
-    models: CompiledVoxelModelData[];
-    voxels: CompiledVoxelModelInputData[];
-    tagState: VoxelTagStatesData;
-}

package/Voxels/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./Types/Voxel.types";
 export * from "./Types/VoxelMaterial.types";
 export * from "./Types/VoxelSubstances.types";
+export * from "./Types/PaintVoxelData";

package/Voxels/index.js

@@ -1,3 +1,4 @@
 export * from "./Types/Voxel.types";
 export * from "./Types/VoxelMaterial.types";
 export * from "./Types/VoxelSubstances.types";
+export * from "./Types/PaintVoxelData";

package/World/Archive/Classes/ArchiveClasses.d.ts

@@ -1,7 +1,7 @@
-import { StringPalette } from "../../../Util/StringPalette";
 import { NumberPalette } from "../../../Util/NumberPalette";
 import { Section } from "../../../World/Section";
-import { ArchivedLightSegments } from "../Archive.types";
+import { ArchivedLightSegments } from "../Types/Archive.types";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
 declare class ProcessedData<Buffer = any> {
     buffer: Buffer;
     constructor(buffer: Buffer);
@@ -11,33 +11,18 @@ declare class ProcessedData<Buffer = any> {
     value: number;
 }
 declare class SectionPalette {
-    ids: NumberPalette;
+    voxels: NumberPalette;
     level: NumberPalette;
     light: LightPalette;
-    maxStatePaletteSize: number;
-    state: Record<number, NumberPalette>;
-    secondaryState: Record<number, NumberPalette>;
-    maxModPaletteSize: number;
-    mod: Record<number, NumberPalette>;
-    secondaryMod: Record<number, NumberPalette>;
-    secondaryId: NumberPalette;
-    secondaryValue: NumberPalette;
+    secondaryVoxels: NumberPalette;
 }
 export declare class ProcessedSection {
     original: Section;
     palettes: SectionPalette;
-    isBuriedAllTheSame: boolean;
-    buriedValue: number;
-    isVoxelMapAllTheSame: boolean;
-    voxelMapValue: number;
-    isDirtyMapAllTheSame: boolean;
-    dirtyMapValue: number;
-    ids: ProcessedData<Uint16Array>;
     light: Record<ArchivedLightSegments, ProcessedData<Uint8Array>>;
     level: ProcessedData<Uint8Array>;
-    state: ProcessedData<Uint16Array>;
-    mod: ProcessedData<Uint16Array>;
-    secondary: ProcessedData<Uint16Array>;
+    voxels: ProcessedData<Uint16Array>;
+    secondaryVoxels: ProcessedData<Uint16Array>;
     constructor(original: Section);
 }
 declare class LightPalette {
@@ -51,16 +36,8 @@ export declare class VoxelStateObjectMap {
     states: any[];
 }
 export declare class SectorPalette {
-    ids: StringPalette;
+    voxels: VoxelArchivePalette;
     level: NumberPalette;
     light: LightPalette;
-    stateMap: VoxelStateObjectMap[];
-    secondaryStateMap: VoxelStateObjectMap[];
-    maxStatePaletteSize: number;
-    modMap: VoxelStateObjectMap[];
-    secondaryModMap: VoxelStateObjectMap[];
-    maxModPaletteSize: number;
-    secondaryId: StringPalette;
-    secondaryValue: NumberPalette;
 }
 export {};

package/World/Archive/Classes/ArchiveClasses.js

@@ -1,5 +1,5 @@
-import { StringPalette } from "../../../Util/StringPalette";
 import { NumberPalette } from "../../../Util/NumberPalette";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
 class ProcessedData {
     buffer;
     constructor(buffer) {
@@ -11,36 +11,21 @@ class ProcessedData {
     value = 0;
 }
 class SectionPalette {
-    ids = new NumberPalette();
+    voxels = new NumberPalette();
     level = new NumberPalette();
     light = new LightPalette();
-    maxStatePaletteSize = 0;
-    state = {};
-    secondaryState = {};
-    maxModPaletteSize = 0;
-    mod = {};
-    secondaryMod = {};
-    secondaryId = new NumberPalette();
-    secondaryValue = new NumberPalette();
+    secondaryVoxels = new NumberPalette();
 }
 export class ProcessedSection {
     original;
     palettes = new SectionPalette();
-    isBuriedAllTheSame = false;
-    buriedValue = 0;
-    isVoxelMapAllTheSame = false;
-    voxelMapValue = 0;
-    isDirtyMapAllTheSame = false;
-    dirtyMapValue = 0;
-    ids;
     light;
     level;
-    state;
-    mod;
-    secondary;
+    voxels;
+    secondaryVoxels;
     constructor(original) {
         this.original = original;
-        this.ids = new ProcessedData(new Uint16Array(original.ids.length));
+        this.voxels = new ProcessedData(new Uint16Array(original.ids.length));
         this.level = new ProcessedData(new Uint8Array(original.level.length));
         this.light = {
             sun: new ProcessedData(new Uint8Array(original.light.length)),
@@ -48,9 +33,7 @@ export class ProcessedSection {
             green: new ProcessedData(new Uint8Array(original.light.length)),
             blue: new ProcessedData(new Uint8Array(original.light.length)),
         };
-        this.state = new ProcessedData(new Uint16Array(original.state.length));
-        this.mod = new ProcessedData(new Uint16Array(original.mod.length));
-        this.secondary = new ProcessedData(new Uint16Array(original.mod.length));
+        this.secondaryVoxels = new ProcessedData(new Uint16Array(original.secondary.length));
     }
 }
 class LightPalette {
@@ -64,15 +47,7 @@ export class VoxelStateObjectMap {
     states = [];
 }
 export class SectorPalette {
-    ids = new StringPalette();
+    voxels = new VoxelArchivePalette();
     level = new NumberPalette();
     light = new LightPalette();
-    stateMap = [];
-    secondaryStateMap = [];
-    maxStatePaletteSize = 0;
-    modMap = [];
-    secondaryModMap = [];
-    maxModPaletteSize = 0;
-    secondaryId = new StringPalette();
-    secondaryValue = new NumberPalette();
 }

package/World/Archive/Classes/ImportedSection.d.ts

@@ -1,26 +1,19 @@
 import { NumberPalette } from "../../../Util/NumberPalette";
-import { ArchivedLightSegments, ArchivedSectionData } from "../Archive.types";
-import { BinaryBuffer } from "../../../Util/Binary/BinaryBuffer";
+import { ArchivedLightSegments, ArchivedSectionData } from "../Types/index";
+import { BinaryBuffer } from "../../../Util/BinaryBuffer/index";
 import { ImportedSector } from "./ImportedSector";
 declare class ImportedSectionBuffers {
     ids: BinaryBuffer;
     level: BinaryBuffer;
     light: Record<ArchivedLightSegments, BinaryBuffer>;
-    state: BinaryBuffer;
-    mod: BinaryBuffer;
     secondary: BinaryBuffer;
     constructor(section: ArchivedSectionData);
 }
 declare class ImportedSectionPalettes {
-    id?: NumberPalette;
+    voxels?: NumberPalette;
     level?: NumberPalette;
     light: Record<ArchivedLightSegments, NumberPalette | null>;
-    state?: NumberPalette[];
-    secondaryState?: NumberPalette[];
-    mod?: NumberPalette[];
-    secondaryMod?: NumberPalette[];
-    secondaryId?: NumberPalette;
-    secondaryValue?: NumberPalette;
+    secondaryVoxels?: NumberPalette;
     constructor(section: ArchivedSectionData);
 }
 export declare class ImportedSection {
@@ -34,7 +27,5 @@ export declare class ImportedSection {
     getLight(index: number): number;
     getLevel(index: number): number;
     getSecondary(index: number): number;
-    getState(index: number): number;
-    getMod(index: number): number;
 }
 export {};