@divinevoxel/vlox 0.0.71 → 0.0.73

package/Data/Structs/StructBuilder.js

@@ -1,157 +0,0 @@
-import { BinaryNumberTypes, } from "@amodx/binary/";
-import { BinaryStruct } from "@amodx/binary/";
-export class StructBuilder {
-    id;
-    dataSegment;
-    _built = false;
-    _nodeMap = new Map();
-    _stringMaps = new Map();
-    _objectMaps = new Map();
-    _defaults = new Map();
-    _initData;
-    constructor(id, dataSegment) {
-        this.id = id;
-        this.dataSegment = dataSegment;
-    }
-    addNode(node) {
-        if (Array.isArray(node)) {
-            for (const n of node) {
-                this._nodeMap.set(n.id, n);
-            }
-            return;
-        }
-        this._nodeMap.set(node.id, node);
-    }
-    getNode(id) {
-        return this._nodeMap.get(id);
-    }
-    setDefaults(tagManager) {
-        for (const [key, node] of this._nodeMap) {
-            const defaultValue = this._defaults.get(key);
-            if (!defaultValue)
-                continue;
-            tagManager.setProperty(key, Number(defaultValue));
-        }
-    }
-    hasNode(id) {
-        return this._nodeMap.has(id);
-    }
-    setNode(id, value, tagManager) {
-        const node = this.getNode(id);
-        if (!node)
-            return;
-        if (node.type == "number") {
-            tagManager.setProperty(node.id, Number(value));
-        }
-        if (node.type == "boolean") {
-            tagManager.setProperty(node.id, Number(value));
-        }
-        if (node.type == "number-array") {
-            if (!Array.isArray(value))
-                return false;
-            let i = value.length;
-            while (i--) {
-                tagManager.setArrayPropertyValue(node.id, i, value[i]);
-            }
-        }
-        if (node.type == "string-map") {
-            const data = this._stringMaps.get(node.id);
-            if (!data)
-                return false;
-            const v = String(value).trim();
-            if (data.found[v] === undefined) {
-                data.map.push(v);
-                data.found[v] = data.count;
-                data.count++;
-            }
-            tagManager.setProperty(node.id, data.found[v]);
-        }
-        if (node.type == "object-map") {
-            const data = this._objectMaps.get(node.id);
-            if (!data)
-                return false;
-            const v = JSON.stringify(value);
-            if (data.found[v] === undefined) {
-                data.map[data.count] = value;
-                data.found[v] = data.count;
-                data.count++;
-            }
-            tagManager.setProperty(node.id, data.found[v]);
-        }
-    }
-    build(totalTagIndexes = 0) {
-        const tags = new BinaryStruct(this.id);
-        for (const [key, node] of this._nodeMap) {
-            if (node.type == "number") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: node.numberType,
-                });
-                this._defaults.set(node.id, node.default);
-                continue;
-            }
-            if (node.type == "number-array") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number-array",
-                    numberType: node.numberType,
-                    length: node.length,
-                });
-                continue;
-            }
-            if (node.type == "boolean") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "boolean",
-                });
-                this._defaults.set(node.id, node.default ? 1 : 0);
-            }
-            if (node.type == "string-map") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: BinaryNumberTypes.Uint16,
-                });
-                this._stringMaps.set(node.id, {
-                    count: 0,
-                    found: {},
-                    map: [],
-                    allowedComms: node.allowedComms,
-                });
-            }
-            if (node.type == "object-map") {
-                tags.registerProperty({
-                    id: node.id,
-                    type: "typed-number",
-                    numberType: BinaryNumberTypes.Uint16,
-                });
-                this._objectMaps.set(node.id, {
-                    count: 0,
-                    found: {},
-                    map: [],
-                    allowedComms: node.allowedComms,
-                });
-            }
-        }
-        tags.init({
-            indexBufferMode: "shared",
-            numberOfIndexes: totalTagIndexes,
-        });
-        return tags;
-    }
-    getMaps() {
-        const objectMaps = {};
-        const stringMaps = {};
-        for (const [key, value] of this._stringMaps) {
-            stringMaps[key] = value.map;
-        }
-        for (const [key, value] of this._objectMaps) {
-            objectMaps[key] = value.map;
-        }
-        return {
-            objectMaps,
-            stringMaps,
-        };
-    }
-}

package/Data/Structs/StructBuilder.types.d.ts

@@ -1,30 +0,0 @@
-import type { BinaryNumberTypes } from "@amodx/binary/";
-type TagBuilderNodeBase = {
-    id: string;
-};
-type TagBuilderNumberNode = {
-    type: "number";
-    numberType: BinaryNumberTypes;
-    default: number;
-} & TagBuilderNodeBase;
-type TagBuilderNumberArrayNode = {
-    type: "number-array";
-    numberType: BinaryNumberTypes;
-    length: number;
-} & TagBuilderNodeBase;
-type TagBuilderStringMapNode = {
-    type: "string-map";
-    allowedComms: string[];
-    default?: string;
-} & TagBuilderNodeBase;
-type TagBuilderObjectMapNode = {
-    type: "object-map";
-    allowedComms: string[];
-    default?: any;
-} & TagBuilderNodeBase;
-type TagBuilderBooleanNode = {
-    type: "boolean";
-    default: boolean;
-} & TagBuilderNodeBase;
-export type TagBuilderNodes = TagBuilderNumberNode | TagBuilderNumberArrayNode | TagBuilderStringMapNode | TagBuilderBooleanNode | TagBuilderObjectMapNode;
-export {};

package/Mesher/Functions/CompactMesh.d.ts

@@ -1,2 +0,0 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
-export declare function CompactMesh(materialId: string, tool: MesherDataTool): void;

package/Mesher/Functions/CompactMesh.js

@@ -1,42 +0,0 @@
-export function CompactMesh(materialId, tool) {
-    /*   let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
-    
-      const mesh = tool.mesh!;
-      const byteRanges: [
-        byteStart: number,
-        length: number,
-        type: BinaryNumberTypes,
-      ][] = [];
-      const dataMap: CompactSubMesh = [materialId, []];
-      let totalSize = 0;
-      for (let [key, [array, stride, type]] of mesh.attributes) {
-        if (key == MeshDefaultAttributes.Indices) {
-          if (array.length > 60_000) {
-            type = BinaryNumberTypes.Uint32;
-          }
-        }
-        let current = totalSize;
-    
-        totalSize += MappedByteCounts[type] * array.length;
-        byteRanges.push([current, array.length, type]);
-        dataMap[1].push([key, array as any, stride]);
-      }
-    
-      const finalBuffer = new ArrayBuffer(totalSize);
-    
-      for (let i = 0; i < dataMap[1].length; i++) {
-        const startByte = byteRanges[i][0];
-        const length = byteRanges[i][1];
-        const type = byteRanges[i][2];
-        const newArray = new TypedArrayClassMap[type](
-          finalBuffer,
-          //@ts-ignore
-          startByte,
-          length
-        ) as Float32Array;
-        newArray.set(dataMap[1][i][0] as any as number[]);
-        dataMap[1][i][1] = newArray;
-      }
-    
-      return [0, finalBuffer, [dataMap]]; */
-}

package/Mesher/Geomtry/Buffers.js

@@ -1,81 +0,0 @@
-export class VoxelVertexBuffer {
-    vertexFloatSize;
-    sectorVertexSize;
-    _buffers = [];
-    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
-        this.vertexFloatSize = vertexFloatSize;
-        this.sectorVertexSize = sectorVertexSize;
-        const sectorSize = vertexFloatSize * sectorVertexSize;
-        for (let i = 0; i < startingSectorSize; i++) {
-            this._buffers.push(new Float32Array(sectorSize));
-        }
-        const array = this;
-        return new Proxy([], {
-            get: (target, property) => {
-                if (property == "length")
-                    return array.length;
-                if (property == "_buffers")
-                    return array._buffers;
-                const index = +property;
-                const bufferIndex = Math.floor(index / sectorSize);
-                if (!array._buffers[bufferIndex])
-                    this._buffers[bufferIndex] = new Float32Array(sectorSize);
-                const arrayIndex = index - bufferIndex * sectorSize;
-                return array._buffers[bufferIndex][arrayIndex];
-            },
-            set: (target, property, value) => {
-                if (property == "length")
-                    return false;
-                const index = +property;
-                const bufferIndex = Math.floor(index / sectorSize);
-                if (!array._buffers[bufferIndex])
-                    array._buffers[bufferIndex] = new Float32Array(sectorSize);
-                const arrayIndex = index - bufferIndex * sectorSize;
-                array._buffers[bufferIndex][arrayIndex] = value;
-                return true;
-            },
-        });
-    }
-    get length() {
-        return this._buffers.length * this.vertexFloatSize;
-    }
-}
-export class VoxelIndiceBuffer {
-    sectorSize;
-    _buffers = [];
-    constructor(sectorSize, startingSectorSize = 4) {
-        this.sectorSize = sectorSize;
-        for (let i = 0; i < startingSectorSize; i++) {
-            this._buffers.push(new Uint32Array(sectorSize));
-        }
-        const array = this;
-        return new Proxy([], {
-            get: (target, property) => {
-                if (property == "length")
-                    return array.length;
-                if (property == "_buffers")
-                    return array._buffers;
-                const index = +property;
-                const bufferIndex = Math.floor(index / sectorSize);
-                if (!array._buffers[bufferIndex])
-                    this._buffers[bufferIndex] = new Uint32Array(sectorSize);
-                const arrayIndex = index - bufferIndex * sectorSize;
-                return array._buffers[bufferIndex][arrayIndex];
-            },
-            set: (target, property, value) => {
-                if (property == "length")
-                    return false;
-                const index = +property;
-                const bufferIndex = Math.floor(index / sectorSize);
-                if (!array._buffers[bufferIndex])
-                    array._buffers[bufferIndex] = new Uint32Array(sectorSize);
-                const arrayIndex = index - bufferIndex * sectorSize;
-                array._buffers[bufferIndex][arrayIndex] = value;
-                return true;
-            },
-        });
-    }
-    get length() {
-        return this._buffers.length * this.sectorSize;
-    }
-}

package/Mesher/Geomtry/GeometryNormals.d.ts

@@ -1,10 +0,0 @@
-import type { Vec3Array } from "@amodx/math";
-export declare class GeometryNormals {
-    static subtract(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static cross(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static scale(v: Vec3Array, scaleFactor: number): Vec3Array;
-    static add(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static normalize(v: Vec3Array): Vec3Array;
-    static getTriangleNormals(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array): Vec3Array;
-    static getQuadNormal(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
-}

package/Mesher/Geomtry/GeometryNormals.js

@@ -1,52 +0,0 @@
-export class GeometryNormals {
-    static subtract(v1, v2) {
-        return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
-    }
-    static cross(v1, v2) {
-        return [
-            v1[1] * v2[2] - v1[2] * v2[1],
-            v1[2] * v2[0] - v1[0] * v2[2],
-            v1[0] * v2[1] - v1[1] * v2[0],
-        ];
-    }
-    static scale(v, scaleFactor) {
-        return [v[0] * scaleFactor, v[1] * scaleFactor, v[2] * scaleFactor];
-    }
-    static add(v1, v2) {
-        return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
-    }
-    static normalize(v) {
-        const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-        return length > 0
-            ? [v[0] / length, v[1] / length, v[2] / length]
-            : [0, 0, 0];
-    }
-    static getTriangleNormals(p1, p2, p3) {
-        const a = this.subtract(p2, p1);
-        const b = this.subtract(p3, p1);
-        const substract = this.cross(a, b);
-        const normal = this.scale(substract, -1);
-        return this.normalize(normal);
-    }
-    static getQuadNormal(p1, p2, p3, p4) {
-        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
-        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const normalA = this.normalize(this.cross(vectorA1, vectorA2));
-        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
-        const normalB = this.normalize(this.cross(vectorB1, vectorB2));
-        const n1 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n2 = normalA;
-        const n3 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n4 = normalB;
-        return [n1, n2, n3, n4];
-    }
-}

package/Mesher/Geomtry/MeshData.types.d.ts

@@ -1,13 +0,0 @@
-import type { TypedArrays } from "@amodx/binary";
-export declare enum MeshDefaultAttributes {
-    Position = "position",
-    Normal = "normal",
-    Indices = "indices"
-}
-export type MeshAttributes = [
-    id: string,
-    data: TypedArrays,
-    stride: number,
-    componentTypes?: number,
-    noramlizer?: number
-][];

package/Mesher/Geomtry/MeshData.types.js

@@ -1,6 +0,0 @@
-export var MeshDefaultAttributes;
-(function (MeshDefaultAttributes) {
-    MeshDefaultAttributes["Position"] = "position";
-    MeshDefaultAttributes["Normal"] = "normal";
-    MeshDefaultAttributes["Indices"] = "indices";
-})(MeshDefaultAttributes || (MeshDefaultAttributes = {}));

package/Mesher/Geomtry/Tools/MesherDataTools.d.ts

@@ -1,7 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export declare class MesherDataTool {
-    segments: Map<string, number[]>;
-    mesh: VoxelMesh | null;
-    startNewMesh(mesh?: VoxelMesh): void;
-    resetAll(): this;
-}

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -1,12 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export class MesherDataTool {
-    segments = new Map();
-    mesh = null;
-    startNewMesh(mesh) {
-        this.mesh = mesh ? mesh : new VoxelMesh();
-    }
-    resetAll() {
-        this.mesh?.clear();
-        return this;
-    }
-}

package/Mesher/Geomtry/Tools/index.d.ts

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/Geomtry/Tools/index.js

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/RenderedMaterials.d.ts

@@ -1,6 +0,0 @@
-import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
-export declare class RenderedMaterials {
-    static meshersMap: Map<string, VoxelMesherDataTool>;
-    static meshers: VoxelMesherDataTool[];
-    static register(materials: string[]): void;
-}

package/Models/Rules/VoxelModelManager.js

@@ -1,82 +0,0 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
-import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-const addGeo = (modelId, stateId, nodes) => {
-    const registred = [];
-    for (const geoLinkNode of nodes) {
-        const geo = VoxelModelManager.geometry.get(geoLinkNode.geometryId);
-        if (!geo)
-            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
-        const newId = getGeometryLinkId(geoLinkNode);
-        if (VoxelModelManager.geometry.has(newId))
-            continue;
-        registred.push([stateId, newId]);
-        if (!VoxelModelManager.geometryPalette.isRegistered(newId))
-            VoxelModelManager.geometryPalette.register(newId);
-        const newData = structuredClone(geo.data);
-        newData.nodes = newData.nodes.map((_) => ({
-            ..._,
-            tranform: {
-                ...(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));
-        continue;
-    }
-    return registred;
-};
-const getGeometryLinkId = (node) => {
-    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
-};
-export class VoxelModelManager {
-    static geometryPalette = new StringPalette();
-    static getGeometryLinkId = getGeometryLinkId;
-    static voxels = new Map();
-    static geometry = new Map();
-    static models = new Map();
-    static registerGeometry(...geometry) {
-        for (const geo of geometry) {
-            if (!this.geometryPalette.isRegistered(geo.id))
-                this.geometryPalette.register(geo.id);
-            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
-                ogData: geo,
-                id: geo.id,
-                nodes: geo.nodes.map((node) => ({
-                    node,
-                    tranform: {},
-                })),
-            }));
-        }
-    }
-    static getGeomtryFromLink(link) {
-        return this.geometry.get(getGeometryLinkId(link));
-    }
-    static registerModels(...models) {
-        for (const model of models) {
-            const rulesModel = new VoxelRulesModoel(model);
-            this.models.set(model.id, rulesModel);
-            for (const stateId in model.shapeStatesNodes) {
-                const nodes = model.shapeStatesNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
-            }
-            for (const stateId in model.shapeStatesConditonalNodes) {
-                const nodes = model.shapeStatesConditonalNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
-            }
-        }
-    }
-    static registerVoxel(id, data) {
-        let voxelModels = this.voxels.get(data.id);
-        if (!voxelModels) {
-            voxelModels = [];
-            this.voxels.set(data.id, voxelModels);
-        }
-        voxelModels.push({ id, data });
-    }
-}

package/Textures/TextureAnimations.d.ts

@@ -1,4 +0,0 @@
-import type { TextureArray } from "./TextureArray";
-export declare const TextureAnimationCreator: {
-    createAnimations(texture: TextureArray): void;
-};

package/Textures/TextureAnimations.js

@@ -1,35 +0,0 @@
-export const TextureAnimationCreator = {
-    createAnimations(texture) {
-        if (!texture.paths.size)
-            return;
-        const animaitonUniform = [];
-        let i = 0;
-        for (const anim of texture.animationsMap) {
-            animaitonUniform[anim[0]] = anim[0];
-            let keyCounts = [];
-            const animTime = texture.animationTimes[i];
-            if (animTime.length == 1) {
-                for (let k = 0; k < anim.length; k++) {
-                    keyCounts.push(animTime[0]);
-                }
-            }
-            else {
-                keyCounts = texture.animationTimes[i];
-            }
-            texture.animations.push({
-                uniformIndex: anim[0],
-                keys: anim,
-                currentFrame: 0,
-                currentCount: 0,
-                keyCounts: keyCounts,
-            });
-            i++;
-        }
-        for (let i = 0; i < texture.totalTextures; i++) {
-            if (!animaitonUniform[i]) {
-                animaitonUniform[i] = 0;
-            }
-        }
-        texture.animationUniform = new Float32Array(animaitonUniform);
-    },
-};

package/Textures/TextureArray.d.ts

@@ -1,47 +0,0 @@
-import type { TextureData } from "./Texture.types";
-export declare class TextureArray {
-    id: string;
-    extension: string;
-    totalTextures: number;
-    textureMap: Map<string, TextureData>;
-    textures: TextureData[];
-    textureIndex: Record<string, number>;
-    animationsMap: number[][];
-    animationTimes: number[][];
-    animations: {
-        uniformIndex: number;
-        overlay?: boolean;
-        keys: number[];
-        currentFrame: number;
-        currentCount: number;
-        keyCounts: number[];
-    }[];
-    varyingID: string;
-    animationUniforID: string;
-    animationUniform: Float32Array;
-    paths: Map<string, HTMLImageElement | string | false>;
-    images: HTMLImageElement[];
-    shaderTexture: any | null;
-    textureID: string;
-    attributeID: string;
-    constructor(id: string);
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData(): void;
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush(): void;
-    flushAll(): void;
-    build(): Promise<void>;
-    getTextureIndex(textureId: string, varation?: string): number;
-    addTexture(data: TextureData): void;
-    runAnimations(): void;
-    getTextureIndexMap(): Record<string, number>;
-    _processVariations(textureData: TextureData, paths: Map<string, HTMLImageElement | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
-    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
-    buildTextureIndex(): false | undefined;
-}