@divinevoxel/vlox 0.0.76 → 0.0.78

package/Mesher/Items/MeshTexture.js

@@ -0,0 +1,214 @@
+import { QuadVerticies } from "../Geomtry/Geometry.types";
+import { Quad } from "../Geomtry/Primitives/Quad";
+import { ItemModelBuilder } from "./Models/ItemModelBuilder";
+import { addItemQuad } from "./Geomtry/ItemGeometryBuilder";
+import { Flat2DIndex } from "@amodx/math";
+import { Box } from "../Geomtry/Shapes/Box";
+import { VoxelFaces } from "../../Math";
+import { CompactItemMesh } from "./Base/CompactItemMesh";
+const { quads: Quads } = Box.Create([
+    [0, 0, 0],
+    [1, 1, 1],
+]);
+const addUvs = (quad, factor, sx, sy, ex, ey) => {
+    const uR = ex * factor;
+    const uL = sx * factor;
+    const vT = ey * factor;
+    const vB = sy * factor;
+    quad.uvs.vertices[QuadVerticies.TopRight].x = uR;
+    quad.uvs.vertices[QuadVerticies.TopRight].y = vT;
+    quad.uvs.vertices[QuadVerticies.TopLeft].x = uL;
+    quad.uvs.vertices[QuadVerticies.TopLeft].y = vT;
+    quad.uvs.vertices[QuadVerticies.BottomLeft].x = uL;
+    quad.uvs.vertices[QuadVerticies.BottomLeft].y = vB;
+    quad.uvs.vertices[QuadVerticies.BottomRight].x = uR;
+    quad.uvs.vertices[QuadVerticies.BottomRight].y = vB;
+};
+class TextureVoxelData {
+    width;
+    height;
+    textureData;
+    index = Flat2DIndex.GetXYOrder();
+    constructor(width, height, textureData) {
+        this.width = width;
+        this.height = height;
+        this.textureData = textureData;
+        this.index.setBounds(width, height);
+    }
+    inBounds(x, y) {
+        return x >= 0 && x < this.width && y >= 0 && y < this.height;
+    }
+    isSolid(x, y) {
+        if (!this.inBounds(x, y))
+            return false;
+        const a = this.textureData[this.index.getIndexXY(x, this.height - 1 - y) * 4 + 3];
+        return a > 0.01;
+    }
+}
+Quads[VoxelFaces.North].setUVs(Quad.FullUVs);
+Quads[VoxelFaces.South].setUVs(Quad.FullUVs);
+const tool = new ItemModelBuilder("dve_item");
+export function MeshTexture(textureId, textureData) {
+    const width = Math.sqrt(textureData.length / 4);
+    const height = Math.sqrt(textureData.length / 4);
+    const factor = 1 / width;
+    const data = new TextureVoxelData(width, height, textureData);
+    {
+        //south face
+        tool.vars.textureIndex = textureId;
+        addItemQuad(tool, Quads[VoxelFaces.South]);
+    }
+    {
+        //north face
+        const backPositionZ = factor;
+        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.TopRight].z =
+            backPositionZ;
+        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.TopLeft].z =
+            backPositionZ;
+        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.BottomLeft].z =
+            backPositionZ;
+        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.BottomRight].z =
+            backPositionZ;
+        tool.vars.textureIndex = textureId;
+        addItemQuad(tool, Quads[VoxelFaces.North]);
+    }
+    for (let x = 0; x < width; x++) {
+        let eastFace = null;
+        let westFace = null;
+        for (let y = 0; y < height; y++) {
+            let eastFaceExposed = true;
+            let westFaceExposed = true;
+            if (!data.isSolid(x, y)) {
+                eastFaceExposed = false;
+                westFaceExposed = false;
+            }
+            if (data.isSolid(x + 1, y)) {
+                eastFaceExposed = false;
+            }
+            if (data.isSolid(x - 1, y)) {
+                westFaceExposed = false;
+            }
+            if (eastFace && !eastFaceExposed) {
+                const x1 = x * factor + factor;
+                const y0 = eastFace[1] * factor;
+                const y1 = y * factor;
+                const z0 = 0;
+                const z1 = factor;
+                // Flip winding vs previous: (p1 <-> p3)
+                const newQuad = Quad.Create([
+                    [x1, y0, z0], // p0
+                    [x1, y0, z1], // p1 (was p3)
+                    [x1, y1, z1], // p2
+                    [x1, y1, z0], // p3 (was p1)
+                ], Quad.FullUVs, false);
+                let [sx, sy] = eastFace;
+                let ex = x + 1;
+                let ey = y;
+                addUvs(newQuad, factor, sx, sy, ex, ey);
+                eastFace = null;
+                tool.vars.textureIndex = textureId;
+                addItemQuad(tool, newQuad);
+            }
+            if (westFace && !westFaceExposed) {
+                const x0 = x * factor;
+                const y0 = westFace[1] * factor;
+                const y1 = y * factor;
+                const z0 = 0;
+                const z1 = factor;
+                // Flip winding vs previous: (p1 <-> p3)
+                const newQuad = Quad.Create([
+                    [x0, y0, z0], // p0
+                    [x0, y1, z0], // p1 (was p3)
+                    [x0, y1, z1], // p2
+                    [x0, y0, z1], // p3 (was p1)
+                ], Quad.FullUVs, false);
+                let [sx, sy] = westFace;
+                let ex = x + 1;
+                let ey = y;
+                addUvs(newQuad, factor, sx, sy, ex, ey);
+                westFace = null;
+                tool.vars.textureIndex = textureId;
+                addItemQuad(tool, newQuad);
+            }
+            const isPixel = data.isSolid(x, y);
+            if (!data.isSolid(x + 1, y) && !eastFace && isPixel) {
+                eastFace = [x, y];
+            }
+            if (!data.isSolid(x - 1, y) && !westFace && isPixel) {
+                westFace = [x, y];
+            }
+        }
+    }
+    for (let y = 0; y < height; y++) {
+        let upFace = null;
+        let downFace = null;
+        for (let x = 0; x < width; x++) {
+            let upFaceExposed = true;
+            let downFaceExposed = true;
+            if (!data.isSolid(x, y)) {
+                upFaceExposed = false;
+                downFaceExposed = false;
+            }
+            if (data.isSolid(x, y + 1)) {
+                upFaceExposed = false;
+            }
+            if (data.isSolid(x, y - 1)) {
+                downFaceExposed = false;
+            }
+            if (upFace && !upFaceExposed) {
+                const x0 = upFace[0] * factor;
+                const x1 = x * factor;
+                const y1 = y * factor + factor;
+                const z0 = 0;
+                const z1 = factor;
+                // +Y normal — CCW when viewed from +Y
+                const newQuad = Quad.Create([
+                    [x0, y1, z0], // p0
+                    [x1, y1, z0], // p1
+                    [x1, y1, z1], // p2
+                    [x0, y1, z1], // p3
+                ], Quad.FullUVs, false
+                // 0
+                );
+                let [sx, sy] = upFace;
+                let [ex, ey] = [x, y];
+                ey += 1;
+                addUvs(newQuad, factor, sx, sy, ex, ey);
+                upFace = null;
+                tool.vars.textureIndex = textureId;
+                addItemQuad(tool, newQuad);
+            }
+            if (downFace && !downFaceExposed) {
+                const x0 = downFace[0] * factor;
+                const x1 = x * factor;
+                const y0 = y * factor;
+                const z0 = 0;
+                const z1 = factor;
+                // -Y normal — flip winding relative to +Y
+                const newQuad = Quad.Create([
+                    [x0, y0, z0], // p0
+                    [x0, y0, z1], // p1
+                    [x1, y0, z1], // p2
+                    [x1, y0, z0], // p3
+                ], Quad.FullUVs, false
+                // 1
+                );
+                let [sx, sy] = downFace;
+                let [ex, ey] = [x, y];
+                ey += 1;
+                addUvs(newQuad, factor, sx, sy, ex, ey);
+                downFace = null;
+                tool.vars.textureIndex = textureId;
+                addItemQuad(tool, newQuad);
+            }
+            const isPixel = data.isSolid(x, y);
+            if (!data.isSolid(x, y + 1) && !upFace && isPixel) {
+                upFace = [x, y];
+            }
+            if (!data.isSolid(x, y - 1) && !downFace && isPixel) {
+                downFace = [x, y];
+            }
+        }
+    }
+    return CompactItemMesh([tool]);
+}

package/Mesher/Items/MeshTextureO.js

@@ -0,0 +1,277 @@
+import { Quad } from "../Geomtry/Primitives/Quad";
+const Quads = {
+    north: Quad.Create([
+        [1, 1, 0],
+        [0, 1, 0],
+        [0, 0, 0],
+        [1, 0, 0],
+    ], Quad.FullUVs),
+    south: Quad.Create([
+        [1, 1, 0],
+        [0, 1, 0],
+        [0, 0, 0],
+        [1, 0, 0],
+    ], Quad.FullUVs),
+};
+//const tool = new MesherDataTool();
+//tool.startNewMesh();
+//tool.mesh!.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
+//tool.mesh!.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
+export function MeshTexture(textureId, textureData) {
+    /*  const width = Math.sqrt(textureData.length / 4);
+     const height = Math.sqrt(textureData.length / 4);
+     const factor = 1 / width;
+   
+     const textureDataIndex = Flat2DIndex.GetXYOrder();
+     textureDataIndex.setBounds(width, height);
+   
+     const origin = Vector3Like.Create(-0.5, -0.5, -0.5);
+   
+     const isSolid = (x: number, y: number) =>
+       x >= 0 &&
+       x < width &&
+       y >= 0 &&
+       y < height &&
+       textureData[textureDataIndex.getIndexXY(x, y) * 4 + 3] > 0.01
+         ? true
+         : false;
+   
+     const uvs = tool.mesh!.getAttribute("uv");
+     const textureIndex = tool.mesh!.getAttribute("textureIndex");
+     const uvOffset = width > 16 ? -(2 / Math.max(width, height)) : 0;
+   
+     const addUvs = (sx: number, sy: number, ex: number, ey: number) => {
+       uvs.push(
+         (ex + uvOffset) * factor,
+         (ey + uvOffset) * factor,
+         (sx - uvOffset) * factor,
+         (ey + uvOffset) * factor,
+         (sx - uvOffset) * factor,
+         (sy - uvOffset) * factor,
+         (ex + uvOffset) * factor,
+         (sy - uvOffset) * factor
+       );
+       textureIndex.push(
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0
+       );
+     };
+   
+     {
+       GeometryBuilder.addQuad(tool, origin, Quads.south);
+       uvs.push(
+         Quads.south.uvs.vertices[QuadVerticies.TopRight].x,
+         Quads.south.uvs.vertices[QuadVerticies.TopRight].y,
+         Quads.south.uvs.vertices[QuadVerticies.TopLeft].x,
+         Quads.south.uvs.vertices[QuadVerticies.TopLeft].y,
+         Quads.south.uvs.vertices[QuadVerticies.BottomLeft].x,
+         Quads.south.uvs.vertices[QuadVerticies.BottomLeft].y,
+         Quads.south.uvs.vertices[QuadVerticies.BottomRight].x,
+         Quads.south.uvs.vertices[QuadVerticies.BottomRight].y
+       );
+   
+       textureIndex.push(
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0
+       );
+     }
+   
+     {
+       const backPositionZ = factor;
+       Quads.north.positions.vertices[QuadVerticies.TopRight].z = backPositionZ;
+       Quads.north.positions.vertices[QuadVerticies.TopLeft].z = backPositionZ;
+       Quads.north.positions.vertices[QuadVerticies.BottomLeft].z = backPositionZ;
+       Quads.north.positions.vertices[QuadVerticies.BottomRight].z = backPositionZ;
+       Quads.north.flip = true;
+       uvs.push(
+         Quads.north.uvs.vertices[QuadVerticies.TopLeft].x,
+         Quads.north.uvs.vertices[QuadVerticies.TopLeft].y,
+         Quads.north.uvs.vertices[QuadVerticies.TopRight].x,
+         Quads.north.uvs.vertices[QuadVerticies.TopRight].y,
+         Quads.north.uvs.vertices[QuadVerticies.BottomRight].x,
+         Quads.north.uvs.vertices[QuadVerticies.BottomRight].y,
+         Quads.north.uvs.vertices[QuadVerticies.BottomLeft].x,
+         Quads.north.uvs.vertices[QuadVerticies.BottomLeft].y
+       );
+       GeometryBuilder.addQuad(tool, origin, Quads.north);
+       textureIndex.push(
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0,
+         textureId,
+         0,
+         0
+       );
+     }
+   
+     for (let x = 0; x < width; x++) {
+       let eastFace: Vec2Array | null = null;
+       let westFace: Vec2Array | null = null;
+       for (let y = 0; y < height; y++) {
+         let eastFaceExposed = true;
+         let westFaceExposed = true;
+   
+         if (!isSolid(x, y)) {
+           eastFaceExposed = false;
+           westFaceExposed = false;
+         }
+         if (isSolid(x + 1, y)) {
+           eastFaceExposed = false;
+         }
+         if (isSolid(x - 1, y)) {
+           westFaceExposed = false;
+         }
+   
+         if (eastFace && !eastFaceExposed) {
+           const newQuad = Quad.Create(
+             [
+               [x * factor + factor, eastFace[1] * factor, 0],
+               [x * factor + factor, y * factor, factor],
+             ],
+             Quad.FullUVs as any,
+             false,
+             0
+           );
+           GeometryBuilder.addQuad(tool, origin, newQuad);
+   
+           let [sx, sy] = eastFace;
+           let ex = x;
+           let ey = y;
+           ex += 1;
+           addUvs(sx, sy, ex, ey);
+           eastFace = null;
+         }
+   
+         if (westFace && !westFaceExposed) {
+           const newQuad = Quad.Create(
+             [
+               [x * factor, westFace[1] * factor, 0],
+               [x * factor, y * factor, factor],
+             ],
+             Quad.FullUVs as any,
+             false,
+             1
+           );
+           GeometryBuilder.addQuad(tool, origin, newQuad);
+           let [sx, sy] = westFace;
+           let ex = x;
+           let ey = y;
+           ex += 1;
+           addUvs(sx, sy, ex, ey);
+           westFace = null;
+         }
+         const isPixel = isSolid(x, y);
+         if (!isSolid(x + 1, y) && !eastFace && isPixel) {
+           eastFace = [x, y];
+         }
+         if (!isSolid(x - 1, y) && !westFace && isPixel) {
+           westFace = [x, y];
+         }
+       }
+     }
+     for (let y = 0; y < height; y++) {
+       let upFace: Vec2Array | null = null;
+       let downFace: Vec2Array | null = null;
+   
+       for (let x = 0; x < width; x++) {
+         let upFaceExposed = true;
+         let downFaceExposed = true;
+   
+         if (!isSolid(x, y)) {
+           upFaceExposed = false;
+           downFaceExposed = false;
+         }
+         if (isSolid(x, y + 1)) {
+           upFaceExposed = false;
+         }
+         if (isSolid(x, y - 1)) {
+           downFaceExposed = false;
+         }
+   
+         if (upFace && !upFaceExposed) {
+           const newQuad = Quad.Create(
+             [
+               [upFace[0] * factor, y * factor + factor, 0],
+               [x * factor, y * factor + factor, factor],
+             ],
+             Quad.FullUVs as any,
+             false,
+             0
+           );
+           GeometryBuilder.addQuad(tool, origin, newQuad);
+           let [sx, sy] = upFace;
+           let [ex, ey] = [x, y];
+   
+           ey += 1;
+           addUvs(sx, sy, ex, ey);
+           upFace = null;
+         }
+   
+         if (downFace && !downFaceExposed) {
+           const newQuad = Quad.Create(
+             [
+               [downFace[0] * factor, y * factor, 0],
+               [x * factor, y * factor, factor],
+             ],
+             Quad.FullUVs as any,
+             false,
+             1
+           );
+           GeometryBuilder.addQuad(tool, origin, newQuad);
+           let [sx, sy] = downFace;
+           let [ex, ey] = [x, y];
+           ey += 1;
+           addUvs(sx, sy, ex, ey);
+           downFace = null;
+         }
+   
+         const isPixel = isSolid(x, y);
+         if (!isSolid(x, y + 1) && !upFace && isPixel) {
+           upFace = [x, y];
+         }
+         if (!isSolid(x, y - 1) && !downFace && isPixel) {
+           downFace = [x, y];
+         }
+       }
+     }
+   
+     for (const [key, [data]] of tool.mesh!.attributes) {
+       if (key == "position") {
+         for (let i = 0; i < data.length; i += 3) {
+           (data as any as number[])[i] -= 0.5;
+           (data as any as number[])[i + 1] -= 0.5;
+           (data as any as number[])[i + 2];
+         }
+       }
+     }
+   
+     const compacted = CompactMesh("dve_item", tool);
+     */
+    //  return tool.mesh;
+}

package/Mesher/Items/Models/ItemModelBuilder.d.ts

@@ -0,0 +1,27 @@
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { Vec3Array, Vector3Like } from "@amodx/math";
+declare class ItemVars {
+    textureIndex: number;
+    reset(): void;
+}
+export declare class ItemModelBuilder {
+    id: string;
+    /**The current world position */
+    position: Vector3Like;
+    /**The current local origin  */
+    origin: Vector3Like;
+    mesh: ProtoMesh;
+    vars: ItemVars;
+    bounds: {
+        min: Vec3Array;
+        max: Vec3Array;
+    };
+    _indexStart: number;
+    constructor(id: string);
+    startConstruction(): void;
+    endConstruction(): boolean;
+    _boundsUpdate: boolean;
+    updateBounds(bounds: [Vec3Array, Vec3Array]): void;
+    clear(): this;
+}
+export {};

package/Mesher/Items/Models/ItemModelBuilder.js

@@ -0,0 +1,64 @@
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { Vector3Like } from "@amodx/math";
+import { ItemMeshVertexStructCursor } from "../Geomtry/ItemMeshVertexStructCursor";
+class ItemVars {
+    textureIndex = 0;
+    reset() {
+        this.textureIndex = 0;
+    }
+}
+export class ItemModelBuilder {
+    id;
+    /**The current world position */
+    position = Vector3Like.Create();
+    /**The current local origin  */
+    origin = Vector3Like.Create();
+    mesh = new ProtoMesh(ItemMeshVertexStructCursor.VertexFloatSize);
+    vars = new ItemVars();
+    bounds = {
+        min: [0, 0, 0],
+        max: [0, 0, 0],
+    };
+    _indexStart = 0;
+    constructor(id) {
+        this.id = id;
+    }
+    startConstruction() {
+        this._indexStart = this.mesh.indicieCount;
+        this.bounds.min[0] = Infinity;
+        this.bounds.min[1] = Infinity;
+        this.bounds.min[2] = Infinity;
+        this.bounds.max[0] = -Infinity;
+        this.bounds.max[1] = -Infinity;
+        this.bounds.max[2] = -Infinity;
+        this._boundsUpdate = false;
+    }
+    endConstruction() {
+        this.vars.reset();
+        return true;
+    }
+    _boundsUpdate = false;
+    updateBounds(bounds) {
+        const origin = this.origin;
+        //min
+        if (origin.x + bounds[0][0] < this.bounds.min[0])
+            this.bounds.min[0] = origin.x + bounds[0][0];
+        if (origin.y + bounds[0][1] < this.bounds.min[1])
+            this.bounds.min[1] = origin.y + bounds[0][1];
+        if (origin.z + bounds[0][2] < this.bounds.min[2])
+            this.bounds.min[2] = origin.z + bounds[0][2];
+        //max
+        if (origin.x + bounds[1][0] > this.bounds.max[0])
+            this.bounds.max[0] = origin.x + bounds[1][0];
+        if (origin.y + bounds[1][1] > this.bounds.max[1])
+            this.bounds.max[1] = origin.y + bounds[1][1];
+        if (origin.z + bounds[1][2] > this.bounds.max[2])
+            this.bounds.max[2] = origin.z + bounds[1][2];
+        this._boundsUpdate = true;
+    }
+    clear() {
+        this.vars.reset();
+        this.mesh.clear();
+        return this;
+    }
+}

package/Mesher/Types/ItemMesh.types.d.ts

@@ -0,0 +1,5 @@
+export declare class ItemMeshTypes {
+    static vertexStrideBytes: number;
+    static vertexStrideFloats: number;
+    static VoxelMeshStructWGSL: string;
+}

package/Mesher/Types/ItemMesh.types.js

@@ -0,0 +1,12 @@
+export class ItemMeshTypes {
+    static vertexStrideBytes = 96;
+    static vertexStrideFloats = 24;
+    static VoxelMeshStructWGSL = /* wgsl */ `
+  struct ItemMeshVertex {
+    position: vec3f, 
+    normal: vec3f,     
+    uv: vec2f,    
+    textureIndex: f32,    
+  };
+      `;
+}

package/Mesher/Types/Mesher.types.d.ts

@@ -7,12 +7,18 @@ export type CompactSubMesh = [
     minBounds: Vec3Array,
     maxBounds: Vec3Array
 ];
-export type CompactMeshData = [type: 0, meshes: CompactSubMesh[]] | [
-    type: 1,
-    vertexBuffer: ArrayBuffer,
-    indexBuffer: Uint32Array,
-    bvhTreeBuffer: Float32Array,
-    bvhIndexBuffer: Uint32Array,
-    minBounds: Vec3Array,
-    maxBounds: Vec3Array
-];
+export type CompactMeshData = CompactSubMesh[];
+/**
+ * old web gpu data
+ [
+      type: 1,
+      vertexBuffer: ArrayBuffer,
+      indexBuffer: Uint32Array,
+      bvhTreeBuffer: Float32Array,
+      bvhIndexBuffer: Uint32Array,
+      minBounds: Vec3Array,
+      maxBounds: Vec3Array,
+    ];
+
+ *
+ */

package/Mesher/Types/Mesher.types.js

@@ -1 +1,15 @@
 export {};
+/**
+ * old web gpu data
+ [
+      type: 1,
+      vertexBuffer: ArrayBuffer,
+      indexBuffer: Uint32Array,
+      bvhTreeBuffer: Float32Array,
+      bvhIndexBuffer: Uint32Array,
+      minBounds: Vec3Array,
+      maxBounds: Vec3Array,
+    ];
+
+ *
+ */

package/Mesher/Types/VoxelMesh.types.js

@@ -3,12 +3,13 @@ export class VoxelMeshTypes {
     static vertexStrideFloats = 24;
     static VoxelMeshStructWGSL = /* wgsl */ `
   struct VoxelMeshVertex {
-      position: vec3f,
-      normal: vec3f,
-      voxelData: f32,
-      textureIndex: vec3f,
-      uv: vec2f,
-      colors: vec3f,
+    position: vec3f, 
+    normal: vec3f,     
+    textureIndex: vec3f,    
+    uv: vec2f,    
+    colors: vec3f,
+    voxelData: f32,    
+    _padding: vec4f
   };
       `;
 }

package/Mesher/Voxels/Base/CompactTemplateMesh.d.ts

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