@divinevoxel/vlox 0.0.76 → 0.0.78

package/Mesher/Geomtry/Proto/ProtoMesh.js

@@ -0,0 +1,73 @@
+import { Vector3Like } from "@amodx/math";
+import { ProtoVertexBuffer, ProtoIndiceBuffer } from "./ProtoMeshBuffer";
+export class ProtoMesh {
+    vertexFloatSize;
+    indicieCount = 0;
+    vertexCount = 0;
+    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
+    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+    buffer;
+    indices;
+    constructor(vertexFloatSize) {
+        this.vertexFloatSize = vertexFloatSize;
+        this.buffer = new ProtoVertexBuffer(vertexFloatSize, 1024);
+        this.indices = new ProtoIndiceBuffer(1024);
+    }
+    create() {
+        const totalVerticies = this.vertexCount * this.vertexFloatSize;
+        const vertexArray = new Float32Array(totalVerticies);
+        const vertexBuffers = this.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let i = 0; i < vertexBuffers.length; i++) {
+            const buffer = vertexBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                vertexArray[start] = buffer[j];
+                start++;
+                if (start > totalVerticies) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        const indiciesArray = this.indicieCount > 65535
+            ? new Uint32Array(this.indicieCount)
+            : new Uint16Array(this.indicieCount);
+        const indiceBuffers = this.indices._buffers;
+        start = 0;
+        done = false;
+        for (let i = 0; i < indiceBuffers.length; i++) {
+            const buffer = indiceBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                indiciesArray[start] = buffer[j];
+                start++;
+                if (start > this.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        return {
+            vertexArray,
+            indiciesArray,
+        };
+    }
+    addVerticies(vertexCount, indicesCount) {
+        this.vertexCount += vertexCount;
+        this.indicieCount += indicesCount;
+    }
+    clear() {
+        this.indicieCount = 0;
+        this.vertexCount = 0;
+        this.minBounds.x = Infinity;
+        this.minBounds.y = Infinity;
+        this.minBounds.z = Infinity;
+        this.maxBounds.x = -Infinity;
+        this.maxBounds.y = -Infinity;
+        this.maxBounds.z = -Infinity;
+    }
+}

package/Mesher/Geomtry/{VoxelMeshBuffers.d.ts → Proto/ProtoMeshBuffer.d.ts}

@@ -1,4 +1,4 @@
-export declare class VoxelVertexBuffer {
+export declare class ProtoVertexBuffer {
     vertexFloatSize: number;
     sectorVertexSize: number;
     _buffers: Float32Array[];
@@ -9,7 +9,7 @@ export declare class VoxelVertexBuffer {
     _index: number;
     setIndex(index: number): void;
 }
-export declare class VoxelIndiceBuffer {
+export declare class ProtoIndiceBuffer {
     sectorSize: number;
     _buffers: Uint32Array[];
     constructor(sectorSize: number, startingSectorSize?: number);

package/Mesher/Geomtry/{VoxelMeshBuffers.js → Proto/ProtoMeshBuffer.js}

@@ -1,4 +1,4 @@
-export class VoxelVertexBuffer {
+export class ProtoVertexBuffer {
     vertexFloatSize;
     sectorVertexSize;
     _buffers = [];
@@ -25,7 +25,7 @@ export class VoxelVertexBuffer {
         this.currentArray = this._buffers[bufferIndex];
     }
 }
-export class VoxelIndiceBuffer {
+export class ProtoIndiceBuffer {
     sectorSize;
     _buffers = [];
     constructor(sectorSize, startingSectorSize = 8) {

package/Mesher/Geomtry/Shapes/Box.d.ts

@@ -1,17 +1,10 @@
 import { Vec3Array } from "@amodx/math";
 import { Quad } from "../Primitives";
+import { VoxelFaces } from "../../../Math";
 type BoxPoints = [Vec3Array, Vec3Array];
-type BoxQuads = [
-    up: Quad,
-    down: Quad,
-    north: Quad,
-    south: Quad,
-    east: Quad,
-    west: Quad
-];
 export declare class Box {
     static Create(points?: BoxPoints): Box;
-    quads: BoxQuads;
+    quads: Record<VoxelFaces, Quad>;
     constructor(data: {
         points?: BoxPoints;
     });

package/Mesher/Geomtry/Shapes/Box.js

@@ -1,4 +1,5 @@
 import { Quad } from "../Primitives";
+import { VoxelFaces } from "../../../Math";
 export class Box {
     static Create(points = [
         [0, 0, 0],
@@ -23,43 +24,37 @@ export class Box {
     setPoints(points) {
         const [startX, startY, startZ] = points[0];
         const [endX, endY, endZ] = points[1];
-        //top
-        this.quads[0].setPositions([
+        this.quads[VoxelFaces.Up].setPositions([
             [endX, endY, endZ],
             [startX, endY, endZ],
             [startX, endY, startZ],
             [endX, endY, startZ],
         ]);
-        //bottom
-        this.quads[1].setPositions([
+        this.quads[VoxelFaces.Down].setPositions([
             [startX, startY, endZ],
             [endX, startY, endZ],
             [endX, startY, startZ],
             [startX, startY, startZ],
         ]);
-        //north
-        this.quads[2].setPositions([
+        this.quads[VoxelFaces.North].setPositions([
             [startX, endY, endZ],
             [endX, endY, endZ],
             [endX, startY, endZ],
             [startX, startY, endZ],
         ]);
-        //south
-        this.quads[3].setPositions([
+        this.quads[VoxelFaces.South].setPositions([
             [endX, endY, startZ],
             [startX, endY, startZ],
             [startX, startY, startZ],
             [endX, startY, startZ],
         ]);
-        //east
-        this.quads[4].setPositions([
+        this.quads[VoxelFaces.East].setPositions([
             [endX, endY, endZ],
             [endX, endY, startZ],
             [endX, startY, startZ],
             [endX, startY, endZ],
         ]);
-        //west
-        this.quads[5].setPositions([
+        this.quads[VoxelFaces.West].setPositions([
             [startX, endY, startZ],
             [startX, endY, endZ],
             [startX, startY, endZ],

package/Mesher/Geomtry/Transform/TransformBox.js

@@ -1,9 +1,11 @@
 import { QuadVerticies } from "../Geometry.types";
 import { AMath, Vector3Like } from "@amodx/math";
+import { VoxelFacesArray } from "../../../Math";
 export function TransformBox(box, transform) {
     // Collect all unique vertices from the quads
     const vertexMap = new Map();
-    for (const quad of box.quads) {
+    for (const face of VoxelFacesArray) {
+        const quad = box.quads[face];
         const vertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],
@@ -123,7 +125,8 @@ export function TransformBox(box, transform) {
         }
     }
     // Update the quads with transformed vertices
-    for (const quad of box.quads) {
+    for (const face of VoxelFacesArray) {
+        const quad = box.quads[face];
         const originalVertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],

package/Mesher/InitMesher.js

@@ -1,7 +1,7 @@
-import { RenderedMaterials } from "./Models/RenderedMaterials";
-import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
-import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
-import { VoxelConstructor } from "./Models/VoxelConstructor.js";
+import { RenderedMaterials } from "./Voxels/Models/RenderedMaterials";
+import { VoxelModelConstructorRegister } from "./Voxels/Models/VoxelModelConstructorRegister.js";
+import { LiquidGeometryNode } from "./Voxels/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
+import { VoxelConstructor } from "./Voxels/Models/VoxelConstructor.js";
 import { AOOcclusionFaceIndex } from "../Voxels/Models/Indexing/AOOcclusionFaceIndex";
 import { CulledOcclusionFaceIndex } from "../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export default function (materials, modelData) {

package/Mesher/InitTask.js

@@ -1,9 +1,9 @@
 import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
-import { MeshSection } from "./Functions/MeshSection";
+import { MeshSection } from "./Voxels/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
 import { getLocationData } from "../Util/LocationData";
-import { MeshSectionSnapShot } from "./Functions/MeshSectionSnapShot";
+import { MeshSectionSnapShot } from "./Voxels/MeshSectionSnapShot";
 import { SectionSnapShot, } from "../World/SnapShot/SectionSnapShot";
 export default function (rendererThread) {
     Threads.registerBinaryTask(TasksIds.BuildSection, (view) => {

package/Mesher/Items/Base/CompactItemMesh.d.ts

@@ -0,0 +1,3 @@
+import { CompactMeshData } from "../../Types/Mesher.types";
+import { ItemModelBuilder } from "../Models/ItemModelBuilder";
+export declare function CompactItemMesh(tools: ItemModelBuilder[], transfers?: any[]): CompactMeshData;

package/Mesher/Items/Base/CompactItemMesh.js

@@ -0,0 +1,20 @@
+export function CompactItemMesh(tools, transfers = []) {
+    const data = [];
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool.mesh.vertexCount)
+            continue;
+        const { vertexArray, indiciesArray } = tool.mesh.create();
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        data.push([
+            tool.id,
+            vertexArray,
+            indiciesArray,
+            [minBounds.x, minBounds.y, minBounds.z],
+            [maxBounds.x, maxBounds.y, maxBounds.z],
+        ]);
+        transfers.push(vertexArray.buffer, indiciesArray.buffer);
+    }
+    return data;
+}

package/Mesher/Items/Geomtry/ItemGeometryBuilder.d.ts

@@ -0,0 +1,5 @@
+import { ItemModelBuilder } from "../Models/ItemModelBuilder";
+import { Quad } from "../../Geomtry/Primitives/Quad";
+import { Triangle } from "../../Geomtry/Primitives";
+export declare function addItemTriangle(builder: ItemModelBuilder, tri: Triangle): void;
+export declare function addItemQuad(builder: ItemModelBuilder, quad: Quad): void;

package/Mesher/Items/Geomtry/ItemGeometryBuilder.js

@@ -0,0 +1,131 @@
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { ItemMeshVertexConstants } from "./ItemMeshVertexStructCursor";
+export function addItemTriangle(builder, tri) {
+    if (!builder.mesh)
+        return;
+    const origin = builder.origin;
+    const texture = builder.vars.textureIndex;
+    const topRightPos = tri.positions.vertices[0];
+    const topLeftPos = tri.positions.vertices[1];
+    const bottomLeftPos = tri.positions.vertices[2];
+    const topRightNor = tri.normals.vertices[0];
+    const topLeftNor = tri.normals.vertices[1];
+    const bottomLeftNor = tri.normals.vertices[2];
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    let sides = tri.doubleSided ? 2 : 1;
+    const baseIndex = builder.mesh.vertexCount;
+    while (sides--) {
+        const baseIndex = builder.mesh.vertexCount;
+        builder.mesh.buffer.setIndex(baseIndex);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, tri.uvs.vertices[QuadVerticies.TopRight], texture);
+        builder.mesh.buffer.setIndex(baseIndex + 1);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, tri.uvs.vertices[QuadVerticies.TopLeft], texture);
+        builder.mesh.buffer.setIndex(baseIndex + 2);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[QuadVerticies.BottomLeft], texture);
+        builder.mesh.addVerticies(3, 3);
+    }
+    if (!tri.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        index += 3;
+        indIndex += 3;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index + 3;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 1;
+    }
+    builder.vars.reset();
+}
+export function addItemQuad(builder, quad) {
+    if (!builder.mesh)
+        return;
+    const origin = builder.origin;
+    const texture = builder.vars.textureIndex;
+    const topRightPos = quad.positions.vertices[0];
+    const topLeftPos = quad.positions.vertices[1];
+    const bottomLeftPos = quad.positions.vertices[2];
+    const bottomRightPos = quad.positions.vertices[3];
+    const topRightNor = quad.normals.vertices[0];
+    const topLeftNor = quad.normals.vertices[1];
+    const bottomLeftNor = quad.normals.vertices[2];
+    const bottomRightNor = quad.normals.vertices[3];
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    const baseIndex = builder.mesh.vertexCount;
+    builder.mesh.buffer.setIndex(baseIndex);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 1);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 2);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], texture);
+    builder.mesh.buffer.setIndex(baseIndex + 3);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], texture);
+    if (!quad.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 6);
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        indIndex += 6;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 12);
+    }
+    builder.vars.reset();
+}
+function addVertex(index, array, origin, position, normal, uvs, texture) {
+    index *= ItemMeshVertexConstants.VertexFloatSize;
+    array[ItemMeshVertexConstants.PositionOffset + index] = position.x + origin.x;
+    array[ItemMeshVertexConstants.PositionOffset + index + 1] =
+        position.y + origin.y;
+    array[ItemMeshVertexConstants.PositionOffset + index + 2] =
+        position.z + origin.z;
+    array[ItemMeshVertexConstants.UVOffset + index] = uvs.x;
+    array[ItemMeshVertexConstants.UVOffset + index + 1] = uvs.y;
+    array[ItemMeshVertexConstants.NormalOffset + index] = normal.x;
+    array[ItemMeshVertexConstants.NormalOffset + index + 1] = normal.y;
+    array[ItemMeshVertexConstants.NormalOffset + index + 2] = normal.z;
+    array[ItemMeshVertexConstants.TextureIndexOffset + index] = texture;
+}

package/Mesher/Items/Geomtry/ItemMeshVertexStructCursor.d.ts

@@ -0,0 +1,48 @@
+export declare const ItemMeshVertexConstants: {
+    VertexFloatSize: number;
+    VertexByteSize: number;
+    PositionOffset: number;
+    NormalOffset: number;
+    TextureIndexOffset: number;
+    UVOffset: number;
+};
+export declare class ItemMeshVertexStructCursor {
+    static get VertexFloatSize(): number;
+    static get VertexByteSize(): number;
+    static get PositionOffset(): number;
+    static get NormalOffset(): number;
+    static get TextureIndexOffset(): number;
+    static get UVOffset(): number;
+    get positionX(): number;
+    set positionX(value: number);
+    get positionY(): number;
+    set positionY(value: number);
+    get positionZ(): number;
+    set positionZ(value: number);
+    get normalX(): number;
+    set normalX(value: number);
+    get normalY(): number;
+    set normalY(value: number);
+    get normalZ(): number;
+    set normalZ(value: number);
+    get textureIndex(): number;
+    set textureIndex(value: number);
+    get uvX(): number;
+    set uvX(value: number);
+    get uvY(): number;
+    set uvY(value: number);
+    trueIndex: number;
+    _index: number;
+    data: {
+        [index: number]: number;
+    };
+    get index(): number;
+    set index(index: number);
+    constructor(data?: Float32Array);
+    toJSON(): {
+        position: number[];
+        normal: number[];
+        textureIndex: number;
+        uv: number[];
+    };
+}

package/Mesher/Items/Geomtry/ItemMeshVertexStructCursor.js

@@ -0,0 +1,114 @@
+export const ItemMeshVertexConstants = {
+    VertexFloatSize: 12,
+    VertexByteSize: 12 * 4,
+    PositionOffset: 0,
+    NormalOffset: 4,
+    TextureIndexOffset: 8,
+    UVOffset: 10,
+};
+export class ItemMeshVertexStructCursor {
+    static get VertexFloatSize() {
+        return ItemMeshVertexConstants.VertexFloatSize;
+    }
+    static get VertexByteSize() {
+        return ItemMeshVertexConstants.VertexByteSize;
+    }
+    static get PositionOffset() {
+        return ItemMeshVertexConstants.PositionOffset;
+    }
+    static get NormalOffset() {
+        return ItemMeshVertexConstants.NormalOffset;
+    }
+    static get TextureIndexOffset() {
+        return ItemMeshVertexConstants.TextureIndexOffset;
+    }
+    static get UVOffset() {
+        return ItemMeshVertexConstants.UVOffset;
+    }
+    // position
+    get positionX() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset];
+    }
+    set positionX(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset] =
+            value;
+    }
+    get positionY() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset + 1];
+    }
+    set positionY(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset + 1] =
+            value;
+    }
+    get positionZ() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset + 2];
+    }
+    set positionZ(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.PositionOffset + 2] =
+            value;
+    }
+    // normal
+    get normalX() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset];
+    }
+    set normalX(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset] = value;
+    }
+    get normalY() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset + 1];
+    }
+    set normalY(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset + 1] =
+            value;
+    }
+    get normalZ() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset + 2];
+    }
+    set normalZ(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.NormalOffset + 2] =
+            value;
+    }
+    // texture index
+    get textureIndex() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.TextureIndexOffset];
+    }
+    set textureIndex(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.TextureIndexOffset] =
+            value;
+    }
+    // uv
+    get uvX() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.UVOffset];
+    }
+    set uvX(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.UVOffset] = value;
+    }
+    get uvY() {
+        return this.data[this.trueIndex + ItemMeshVertexStructCursor.UVOffset + 1];
+    }
+    set uvY(value) {
+        this.data[this.trueIndex + ItemMeshVertexStructCursor.UVOffset + 1] = value;
+    }
+    trueIndex = 0;
+    _index = 0;
+    data;
+    get index() {
+        return this._index;
+    }
+    set index(index) {
+        this._index = index;
+        this.trueIndex = index * ItemMeshVertexStructCursor.VertexFloatSize;
+    }
+    constructor(data) {
+        if (data)
+            this.data = data;
+    }
+    toJSON() {
+        return {
+            position: [this.positionX, this.positionY, this.positionZ],
+            normal: [this.normalX, this.normalY, this.normalZ],
+            textureIndex: this.textureIndex,
+            uv: [this.uvX, this.uvY],
+        };
+    }
+}

package/Mesher/Items/MeshTexture.d.ts

@@ -0,0 +1 @@
+export declare function MeshTexture(textureId: number, textureData: number[]): import("../Types").CompactMeshData;