@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/Types/PaintVoxelData.d.ts

@@ -0,0 +1,17 @@
+import { RawVoxelData } from "./Voxel.types";
+export declare class PaintVoxelData {
+    id: string;
+    name: string;
+    mod: number;
+    state: number;
+    level: number;
+    levelState: number;
+    secondaryVoxelId: string;
+    secondaryName: string;
+    secondaryMod: number;
+    secondaryState: number;
+    static Create(data?: Partial<PaintVoxelData>): PaintVoxelData;
+    static FromRaw(data: RawVoxelData, paintData?: PaintVoxelData): PaintVoxelData;
+    static ToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
+    private constructor();
+}

package/Voxels/Types/PaintVoxelData.js

@@ -0,0 +1,73 @@
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { VoxelLevelReader } from "../Cursor/VoxelLevelReader";
+export class PaintVoxelData {
+    id;
+    name;
+    mod;
+    state;
+    level;
+    levelState;
+    secondaryVoxelId;
+    secondaryName;
+    secondaryMod;
+    secondaryState;
+    static Create(data = {}) {
+        return new PaintVoxelData(data.id, data.name, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId, data.secondaryName, data.secondaryMod, data.secondaryState);
+    }
+    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;
+    }
+    static ToRaw(data, light = 0) {
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        const id = (stringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
+            0;
+        const secondaryId = (secondaryStringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, data.secondaryState || 0, data.secondaryMod || 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];
+    }
+    constructor(id = "dve_air", name = "", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryName = "", secondaryMod = 0, secondaryState = 0) {
+        this.id = id;
+        this.name = name;
+        this.mod = mod;
+        this.state = state;
+        this.level = level;
+        this.levelState = levelState;
+        this.secondaryVoxelId = secondaryVoxelId;
+        this.secondaryName = secondaryName;
+        this.secondaryMod = secondaryMod;
+        this.secondaryState = secondaryState;
+    }
+}

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

@@ -1,6 +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;
@@ -8,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;
 }
@@ -27,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";
@@ -34,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.
  */
@@ -56,16 +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;
-    /** Named states associated with the voxel. */
+    /**Logic data for a the voxel */
+    dve_logic_data?: VoxelLogicData[];
+    /**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;
@@ -80,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,16 +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 "../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][];
     };
@@ -25,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[];
-    shapeStateTree: any[];
-    shapeStateMap: number[][];
-    shapeStateGeometryMap: number[][];
-    shapeStateRelativeGeometryMap: 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

@@ -0,0 +1,43 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { Section } from "../../../World/Section";
+import { ArchivedLightSegments } from "../Types/Archive.types";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
+declare class ProcessedData<Buffer = any> {
+    buffer: Buffer;
+    constructor(buffer: Buffer);
+    allTheSame: boolean;
+    isPaletted: boolean;
+    remapped: boolean;
+    value: number;
+}
+declare class SectionPalette {
+    voxels: NumberPalette;
+    level: NumberPalette;
+    light: LightPalette;
+    secondaryVoxels: NumberPalette;
+}
+export declare class ProcessedSection {
+    original: Section;
+    palettes: SectionPalette;
+    light: Record<ArchivedLightSegments, ProcessedData<Uint8Array>>;
+    level: ProcessedData<Uint8Array>;
+    voxels: ProcessedData<Uint16Array>;
+    secondaryVoxels: ProcessedData<Uint16Array>;
+    constructor(original: Section);
+}
+declare class LightPalette {
+    sun: NumberPalette;
+    red: NumberPalette;
+    green: NumberPalette;
+    blue: NumberPalette;
+}
+export declare class VoxelStateObjectMap {
+    palette: NumberPalette;
+    states: any[];
+}
+export declare class SectorPalette {
+    voxels: VoxelArchivePalette;
+    level: NumberPalette;
+    light: LightPalette;
+}
+export {};

package/World/Archive/Classes/ArchiveClasses.js

@@ -0,0 +1,53 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
+class ProcessedData {
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    allTheSame = true;
+    isPaletted = false;
+    remapped = false;
+    value = 0;
+}
+class SectionPalette {
+    voxels = new NumberPalette();
+    level = new NumberPalette();
+    light = new LightPalette();
+    secondaryVoxels = new NumberPalette();
+}
+export class ProcessedSection {
+    original;
+    palettes = new SectionPalette();
+    light;
+    level;
+    voxels;
+    secondaryVoxels;
+    constructor(original) {
+        this.original = original;
+        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)),
+            red: new ProcessedData(new Uint8Array(original.light.length)),
+            green: new ProcessedData(new Uint8Array(original.light.length)),
+            blue: new ProcessedData(new Uint8Array(original.light.length)),
+        };
+        this.secondaryVoxels = new ProcessedData(new Uint16Array(original.secondary.length));
+    }
+}
+class LightPalette {
+    sun = new NumberPalette();
+    red = new NumberPalette();
+    green = new NumberPalette();
+    blue = new NumberPalette();
+}
+export class VoxelStateObjectMap {
+    palette = new NumberPalette();
+    states = [];
+}
+export class SectorPalette {
+    voxels = new VoxelArchivePalette();
+    level = new NumberPalette();
+    light = new LightPalette();
+}

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

@@ -0,0 +1,31 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+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>;
+    secondary: BinaryBuffer;
+    constructor(section: ArchivedSectionData);
+}
+declare class ImportedSectionPalettes {
+    voxels?: NumberPalette;
+    level?: NumberPalette;
+    light: Record<ArchivedLightSegments, NumberPalette | null>;
+    secondaryVoxels?: NumberPalette;
+    constructor(section: ArchivedSectionData);
+}
+export declare class ImportedSection {
+    sectionIndex: number;
+    sector: ImportedSector;
+    section: ArchivedSectionData;
+    buffers: ImportedSectionBuffers;
+    palettes: ImportedSectionPalettes;
+    constructor(sectionIndex: number, sector: ImportedSector, section: ArchivedSectionData);
+    getId(index: number): number;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+}
+export {};

package/World/Archive/Classes/ImportedSection.js

@@ -0,0 +1,169 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../Util/BinaryBuffer/index";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { lightSegments, lightSemgnetSet, } from "../Functions/Shared/LightSegments";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { WorldSpaces } from "../../WorldSpaces";
+class ImportedSectionBuffers {
+    ids;
+    level;
+    light;
+    secondary;
+    constructor(section) {
+        this.ids = section.buffers.id
+            ? new BinaryBuffer(section.buffers.id)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                byteLength: WorldSpaces.section.volumne,
+                buffer: 0,
+                format: BinaryBufferFormat.Uint16,
+            }));
+        this.secondary = section.buffers.secondary
+            ? new BinaryBuffer(section.buffers.secondary)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                byteLength: WorldSpaces.section.volumne,
+                buffer: 0,
+                format: BinaryBufferFormat.Uint16,
+            }));
+        this.level = section.buffers.level
+            ? new BinaryBuffer(section.buffers.level)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                byteLength: WorldSpaces.section.volumne,
+                buffer: 0,
+                format: BinaryBufferFormat.Uint8,
+            }));
+        this.light = {
+            sun: section.buffers.light?.sun
+                ? new BinaryBuffer(section.buffers.light.sun)
+                : new BinaryBuffer(BinaryBuffer.Create({
+                    byteLength: WorldSpaces.section.volumne,
+                    buffer: 0,
+                    format: BinaryBufferFormat.NibbleArray,
+                })),
+            red: section.buffers.light?.red
+                ? new BinaryBuffer(section.buffers.light.red)
+                : new BinaryBuffer(BinaryBuffer.Create({
+                    byteLength: WorldSpaces.section.volumne,
+                    buffer: 0,
+                    format: BinaryBufferFormat.NibbleArray,
+                })),
+            green: section.buffers.light?.green
+                ? new BinaryBuffer(section.buffers.light.green)
+                : new BinaryBuffer(BinaryBuffer.Create({
+                    byteLength: WorldSpaces.section.volumne,
+                    buffer: 0,
+                    format: BinaryBufferFormat.NibbleArray,
+                })),
+            blue: section.buffers.light?.blue
+                ? new BinaryBuffer(section.buffers.light.blue)
+                : new BinaryBuffer(BinaryBuffer.Create({
+                    byteLength: WorldSpaces.section.volumne,
+                    buffer: 0,
+                    format: BinaryBufferFormat.NibbleArray,
+                })),
+        };
+    }
+}
+class ImportedSectionPalettes {
+    voxels;
+    level;
+    light;
+    secondaryVoxels;
+    constructor(section) {
+        this.voxels = section.palettes?.id
+            ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.id))
+            : undefined;
+        this.light = {
+            sun: section.palettes?.light?.sun
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.light?.sun))
+                : null,
+            red: section.palettes?.light?.red
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.light?.red))
+                : null,
+            green: section.palettes?.light?.green
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.light?.green))
+                : null,
+            blue: section.palettes?.light?.blue
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.light?.blue))
+                : null,
+        };
+        this.level = section.palettes?.level
+            ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.level))
+            : undefined;
+        this.secondaryVoxels = section.palettes?.secondary
+            ? new NumberPalette(BinaryBuffer.ToTypedArray(section.palettes?.secondary))
+            : undefined;
+    }
+}
+export class ImportedSection {
+    sectionIndex;
+    sector;
+    section;
+    buffers;
+    palettes;
+    constructor(sectionIndex, sector, section) {
+        this.sectionIndex = sectionIndex;
+        this.sector = sector;
+        this.section = section;
+        this.buffers = new ImportedSectionBuffers(section);
+        this.palettes = new ImportedSectionPalettes(section);
+    }
+    getId(index) {
+        const value = this.buffers.ids.getValue(index);
+        if (this.buffers.ids.isValue) {
+            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+        }
+        if (this.palettes.voxels) {
+            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.voxels.getValue(value)));
+        }
+        return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+    }
+    getLight(index) {
+        let finalLight = 0;
+        for (let l = 0; l < lightSegments.length; l++) {
+            const segment = lightSegments[l];
+            let value = 0;
+            if (this.buffers.light[segment].isValue) {
+                value = this.buffers.light[segment].getValue(index);
+            }
+            else {
+                if (this.buffers.light[segment].format == BinaryBufferFormat.NibbleArray) {
+                    value = this.buffers.light[segment].getValue(index);
+                }
+                else {
+                    if (this.palettes.light[segment]) {
+                        value = this.palettes.light[segment].getValue(this.buffers.light[segment].getValue(index));
+                    }
+                    else if (this.sector.palettes.light[segment]) {
+                        value = this.sector.palettes.light[segment].getValue(this.buffers.light[segment].getValue(index));
+                    }
+                }
+            }
+            finalLight = lightSemgnetSet[segment](value, finalLight);
+        }
+        return finalLight;
+    }
+    getLevel(index) {
+        const value = this.buffers.level.getValue(index);
+        if (this.palettes.level) {
+            return this.palettes.level.getValue(value);
+        }
+        if (this.sector.palettes.level) {
+            return this.sector.palettes.level.getValue(value);
+        }
+        return value;
+    }
+    getSecondary(index) {
+        const trueVoxelId = VoxelPalettesRegister.voxels[this.getId(index)][0];
+        const value = this.buffers.secondary.getValue(index);
+        if (VoxelTagsRegister.VoxelTags[trueVoxelId]["dve_can_have_secondary"]) {
+            if (this.buffers.ids.isValue) {
+                return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+            }
+            if (this.palettes.secondaryVoxels) {
+                return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.secondaryVoxels.getValue(value)));
+            }
+            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+        }
+        return value;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { ArchivedLightSegments, ArchivedSectorData } from "../Types/index";
+import { ImportedSection } from "./ImportedSection";
+import { BinarySchema } from "../../../Voxels/State/Schema/BinarySchema";
+import { VoxelPaletteArchiveReader } from "../../../Voxels/Archive/VoxelPaletteArchiveReader";
+declare class ImportedSectorPalettes {
+    voxelPalette: Uint16Array;
+    stateSchemas: Map<number, BinarySchema>;
+    modSchema: Map<number, BinarySchema>;
+    level?: NumberPalette;
+    light: Record<ArchivedLightSegments, NumberPalette | null>;
+    constructor(sector: ArchivedSectorData);
+}
+export declare class ImportedSector {
+    sector: ArchivedSectorData;
+    sections: ImportedSection[];
+    palettes: ImportedSectorPalettes;
+    voxels: VoxelPaletteArchiveReader;
+    constructor(sector: ArchivedSectorData);
+}
+export {};

package/World/Archive/Classes/ImportedSector.js

@@ -0,0 +1,50 @@
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { ImportedSection } from "./ImportedSection";
+import { BinaryBuffer } from "../../../Util/BinaryBuffer/BinaryBuffer";
+import { VoxelPaletteArchiveReader } from "../../../Voxels/Archive/VoxelPaletteArchiveReader";
+class ImportedSectorPalettes {
+    voxelPalette;
+    stateSchemas = new Map();
+    modSchema = new Map();
+    level;
+    light;
+    constructor(sector) {
+        this.voxelPalette = BinaryBuffer.ToTypedArray(sector.palettes.voxelPalette);
+        this.level = sector.palettes.level
+            ? new NumberPalette(BinaryBuffer.ToTypedArray(sector.palettes.level))
+            : undefined;
+        this.light = {
+            sun: sector.palettes.light?.sun
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(sector.palettes.light.sun))
+                : null,
+            red: sector.palettes.light?.red
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(sector.palettes.light.red))
+                : null,
+            green: sector.palettes.light?.green
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(sector.palettes.light.green))
+                : null,
+            blue: sector.palettes.light?.blue
+                ? new NumberPalette(BinaryBuffer.ToTypedArray(sector.palettes.light.blue))
+                : null,
+        };
+    }
+}
+const temp = ["", 0, 0];
+export class ImportedSector {
+    sector;
+    sections = [];
+    palettes;
+    voxels;
+    constructor(sector) {
+        this.sector = sector;
+        this.palettes = new ImportedSectorPalettes(sector);
+        this.voxels = new VoxelPaletteArchiveReader(sector.palettes);
+        for (let sectionIndex = 0; sectionIndex < sector.sections.length; sectionIndex++) {
+            const archivedSectionValue = sector.sections[sectionIndex];
+            const archivedSection = typeof archivedSectionValue == "string"
+                ? sector.duplicates?.sections?.[archivedSectionValue]
+                : archivedSectionValue;
+            this.sections[sectionIndex] = new ImportedSection(sectionIndex, this, archivedSection);
+        }
+    }
+}