@divinevoxel/vlox 0.0.75 → 0.0.77

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;

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 {};