@divinevoxel/vlox 0.0.2 → 0.0.4

package/{VoxelModels → Models}/Input/BoxVoxelGometryInputs.js

@@ -27,7 +27,10 @@ export class BoxVoxelGometryInputs {
     static ArgIndexes = ArgIndexes;
     static CreateArgs() {
         const base = [];
-        VoxelFacesArray.forEach((_) => (base[_] = getArgs()));
+        for (let i = 0; i < VoxelFacesArray.length; i++) {
+            const face = VoxelFacesArray[i];
+            base[face] = getArgs();
+        }
         return base;
     }
 }

package/{VoxelModels → Models}/Rules/Classes/OcclusionFace.js

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-import { Quad } from "@amodx/meshing/Classes/Quad";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
 export class OcclusionFace {
     parentId;
     nodeId;
@@ -348,7 +348,7 @@ export class OcclusionQuadFace extends OcclusionFace {
         this.vertexCount = vertexCount;
         this.faceCount = faceCount;
         this._points = _points;
-        this.normals = Quad.GetQuadNormal(_points[0], _points[1], _points[2], _points[3]);
+        this.normals = Quad.GetQuadNormalLeftHanded(_points[0], _points[1], _points[2], _points[3]);
         const averageNormal = [0, 0, 0];
         for (let i = 0; i < this.normals.length; i++) {
             averageNormal[0] += this.normals[i][0];

package/Models/Rules/Classes/VoxelRulesGeometry.d.ts

@@ -0,0 +1,15 @@
+import { OcclusionFaceContainer } from "./OcclusionFace";
+import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
+import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
+import { PrcoessedVoxelGeometryData } from "../../../Voxels/VoxelSyncData";
+export declare class VoxelRuleGeometry {
+    id: string;
+    data: PrcoessedVoxelGeometryData;
+    occlusionPlane: OcclusionFaceContainer;
+    inputs: ReturnType<typeof BuildGeomtryInputs>;
+    faceCount: number;
+    vertexCount: number;
+    state: ReturnType<typeof BuildStateData>;
+    constructor(id: string, data: PrcoessedVoxelGeometryData, occlusionPlane?: OcclusionFaceContainer, inputs?: ReturnType<typeof BuildGeomtryInputs>);
+    clone(): VoxelRuleGeometry;
+}

package/{VoxelModels → Models}/Rules/Classes/VoxelRulesGeometry.js

@@ -3,30 +3,27 @@ import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
 export class VoxelRuleGeometry {
     id;
     data;
-    position;
-    scale;
-    rotation;
     occlusionPlane;
+    inputs;
     faceCount = 0;
     vertexCount = 0;
     state;
-    inputs;
-    constructor(id, data, position, scale, rotation) {
+    constructor(id, data, occlusionPlane, inputs) {
         this.id = id;
         this.data = data;
-        this.position = position;
-        this.scale = scale;
-        this.rotation = rotation;
-        if (data.ogData.doNotBuildRules !== true) {
+        if (!occlusionPlane && data.ogData.doNotBuildRules !== true) {
             this.occlusionPlane = GetOcclusionFaces(this.id, this, data.nodes);
         }
-        this.inputs = BuildGeomtryInputs(this);
+        else {
+            if (occlusionPlane)
+                this.occlusionPlane = occlusionPlane;
+        }
+        !inputs && (this.inputs = BuildGeomtryInputs(this));
     }
     clone() {
-        const newVoxel = new VoxelRuleGeometry(this.id, this.data, this.position, this.scale, this.rotation);
+        const newVoxel = new VoxelRuleGeometry(this.id, this.data, this.occlusionPlane.clone(), this.inputs);
         newVoxel.vertexCount = this.vertexCount;
         newVoxel.faceCount = this.faceCount;
-        newVoxel.occlusionPlane = this.occlusionPlane.clone();
         return newVoxel;
     }
 }

package/{VoxelModels → Models}/Rules/Classes/VoxelRulesModel.d.ts

@@ -1,5 +1,5 @@
 import { VoxelModelConstructorData, VoxelModelData } from "../../VoxelModel.types";
-import { BuildStateData } from "../Functions/BuildStateData";
+import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
 export declare class VoxelRulesModoel {
     data: VoxelModelData;
     shapeStates: Map<string, string[]>;

package/{VoxelModels → Models}/Rules/Functions/BuildGeomtryInputs.js

@@ -1,12 +1,12 @@
 import { Observable } from "@amodx/core/Observers";
 import { BoxVoxelGometryInputs } from "../../Input/BoxVoxelGometryInputs";
-import { VoxelFaceNameArray, VoxelFaceNameRecord, } from "../../../Math";
+import { VoxelFaceNameArray, VoxelFaceNameRecord } from "../../../Math";
 import { TextureManager } from "../../../Textures/TextureManager";
 import { Matrix2x2Like, AMath } from "@amodx/math";
 import { QuadVoxelGometryInputs } from "../../Input/QuadVoxelGometryInputs";
 const isArgString = (data) => {
     if (typeof data !== "string")
-        return;
+        return false;
     return data[0] == "@";
 };
 const rotationMatrix = new Map();
@@ -76,6 +76,24 @@ export function BuildGeomtryInputs(geomtry) {
     let args = [];
     for (const prcoessedNode of geomtry.data.nodes) {
         const { node, tranform } = prcoessedNode;
+        if (node.type == "custom") {
+            const newArgs = {};
+            args.push(newArgs);
+            const argsIndex = args.length - 1;
+            for (const input in node.inputs) {
+                const value = node.inputs[input];
+                if (isArgString(value)) {
+                    args[argsIndex][input] = null;
+                    getInputObserver(value).subscribe((value) => {
+                        args[argsIndex][input] = value;
+                        console.warn("set the value", value, args[argsIndex][input]);
+                    });
+                }
+                else {
+                    args[argsIndex][input] = value;
+                }
+            }
+        }
         if (node.type == "box") {
             const newArgs = BoxVoxelGometryInputs.CreateArgs();
             args.push(newArgs);

package/{VoxelModels → Models}/Rules/Functions/BuildRules.d.ts

@@ -1,5 +1,5 @@
 import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 export declare function BuildRules(main: VoxelRuleGeometry, geoPalette: StringPalette): {
     aoIndex: import("../../Indexing/VoxelAOResultsIndex").VoxelAOResultsIndexData;
     cullIndex: import("../../Indexing/VoxelFaceCullResultsIndex").VoxelFaceCullResultsIndexData;

package/{VoxelModels → Models}/Rules/Functions/GetOcclusionFaces.d.ts

@@ -1,4 +1,4 @@
 import { OcclusionFaceContainer } from "../Classes/OcclusionFace";
 import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-import { PrcoessedVoxelGeometryNodes } from "../../VoxelModelRules.types";
+import { PrcoessedVoxelGeometryNodes } from "../../../Voxels/VoxelSyncData";
 export declare function GetOcclusionFaces(parentId: string, geometry: VoxelRuleGeometry, data: PrcoessedVoxelGeometryNodes[]): OcclusionFaceContainer;

package/{VoxelModels → Models}/Rules/Functions/GetOcclusionFaces.js

@@ -2,7 +2,7 @@ import { Vector3Like } from "@amodx/math";
 import { OcclusionFlatQuadFace, OcclusionFaceContainer, OcclusionQuadFace, } from "../Classes/OcclusionFace";
 import { VoxelFaces } from "../../../Math";
 import { TransformBox, TransformQuad } from "../../Shared/Transform";
-import { Quad } from "@amodx/meshing/Classes/Quad";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
 export function GetOcclusionFaces(parentId, geometry, data) {
     const faceContainer = new OcclusionFaceContainer();
     let vertexCount = 0;

package/{VoxelModels → Models}/Rules/VoxelModelManager.d.ts

@@ -1,4 +1,4 @@
-import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";

package/{VoxelModels → Models}/Rules/VoxelModelManager.js

@@ -1,4 +1,4 @@
-import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../Util/StringPalette";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
 const addGeo = (modelId, stateId, nodes) => {
@@ -17,14 +17,16 @@ const addGeo = (modelId, stateId, nodes) => {
         newData.nodes = newData.nodes.map((_) => ({
             ..._,
             tranform: {
-                position: geoLinkNode.position,
-                scale: geoLinkNode.scale,
-                rotation: geoLinkNode.rotation,
-                rotationPivot: geoLinkNode.rotationPivot,
-                flip: geoLinkNode.flip,
+                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
+                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
+                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
+                ...(geoLinkNode.rotationPivot
+                    ? { rotationPivot: geoLinkNode.rotationPivot }
+                    : {}),
+                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
             },
         }));
-        VoxelModelManager.geometry.set(newId, new VoxelRuleGeometry(newId, newData, structuredClone(geoLinkNode.position), structuredClone(geoLinkNode.scale), structuredClone(geoLinkNode.rotation)));
+        VoxelModelManager.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
         continue;
     }
     return registred;

package/{VoxelModels → Models}/Shared/Transform.d.ts

@@ -1,4 +1,4 @@
-import { Quad } from "@amodx/meshing/Classes/Quad";
-import { VoxelGeometryTransform } from "../VoxelModelRules.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelGeometryTransform } from "../../Voxels/VoxelSyncData";
 export declare function TransformQuad(quad: Quad, transform: VoxelGeometryTransform): Quad;
 export declare function TransformBox(quads: [Quad, Quad, Quad, Quad, Quad, Quad], transform: VoxelGeometryTransform): [Quad, Quad, Quad, Quad, Quad, Quad];

package/{VoxelModels → Models}/Shared/Transform.js

@@ -1,4 +1,4 @@
-import { Quad } from "@amodx/meshing/Classes/Quad";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types";
 import { Vector3Like } from "@amodx/math";
 // Utility function to convert degrees to radians

package/{VoxelModels → Models}/VoxelModel.types.d.ts

@@ -1,16 +1,25 @@
 import { Vec2Array, Vec3Array } from "@amodx/math";
 import { QuadUVData } from "@amodx/meshing/Geometry.types";
 import { VoxelFaceNames } from "../Math";
+import { VoxelStateStringSchemaData, VoxelModelRelationsSchemaData, VoxelStateNumberSchemaData } from "../Voxels/State/State.types";
+import { VoxelEffectData } from "../Voxels/Effects/VoxelEffects.types";
+/**The model data assoicated with the actual voxel. */
 export interface VoxelModelConstructorData {
     id: string;
     modRelationSchema?: VoxelModelRelationsSchemaData[];
-    modSchema?: VoxelBinaryStringSchemaData[];
+    modSchema?: VoxelStateStringSchemaData[];
     inputs: Record<string, Record<string, any>>;
     tagOverrides?: {
         isLightSource?: Record<string, boolean>;
         lightValue?: Record<string, Vec3Array>;
     };
 }
+/**Define a custom geomtry node */
+export interface VoxelCustomGeomtryNode {
+    type: "custom";
+    id: string;
+    inputs: Record<string, any>;
+}
 export interface VoxelBoxGeometryNode {
     type: "box";
     noShade?: boolean;
@@ -78,30 +87,7 @@ export interface VoxelGeometryVector3Argument {
     min?: Vec3Array;
     max?: Vec3Array;
 }
-export interface VoxelBinaryStringSchemaData {
-    name: string;
-    type: "string";
-    values: Record<number, string>;
-}
-export interface VoxelBinaryNumberSchemaData {
-    name: string;
-    type: "number";
-    maxValue: number;
-}
-export interface SameVoxelRelationsConditionData {
-    type: "same-voxel";
-    direction: Vec3Array;
-}
-export interface AnyVoxelRelationsConditionData {
-    type: "any-voxel";
-    direction: Vec3Array;
-}
-export type VoxelModelRelationsConditionData = SameVoxelRelationsConditionData | AnyVoxelRelationsConditionData;
-export interface VoxelModelRelationsSchemaData {
-    name: string;
-    conditions: VoxelModelRelationsConditionData[];
-}
-export type VoxelGeometryNodes = VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode | VoxelRawGeometryGeometryNode;
+export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode | VoxelRawGeometryGeometryNode;
 export interface VoxelGeometryData {
     id: string;
     nodes: VoxelGeometryNodes[];
@@ -128,7 +114,8 @@ export interface VoxelGeometryLinkData extends VoxelGeometryBaseLinkData {
 export interface VoxelModelData {
     id: string;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
-    shapeStateSchema: (VoxelBinaryStringSchemaData | VoxelBinaryNumberSchemaData)[];
+    shapeStateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
+    effects?: VoxelEffectData[];
     relationsSchema: VoxelModelRelationsSchemaData[];
     shapeStatesNodes: Record<string, VoxelGeometryLinkData[]>;
     shapeStatesConditonalNodes: Record<string, VoxelGeometryLinkData[]>;

package/Renderer/Classes/ChunkMesh.d.ts

@@ -0,0 +1,10 @@
+import { ChunkMeshInterface } from "../DVEChunkMeshInterface";
+import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
+import { Vec3Array } from "@amodx/math";
+export declare class ChunkMesh {
+    location: Vec3Array;
+    meshes: Map<string, ChunkMeshInterface>;
+    effects: Map<string, VoxelEffect>;
+    constructor(location: Vec3Array);
+    dispose(): void;
+}

package/Renderer/Classes/ChunkMesh.js

@@ -0,0 +1,13 @@
+export class ChunkMesh {
+    location;
+    meshes = new Map();
+    effects = new Map();
+    constructor(location) {
+        this.location = location;
+    }
+    dispose() {
+        for (const [key, effect] of this.effects) {
+            effect.dispose();
+        }
+    }
+}

package/Renderer/Classes/MeshRegisterColumn.d.ts

@@ -0,0 +1,7 @@
+import { LocationData } from "Math";
+import { ChunkMesh } from "./ChunkMesh";
+export declare class MeshRegisterColumn {
+    location: LocationData;
+    chunks: Map<number, ChunkMesh>;
+    constructor(location: LocationData);
+}

package/Renderer/Classes/MeshRegisterColumn.js

@@ -0,0 +1,7 @@
+export class MeshRegisterColumn {
+    location;
+    chunks = new Map();
+    constructor(location) {
+        this.location = location;
+    }
+}

package/Renderer/Classes/MushRegisterRegion.d.ts

@@ -0,0 +1,4 @@
+import { MeshRegisterColumn } from "./MeshRegisterColumn";
+export declare class MushRegisterRegion {
+    columns: Map<number, MeshRegisterColumn>;
+}

package/Renderer/Classes/MushRegisterRegion.js

@@ -0,0 +1,3 @@
+export class MushRegisterRegion {
+    columns = new Map();
+}

package/Renderer/DVEChunkMeshInterface.d.ts

@@ -0,0 +1,3 @@
+export interface ChunkMeshInterface {
+    dispose(): void;
+}

package/Renderer/DVEChunkMeshes.d.ts

@@ -0,0 +1,6 @@
+import { Vec3Array } from "@amodx/math";
+import { CompactMeshData } from "../Mesher/Types/Mesher.types";
+import { ChunkMesh } from "./Classes/ChunkMesh";
+export declare abstract class DVEChunkMeshes {
+    abstract updateVertexData(chunk: ChunkMesh, position: Vec3Array, data: CompactMeshData): ChunkMesh;
+}

package/Renderer/DVEChunkMeshes.js

@@ -0,0 +1,2 @@
+export class DVEChunkMeshes {
+}

package/{Interfaces/Render/Nodes → Renderer}/DVERenderNode.types.d.ts

@@ -1,7 +1,6 @@
 import type { Vec3Array } from "@amodx/math";
-import type { URIShader } from "@amodx/uri/Shaders/Classes/URIShader";
 import type { TypedArrays } from "@amodx/binary/";
-export type DVENodeMeshAttributes = [
+export type DVEChunkMeshesAttributes = [
     id: string,
     data: TypedArrays,
     stride: number,
@@ -25,6 +24,7 @@ export type NodeMeshData = {
     materialId: string;
     boundingBoxMaxSize: Vec3Array;
     type?: string;
+    worldMesh?: boolean;
 } & NodeMeshOptions;
 export type NodeMeshOptions = {
     materialId: string;
@@ -33,7 +33,7 @@ export type NodeMeshOptions = {
 };
 export type NodeSubstanceData = {
     id: string;
-    shader: URIShader;
+    shader: string;
     material: NodeMaterialOptions;
     mesh: NodeMeshOptions;
 };

package/Renderer/DVERenderer.d.ts

@@ -0,0 +1,6 @@
+import { DivineVoxelEngineRender } from "Contexts/Render";
+import { DVEChunkMeshes } from "./DVEChunkMeshes";
+export declare abstract class DVERenderer {
+    abstract chunkMeshes: DVEChunkMeshes;
+    abstract init(dver: DivineVoxelEngineRender): Promise<void>;
+}

package/Renderer/MeshManager.d.ts

@@ -0,0 +1,11 @@
+import { RemoveChunkMeshTasks, SetChunkMeshTask } from "../Contexts/Render/Tasks/RenderTasks.types.js";
+import { LocationData } from "../Math/index.js";
+export declare class MeshManager {
+    static runningUpdate: boolean;
+    private static columnSquare;
+    private static renderCircle;
+    static removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
+    static remove(data: RemoveChunkMeshTasks): false | undefined;
+    static update(data: SetChunkMeshTask): void;
+    static removeColumn(data: LocationData): false | undefined;
+}

package/Renderer/MeshManager.js

@@ -0,0 +1,79 @@
+import { MeshRegister } from "./MeshRegister.js";
+import { DivineVoxelEngineRender } from "../Contexts/Render/DivineVoxelEngineRender.js";
+import { Square, Circle } from "@amodx/math/Shapes";
+import { Vector2Like } from "@amodx/math";
+import { WorldSpaces } from "../Data/World/WorldSpaces.js";
+import { VoxelEffectRegister } from "../Voxels/Effects/VoxelEffectRegister.js";
+const added = new Set();
+export class MeshManager {
+    static runningUpdate = false;
+    static columnSquare = new Square(Vector2Like.Create(1, 1), 16);
+    static renderCircle = new Circle(Vector2Like.Create(0.1, 1), 10);
+    static removeColumnsOutsideRadius(origion, radius) {
+        const [dimesnionId, x, y, z] = origion;
+        const dimension = MeshRegister.dimensions.get(dimesnionId);
+        if (!dimension)
+            return;
+        this.columnSquare.sideLength = WorldSpaces.column._bounds.x;
+        this.renderCircle.radius = radius;
+        this.renderCircle.center.x = origion[1];
+        this.renderCircle.center.y = origion[3];
+        dimension.forEach((region) => {
+            region.columns.forEach((column) => {
+                const location = column.location;
+                this.columnSquare.center.x = location[1];
+                this.columnSquare.center.y = location[3];
+                if (!Circle.IsSquareInsideOrTouchingCircle(this.columnSquare, this.renderCircle)) {
+                    this.removeColumn(location);
+                }
+            });
+        });
+    }
+    static remove(data) {
+        const [location, substance] = data;
+        const mesh = MeshRegister.chunk.removeMesh(location, substance);
+        if (!mesh)
+            return false;
+        mesh.dispose();
+    }
+    static update(data) {
+        const [location, chunks, effects] = data;
+        let i = chunks.length;
+        let chunk = MeshRegister.chunk.get(location);
+        if (!chunk) {
+            chunk = MeshRegister.chunk.add(location);
+        }
+        added.clear();
+        for (const [id, points] of effects) {
+            added.add(id);
+            if (!chunk.effects.has(id)) {
+                const EffectClass = VoxelEffectRegister.get(id);
+                const newEffect = new EffectClass(chunk);
+                newEffect.init();
+                newEffect.setPoints(points);
+                chunk.effects.set(id, newEffect);
+            }
+            else {
+                const effect = chunk.effects.get(id);
+                effect.setPoints(points);
+            }
+        }
+        for (const [key, effect] of chunk.effects) {
+            if (!added.has(key)) {
+                effect.dispose();
+                chunk.effects.delete(key);
+            }
+        }
+        if (data[1][0] == 0) {
+            DivineVoxelEngineRender.instance.renderer.chunkMeshes.updateVertexData(chunk, [location[1], location[2], location[3]], data[1]);
+        }
+    }
+    static removeColumn(data) {
+        const column = MeshRegister.column.remove(data);
+        if (!column)
+            return false;
+        for (const [key, chunk] of column.chunks) {
+            chunk.dispose();
+        }
+    }
+}

package/Renderer/MeshRegister.d.ts

@@ -0,0 +1,39 @@
+import { type LocationData } from "../Math/index.js";
+import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
+import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
+import { ChunkMesh } from "./Classes/ChunkMesh.js";
+import { ChunkMeshInterface } from "./DVEChunkMeshInterface.js";
+export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;
+declare class Chunk {
+    static addMesh(location: LocationData, mesh: ChunkMeshInterface, substance: string): ChunkMesh;
+    static add(location: LocationData): ChunkMesh;
+    static removeMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
+    static getMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
+    static remove(location: LocationData): false | ChunkMesh;
+    static get(location: LocationData): false | ChunkMesh;
+}
+declare class Column {
+    static add(location: LocationData): MeshRegisterColumn;
+    static remove(location: LocationData): false | MeshRegisterColumn;
+    static get(location: LocationData): false | MeshRegisterColumn | undefined;
+}
+declare class Region {
+    static add(location: LocationData): MushRegisterRegion;
+    static remove(location: LocationData): boolean;
+    static get(location: LocationData): false | MushRegisterRegion;
+}
+declare class Dimensions {
+    static add(id: string): Map<any, any>;
+    static get(id: string): Map<string, MushRegisterRegion> | undefined;
+    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: ChunkMeshInterface]>;
+    static remove(id: string): boolean;
+}
+export declare class MeshRegister {
+    static _dimensions: MeshRegisterDimensions;
+    static dimensions: typeof Dimensions;
+    static region: typeof Region;
+    static column: typeof Column;
+    static chunk: typeof Chunk;
+    static clearAll(): void;
+}
+export {};