@divinevoxel/vlox 0.0.78 → 0.0.80

package/Voxels/Indexes/VoxelIndex.js

@@ -1,6 +1,6 @@
 import { PaintVoxelData } from "../Types/PaintVoxelData";
-import { SchemaRegister } from "../State/SchemaRegister";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelSchemas } from "../State/VoxelSchemas";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 export class VoxelNamedState {
     voxelId;
     data;
@@ -17,28 +17,22 @@ export class VoxelNamedState {
         for (const key in data.properties) {
             this.tags.set(key, data.properties[key]);
         }
-        if (SchemaRegister.modSchemaData.has(this.voxelId)) {
-            const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
-            if (this.data.state == "*") {
-                this.compiled.stateAny = true;
-            }
-            else if (this.data.state) {
-                this.compiled.state = schema.state.readString(this.data.state);
-            }
-            if (this.data.mod == "*") {
-                this.compiled.modAny = true;
-            }
-            else if (this.data.mod) {
-                this.compiled.mod = schema.mod.readString(this.data.mod);
-            }
+        const stateSchema = VoxelSchemas.getStateSchema(this.voxelId);
+        if (this.data.state == "*") {
+            this.compiled.stateAny = true;
+        }
+        else if (this.data.state && stateSchema) {
+            this.compiled.state = stateSchema.readString(this.data.state);
         }
-        else {
+        const modSchema = VoxelSchemas.mod.get(voxelId);
+        if (this.data.mod == "*") {
             this.compiled.modAny = true;
-            this.compiled.stateAny = true;
+        }
+        else if (this.data.mod && modSchema) {
+            this.compiled.mod = modSchema.readString(this.data.mod);
         }
     }
     getPaintData() {
-        const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
         return PaintVoxelData.Create({
             id: this.voxelId,
             level: 0,
@@ -121,8 +115,8 @@ export class VoxelIndex {
     }
     getStateFromRawData(data) {
         const [id, light, secondary] = data;
-        const [trueId, state, mod] = VoxelPalettesRegister.voxels[id];
-        const conatiner = this.states.get(VoxelPalettesRegister.voxelIds.getStringId(trueId));
+        const [trueId, state, mod] = VoxelLUT.voxels[id];
+        const conatiner = this.states.get(VoxelLUT.voxelIds.getStringId(trueId));
         if (!conatiner)
             return false;
         return this.findState(conatiner, mod, state);

package/Voxels/InitVoxelData.d.ts

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

package/Voxels/InitVoxelData.js

@@ -1,112 +1,62 @@
 import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Models/Defaults/Examples";
 import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Models/Defaults/CubeVoxelGeometry";
-import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, } from "./Models/Defaults/CubeVoxelModels";
+import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, fullTextureCube, } from "./Models/Defaults/CubeVoxelModels";
 import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanel, } from "./Models/Defaults/PanelVoxelGeometry";
 import { stair } from "./Models/Defaults/StairVoxelModel";
 import { liquidGeometry, liquidModel, } from "./Models/Defaults/LiquidVoxelModel";
-import { VoxelModelRuleBuilderRegister } from "./Models/Rules/VoxelModelRuleBuilderRegister";
-import { BuildStateData } from "./Functions/BuildStateData";
-import { BuildFinalInputs } from "./Models/Rules/Functions/BuildFinalInputs";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister";
 import { simpleCrossedPannel, simpleThinPannel, simpleTransparentThinPannel, } from "./Models/Defaults/PanelVoxelModels";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
-import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
 import { VoxelTagIds } from "./Data/VoxelTag.types";
 import { BuildTagAndPaletteData as BuildTagData } from "./Functions/BuildTagData";
-import { VoxelPalettesRegister } from "./Data/VoxelPalettesRegister";
 import { VoxelLogicRegister } from "./Logic/VoxelLogicRegister";
-import { BuildPaletteData } from "./Functions/BuildPaletteData";
-import { BuildRules } from "./Models/Rules/Functions/BuildRules";
-import { VoxelTagsRegister } from "./Data/VoxelTagsRegister";
-import { farmGeomtry, farmModels } from "./Models/Defaults/FarmVoxelModels";
-function RegisterModels(data) {
-    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanel, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...farmGeomtry, ...(data.geometry || []));
-    VoxelModelRuleBuilderRegister.registerModels(simpleCube, simpleTransparentCube, simpleNoCulledCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, simpleTransparentThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...farmModels, ...(data.models || []));
-}
-function GetModelData(data) {
-    if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
-        const syncData = CacheManager.cachedData.models;
-        for (let i = 0; i < syncData.models.length; i++) {
-            const model = syncData.models[i];
-            SchemaRegister.registerModel(model.id, model.schema);
-        }
-        for (let i = 0; i < syncData.voxels.length; i++) {
-            const voxel = syncData.voxels[i];
-            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-        }
-        return syncData;
-    }
-    for (const voxel of data.voxels) {
-        const voxelData = voxel.properties["dve_model_data"];
-        if (!voxelData)
-            continue;
-        VoxelModelRuleBuilderRegister.registerVoxel(voxel.id, voxelData);
-        const model = VoxelModelRuleBuilderRegister.models.get(voxelData.id);
-        if (!model)
-            throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
-        model.voxels.set(voxel.id, voxelData);
-    }
-    const syncData = {
-        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
-        ...BuildRules(VoxelModelRuleBuilderRegister.geometryPalette),
-        geometry: [],
-        models: [],
-        voxels: [],
-    };
-    for (const [mainKey, mainGeo] of VoxelModelRuleBuilderRegister.geometry) {
-        syncData.geometry.push({
-            id: mainKey,
-            nodes: mainGeo.compiled,
-            cullingProcedure: mainGeo.data.cullingProcedure,
-        });
-    }
-    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
-        const stateData = BuildStateData(model, VoxelModelRuleBuilderRegister.geometryPalette);
-        model.stateData = stateData;
-        SchemaRegister.registerModel(mainKey, stateData.schema);
-        syncData.models.push({
-            id: mainKey,
-            effects: stateData.effects,
-            schema: stateData.schema,
-            //   geoLinkMap: stateData.geometryLinkStateMap,
-            stateMap: stateData.statePalette,
-            stateGeometryMap: stateData.stateGeometryPalette,
-            stateTree: stateData.stateTree,
-            condiotnalStateTree: stateData.condiotnalNodeStateTree,
-            condiotnalStatements: stateData.condiotnalStatements,
-            condiotnalStateMap: stateData.condiotnalStatePalette,
-            condiotnalShapeStateMap: stateData.condiotanlStatePalette,
-            condiotanlGeometryStatePalette: stateData.condiotanlGeometryStatePalette,
-            stateRelativeGeometryMap: stateData.stateRelativeGeometryMap,
-            relativeGeometryByteIndexMap: stateData.relativeGeometryByteIndexMap,
-            condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
-        });
-    }
-    /*   for (const [mainKey, geometry] of VoxelModelManager.geometry) {
-      BuildGeomtryInputs(geometry);
-    } */
-    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
-        const { stateVoxelInputs, conditionalShapeStateVoxelInputs } = BuildFinalInputs(model);
-        for (const v in stateVoxelInputs) {
-            const stateData = model.voxelModData.get(v);
-            SchemaRegister.registerVoxel(v, mainKey, stateData.modSchema);
-            syncData.voxels.push({
-                id: v,
-                materialId: VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(v)]["dve_rendered_material"] || "dve_solid",
-                modelId: mainKey,
-                modSchema: stateData.modSchema,
-                modStateTree: stateData.modStateTree,
-                baseGeometryInputMap: stateVoxelInputs[v],
-                condiotnalGeometryInputMap: conditionalShapeStateVoxelInputs[v],
-            });
-        }
-    }
-    if (CacheManager.cacheStoreEnabled) {
-        CacheManager.cachedModelData = syncData;
-    }
-    return syncData;
-}
+import { farmGeometry, farmModels } from "./Models/Defaults/FarmVoxelModels";
+import { BuildLUTs } from "./Functions/BuildLUTs";
+const geometry = [
+    cube,
+    halfDownCube,
+    halfSouthCube,
+    halfWestCube,
+    quaterCubeSouthNorth,
+    quaterCubeUpDown,
+    quaterCubeWestEast,
+    eighthCube,
+    thinPanel,
+    diagonalFlatPanelEastWest,
+    diagonalFlatPanelWestEast,
+    fencePost,
+    fenceEastWest,
+    fenceNorthsouth,
+    chainGeometry,
+    carpetGeometry,
+    candlesGeometry1,
+    candlesGeometry2,
+    candlesGeometry3,
+    candlesGeometry4,
+    liquidGeometry,
+    ...leverGeometry,
+    ...farmGeometry,
+];
+const models = [
+    simpleCube,
+    fullTextureCube,
+    simpleTransparentCube,
+    simpleNoCulledCube,
+    orientedCube,
+    simpleHalfCube,
+    pillarCube,
+    simpleThinPannel,
+    simpleTransparentThinPannel,
+    stair,
+    simpleCrossedPannel,
+    chainModel,
+    carpetModel,
+    candlesModel,
+    leverModel,
+    fence,
+    liquidModel,
+    ...farmModels,
+];
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
     const materials = [
@@ -211,9 +161,10 @@ export function InitVoxelData(data) {
         },
         ...data.voxels,
     ];
-    RegisterModels(data);
+    BuildLUTs(materials, substances, voxels, geometry, models);
     const voxelData = BuildTagData({
         voxels,
+        models,
         voxelsOverrides: {
             [VoxelTagIds.lightValue]: (value) => {
                 const v = value;
@@ -227,17 +178,9 @@ export function InitVoxelData(data) {
         substances,
         materials,
     });
-    console.warn("FINAL", structuredClone(voxelData), voxelData.data.tags.filter((_) => _["dve_substance"] == "dve_glow"));
-    let models = GetModelData(data);
-    BuildPaletteData({ models });
-    voxelData.data.palette = VoxelPalettesRegister.voxels;
-    voxelData.data.record = VoxelPalettesRegister.voxelRecord;
-    for (const id in voxelData.data.logic) {
-        VoxelLogicRegister.register(id, voxelData.data.logic[id]);
+    for (const id in voxelData.logic) {
+        VoxelLogicRegister.register(id, voxelData.logic[id]);
     }
     new VoxelIndex(data.voxels);
-    return {
-        models,
-        ...voxelData,
-    };
+    return voxelData;
 }

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelPickResult } from "../VoxelPickResult";
 import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 const epsilon = 1e-5;
 const bounds = new BoundingBox();
 export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.js

@@ -5,10 +5,10 @@ export class VoxelLogicStateType extends VoxelLogicType {
         this.keys = Object.keys(this.data.value);
     }
     run(voxel) {
-        this.voxelLogic.schema.state.startEncoding(voxel.getState());
+        this.voxelLogic.schema.startEncoding(voxel.getState());
         for (let i = 0; i < this.keys.length; i++) {
             const key = this.keys[i];
-            if (this.data.value[key] !== this.voxelLogic.schema.state.get(key)) {
+            if (this.data.value[key] !== this.voxelLogic.schema.get(key)) {
                 return false;
             }
         }

package/Voxels/Logic/Classes/VoxelLogic.d.ts

@@ -1,12 +1,12 @@
-import { VoxelSchema } from "../../State/Schema/VoxelSchema";
 import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 import { VoxelLogicData } from "../VoxelLogic.types";
 import { VoxelLogicType } from "./VoxelLogicType";
+import { BinarySchema } from "../../State/Schema/BinarySchema";
 export declare class VoxelLogic {
     voxelId: string;
     types: VoxelLogicType<any>[];
     effectedTags: Map<string, VoxelLogicType<any>[]>;
-    schema: VoxelSchema;
+    schema: BinarySchema;
     constructor(voxelId: string, data: VoxelLogicData[]);
     getTagValue(tagId: string, cursor: VoxelCursorInterface): any;
     registerEffectOnTag(tagId: string, effect: VoxelLogicType<any>): void;

package/Voxels/Logic/Classes/VoxelLogic.js

@@ -1,5 +1,5 @@
 import { VoxelLogicRegister } from "../VoxelLogicRegister";
-import { SchemaRegister } from "../../State/SchemaRegister";
+import { VoxelSchemas } from "../../State/VoxelSchemas";
 export class VoxelLogic {
     voxelId;
     types = [];
@@ -7,7 +7,7 @@ export class VoxelLogic {
     schema;
     constructor(voxelId, data) {
         this.voxelId = voxelId;
-        this.schema = SchemaRegister.getVoxelSchemas(voxelId);
+        this.schema = VoxelSchemas.getStateSchema(voxelId);
         for (const logicData of data) {
             const LogicTypeClass = VoxelLogicRegister.get(logicData.type);
             const newLogicType = new LogicTypeClass(this, logicData);

package/Voxels/Logic/VoxelLogicRegister.js

@@ -1,4 +1,4 @@
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 import { VoxelLogic } from "./Classes/VoxelLogic";
 import { VoxelLogicPoweredType } from "./Classes/Types/VoxelLogicPoweredType";
 import { VoxelLogicStateType } from "./Classes/Types/VoxelLogicStateType";
@@ -12,7 +12,7 @@ export class VoxelLogicRegister {
         return typeClass;
     }
     static register(id, logicData) {
-        const voxelId = VoxelPalettesRegister.voxelIds.getNumberId(id);
+        const voxelId = VoxelLUT.voxelIds.getNumberId(id);
         this.voxels[voxelId] = new VoxelLogic(id, logicData);
     }
     static registerType(id, logic) {

package/Voxels/Models/Defaults/CubeVoxelGeometry.d.ts

@@ -1,4 +1,4 @@
-import { VoxelGeometryData } from "../VoxelModel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
 export declare const cube: VoxelGeometryData;
 export declare const halfDownCube: VoxelGeometryData;
 export declare const halfSouthCube: VoxelGeometryData;

package/Voxels/Models/Defaults/CubeVoxelModels.d.ts

@@ -1,5 +1,6 @@
 import { VoxelModelData } from "../VoxelModel.types";
 export declare const simpleCube: VoxelModelData;
+export declare const fullTextureCube: VoxelModelData;
 export declare const simpleTransparentCube: VoxelModelData;
 export declare const simpleNoCulledCube: VoxelModelData;
 export declare const orientedCube: VoxelModelData;

package/Voxels/Models/Defaults/CubeVoxelModels.js

@@ -28,6 +28,51 @@ export const simpleCube = {
         ],
     },
 };
+export const fullTextureCube = {
+    id: "dve_full_texture_cube",
+    relationsSchema: [],
+    stateSchema: [],
+    arguments: {
+        upTex: {
+            type: "texture",
+        },
+        downTex: {
+            type: "texture",
+        },
+        northTex: {
+            type: "texture",
+        },
+        southTex: {
+            type: "texture",
+        },
+        eastTex: {
+            type: "texture",
+        },
+        westTex: {
+            type: "texture",
+        },
+    },
+    conditonalNodes: {},
+    properties: {
+        dve_placing_strategy: "*",
+        dve_full_block: true,
+    },
+    stateNodes: {
+        "*": [
+            {
+                geometryId: "dve_cube",
+                inputs: {
+                    upTex: "@upTex",
+                    downTex: "@downTex",
+                    northTex: "@northTex",
+                    southTex: "@southTex",
+                    eastTex: "@eastTex",
+                    westTex: "@westTex",
+                },
+            },
+        ],
+    },
+};
 export const simpleTransparentCube = {
     id: "dve_transparent_simple_cube",
     relationsSchema: [],

package/Voxels/Models/Defaults/Examples.d.ts

@@ -1,4 +1,5 @@
-import { VoxelGeometryData, VoxelModelData } from "../VoxelModel.types";
+import { VoxelModelData } from "../VoxelModel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
 export declare const chainGeometry: VoxelGeometryData;
 export declare const chainModel: VoxelModelData;
 export declare const carpetGeometry: VoxelGeometryData;

package/Voxels/Models/Defaults/Examples.js

@@ -404,6 +404,26 @@ export const fenceNorthsouth = {
 export const fence = {
     id: "dve_fence",
     divisor: [16, 16, 16],
+    arguments: {
+        southTex: {
+            type: "texture",
+        },
+        northTex: {
+            type: "texture",
+        },
+        eastTex: {
+            type: "texture",
+        },
+        westTex: {
+            type: "texture",
+        },
+        upTex: {
+            type: "texture",
+        },
+        downTex: {
+            type: "texture",
+        },
+    },
     relationsSchema: [
         {
             name: "same-east",
@@ -443,28 +463,8 @@ export const fence = {
         },
     ],
     stateSchema: [],
-    arguments: {
-        southTex: {
-            type: "texture",
-        },
-        northTex: {
-            type: "texture",
-        },
-        eastTex: {
-            type: "texture",
-        },
-        westTex: {
-            type: "texture",
-        },
-        upTex: {
-            type: "texture",
-        },
-        downTex: {
-            type: "texture",
-        },
-    },
     conditonalNodes: {
-        "same-south=true": [
+        "*|same-south=true": [
             {
                 geometryId: "dve_fence_north_south",
                 inputs: {
@@ -477,7 +477,7 @@ export const fence = {
                 },
             },
         ],
-        "same-north=true": [
+        "*|same-north=true": [
             {
                 geometryId: "dve_fence_north_south",
                 position: [0, 0, 10],
@@ -491,7 +491,7 @@ export const fence = {
                 },
             },
         ],
-        "same-east=true": [
+        "*|same-east=true": [
             {
                 position: [10, 0, 0],
                 geometryId: "dve_fence_east_west",
@@ -505,7 +505,7 @@ export const fence = {
                 },
             },
         ],
-        "same-west=true": [
+        "*|same-west=true": [
             {
                 geometryId: "dve_fence_east_west",
                 inputs: {
@@ -855,11 +855,11 @@ export const candlesModel = {
         {
             name: "num_candles",
             bitIndex: 0,
-            bitSize: 3,
+            bitSize: 2,
         },
         {
             name: "lit",
-            bitIndex: 3,
+            bitIndex: 2,
             bitSize: 1,
             values: ["false", "true"],
         },
@@ -1182,7 +1182,7 @@ export const leverModel = {
             },
             {
                 geometryId: "dve_lever_model",
-                position: [0, -8, -3],
+                position: [0, -2, -3],
                 rotation: [-45, 0, 0],
                 inputs: {
                     texture: "@leverTexture",
@@ -1198,7 +1198,7 @@ export const leverModel = {
             },
             {
                 geometryId: "dve_lever_model",
-                position: [0, -8, 3],
+                position: [0, -2, 3],
                 rotation: [45, 0, 0],
                 inputs: {
                     texture: "@leverTexture",

package/Voxels/Models/Defaults/FarmVoxelModels.d.ts

@@ -1,3 +1,4 @@
-import { VoxelGeometryData, VoxelModelData } from "../VoxelModel.types";
-export declare const farmGeomtry: VoxelGeometryData[];
+import { VoxelModelData } from "../VoxelModel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
+export declare const farmGeometry: VoxelGeometryData[];
 export declare const farmModels: VoxelModelData[];

package/Voxels/Models/Defaults/FarmVoxelModels.js

@@ -1,4 +1,4 @@
-const farmlandGeomtry = {
+const farmlandGeometry = {
     id: "dve_farmland",
     divisor: [16, 16, 16],
     arguments: {
@@ -152,7 +152,7 @@ const farmlandModel = {
         ],
     },
 };
-const cropGeomtry = {
+const cropGeometry = {
     id: "dve_crop",
     doNotBuildRules: true,
     cullingProcedure: {
@@ -345,5 +345,5 @@ const cropModel = {
         ],
     },
 };
-export const farmGeomtry = [farmlandGeomtry, cropGeomtry];
+export const farmGeometry = [farmlandGeometry, cropGeometry];
 export const farmModels = [farmlandModel, cropModel];

package/Voxels/Models/Defaults/LiquidVoxelModel.d.ts

@@ -1,4 +1,5 @@
-import { VoxelGeometryData, VoxelModelData } from "../VoxelModel.types";
+import { VoxelModelData } from "../VoxelModel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
 export type LiquidVoxelModelArgs = {
     stillTexture: number;
     flowTexture: number;

package/Voxels/Models/Defaults/PanelVoxelGeometry.d.ts

@@ -1,4 +1,4 @@
-import { VoxelGeometryData } from "../VoxelModel.types";
+import { VoxelGeometryData } from "../../Geometry/VoxelGeometry.types";
 export declare const diagonalFlatPanelWestEast: VoxelGeometryData;
 export declare const diagonalFlatPanelEastWest: VoxelGeometryData;
 export declare const thinPanel: VoxelGeometryData;