@divinevoxel/vlox 0.0.4 → 0.0.6

package/Mesher/Functions/CompactVoxelMesh.js

@@ -1,111 +1,119 @@
-import { MeshDefaultAttributes, } from "@amodx/meshing/MeshData.types";
-import { EngineSettings } from "../../Settings/EngineSettings";
-import { BinaryNumberTypes, TypedArrayClassMap, MappedByteCounts, } from "@amodx/binary";
-import { VoxelMeshTypes } from "../../Mesher/Types/VoxelMesh.types";
-import { Vector3Like } from "@amodx/math";
 import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
-/**
-struct VoxelMeshVertex {
-    position: vec3<f32>,
-    normal: vec3<f32>,
-    voxelData: f32,
-    textureIndex: vec3<f32>,
-    uv: vec2<f32>,
-    colors: vec3<f32>,
-};
- */
 const structCursor = new VoxelMeshVertexStructCursor();
-function MakeWebGPUMesh(tool) {
-    const mesh = tool.mesh;
-    const positions = mesh.attributes.get(MeshDefaultAttributes.Position)[0];
-    const normals = mesh.attributes.get(MeshDefaultAttributes.Normal)[0];
-    const voxelData = mesh.attributes.get("voxelData")[0];
-    const textureIndex = mesh.attributes.get("textureIndex")[0];
-    const uv = mesh.attributes.get("uv")[0];
-    const colors = mesh.attributes.get("colors")[0];
-    const indices = mesh.attributes.get(MeshDefaultAttributes.Indices)[0];
-    const numVertices = positions.length / 3;
-    // Create the vertex buffer
-    const finalBuffer = new ArrayBuffer(numVertices * VoxelMeshTypes.vertexStrideBytes);
-    const vertexData = new Float32Array(finalBuffer);
-    structCursor.data = vertexData;
-    for (let i = 0; i < numVertices; i++) {
-        structCursor.index = i;
-        structCursor.positionX = positions[i * 3];
-        structCursor.positionY = positions[i * 3 + 1];
-        structCursor.positionZ = positions[i * 3 + 2];
-        structCursor.normalX = normals[i * 3];
-        structCursor.normalY = normals[i * 3 + 1];
-        structCursor.normalZ = normals[i * 3 + 2];
-        structCursor.voxelData = voxelData[i];
-        structCursor.textureIndexX = textureIndex[i * 3];
-        structCursor.textureIndexY = textureIndex[i * 3 + 1];
-        structCursor.textureIndexZ = textureIndex[i * 3 + 2];
-        structCursor.uvX = uv[i * 2];
-        structCursor.uvY = uv[i * 2 + 1];
-        structCursor.colorR = colors[i * 3];
-        structCursor.colorG = colors[i * 3 + 1];
-        structCursor.colorB = colors[i * 3 + 2];
-    }
-    const indexData = new Uint32Array(indices);
-    for (let i = 0; i < tool.bvhTool.tree.length; i++) {
-        if (tool.bvhTool.tree[i] == -Infinity)
-            tool.bvhTool.tree[i] = -1;
-    }
-    return [
-        1,
-        finalBuffer,
-        indexData,
-        tool.bvhTool.tree.slice(0),
-        tool.bvhTool.indices.slice(0),
-        Vector3Like.ToArray(mesh.minBounds),
-        Vector3Like.ToArray(mesh.maxBounds),
-    ];
-}
-export function CompactVoxelMesh(...tools) {
-    if (EngineSettings.settings.rendererSettings.mode == "webgpu") {
-        throw new Error("WebGPU disabled right now");
-        //    return MakeWebGPUMesh(tool);
-    }
-    const dataMap = [];
-    let totalSize = 0;
-    for (const tool of tools) {
-        const mesh = tool.mesh;
-        const subMesh = [tool.id, []];
-        for (let [key, [array, stride, type]] of mesh.attributes) {
-            if (key == MeshDefaultAttributes.Indices) {
-                if (array.length > 60_000) {
-                    type = BinaryNumberTypes.Uint32;
+/*
+function MakeWebGPUMesh(tool: VoxelMesherDataTool): CompactMeshData {
+  const mesh = tool.mesh!;
+
+  const positions = mesh.attributes.get(MeshDefaultAttributes.Position)![0];
+  const normals = mesh.attributes.get(MeshDefaultAttributes.Normal)![0];
+  const voxelData = mesh.attributes.get("voxelData")![0];
+  const textureIndex = mesh.attributes.get("textureIndex")![0];
+  const uv = mesh.attributes.get("uv")![0];
+  const colors = mesh.attributes.get("colors")![0];
+  const indices = mesh.attributes.get(MeshDefaultAttributes.Indices)![0];
+
+  const numVertices = positions.length / 3;
+
+  // Create the vertex buffer
+  const finalBuffer = new ArrayBuffer(
+    numVertices * VoxelMeshTypes.vertexStrideBytes
+  );
+  const vertexData = new Float32Array(finalBuffer);
+  structCursor.data = vertexData;
+  for (let i = 0; i < numVertices; i++) {
+    structCursor.index = i;
+
+    structCursor.positionX = positions[i * 3];
+    structCursor.positionY = positions[i * 3 + 1];
+    structCursor.positionZ = positions[i * 3 + 2];
+
+    structCursor.normalX = normals[i * 3];
+    structCursor.normalY = normals[i * 3 + 1];
+    structCursor.normalZ = normals[i * 3 + 2];
+
+    structCursor.voxelData = voxelData[i];
+
+    structCursor.textureIndexX = textureIndex[i * 3];
+    structCursor.textureIndexY = textureIndex[i * 3 + 1];
+    structCursor.textureIndexZ = textureIndex[i * 3 + 2];
+
+    structCursor.uvX = uv[i * 2];
+    structCursor.uvY = uv[i * 2 + 1];
+
+    structCursor.colorR = colors[i * 3];
+    structCursor.colorG = colors[i * 3 + 1];
+    structCursor.colorB = colors[i * 3 + 2];
+  }
+
+  const indexData = new Uint32Array(indices);
+  for (let i = 0; i < tool.bvhTool.tree.length; i++) {
+    if (tool.bvhTool.tree[i] == -Infinity) tool.bvhTool.tree[i] = -1;
+  }
+
+  return [
+    1,
+    finalBuffer,
+    indexData,
+    tool.bvhTool.tree.slice(0),
+    tool.bvhTool.indices.slice(0),
+    Vector3Like.ToArray(mesh.minBounds),
+    Vector3Like.ToArray(mesh.maxBounds),
+  ];
+} */
+export function CompactVoxelMesh(tools) {
+    const data = [0, []];
+    const transfers = [];
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool.mesh.buffer.length)
+            continue;
+        const totalVerticies = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
+        const vertexArray = new Float32Array(totalVerticies);
+        const vertexBuffers = tool.mesh.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;
                 }
             }
-            let current = totalSize;
-            totalSize += MappedByteCounts[type] * array.length;
-            subMesh[1].push([
-                key,
-                mesh.attributes.get(key)[0],
-                array.length,
-                current,
-                totalSize,
-                stride,
-                type,
-            ]);
+            if (done)
+                break;
         }
-        for (let i = 0; i < tool.bvhTool.tree.length; i++) {
-            if (tool.bvhTool.tree[i] == -Infinity)
-                tool.bvhTool.tree[i] = -1;
-        }
-        dataMap.push(subMesh);
-    }
-    const finalBuffer = new ArrayBuffer(totalSize);
-    for (let subMesh of dataMap) {
-        for (const data of subMesh[1]) {
-            const [id, n, length, startByte, endByte, stride, type] = data;
-            const newArray = new TypedArrayClassMap[type](finalBuffer, 
-            //@ts-ignore
-            startByte, length);
-            newArray.set(n);
-            data[1] = newArray;
+        const indiciesArray = tool.mesh.indicieCount > 65535
+            ? new Uint32Array(tool.mesh.indicieCount)
+            : new Uint16Array(tool.mesh.indicieCount);
+        const indiceBuffers = tool.mesh.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 > tool.mesh.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
         }
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        data[1].push([
+            tool.id,
+            vertexArray,
+            indiciesArray,
+            [minBounds.x, minBounds.y, minBounds.z],
+            [maxBounds.x, maxBounds.y, maxBounds.z],
+        ]);
+        transfers.push(vertexArray.buffer, indiciesArray.buffer);
     }
-    return [0, finalBuffer, dataMap];
+    return [data, transfers];
 }

package/Mesher/Functions/MeshSection.d.ts

@@ -0,0 +1,3 @@
+import { LocationData } from "../../Math";
+import type { SetSectionMeshTask } from "../../Renderer/Renderer.types.js";
+export declare function MeshSection(location: LocationData): [task: SetSectionMeshTask, transfers: any[]] | null;

package/Mesher/Functions/MeshSection.js

@@ -0,0 +1,117 @@
+//data
+import { WorldSpaces } from "../../World/WorldSpaces.js";
+//tools
+import { VoxelGeometryLookUp, } from "../Models/VoxelGeometryLookUp.js";
+import { CompactVoxelMesh } from "./CompactVoxelMesh.js";
+import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
+import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
+import { RenderedMaterials } from "../RenderedMaterials";
+import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+import { SectionHeightMap } from "../../World/Section/SectionHeightMap.js";
+import { WorldRegister } from "../../World/WorldRegister.js";
+import { VoxelMeshBVHBuilder } from "../Tools/VoxelMeshBVHBuilder";
+import { Vector3Like } from "@amodx/math";
+const sectionCursor = new SectionCursor();
+const worldCursor = new WorldCursor();
+let space;
+const bvhTool = new VoxelMeshBVHBuilder();
+function process(x, y, z) {
+    const voxel = sectionCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    if (!voxel.isRenderable())
+        return false;
+    if (voxel.hasSecondaryVoxel()) {
+        voxel.setSecondary(true);
+        meshVoxel(x, y, z, voxel);
+        voxel.setSecondary(false);
+    }
+    meshVoxel(x, y, z, voxel);
+    return true;
+}
+function meshVoxel(x, y, z, voxel) {
+    const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
+    if (!constructor) {
+        throw new Error(`Could not find constructor ${voxel.getId()} | ${voxel.getName()} `);
+    }
+    const mesher = RenderedMaterials.meshers[voxel.getRenderedMaterial()];
+    if (!mesher) {
+        throw new Error(`Could not find material for ${voxel.getId()} | ${voxel.getName()} | ${constructor?.id} | ${voxel.getMaterial()} | ${voxel.getRenderedMaterialStringId()}`);
+    }
+    mesher.origin.x = sectionCursor._voxelPosition.x;
+    mesher.origin.y = sectionCursor._voxelPosition.y;
+    mesher.origin.z = sectionCursor._voxelPosition.z;
+    mesher.position.x = x;
+    mesher.position.y = y;
+    mesher.position.z = z;
+    mesher.voxel = voxel;
+    mesher.nVoxel = worldCursor;
+    mesher.startConstruction();
+    constructor.process(mesher);
+    mesher.endConstruction();
+    mesher.reset();
+}
+const padding = Vector3Like.Create(5, 5, 5);
+export function MeshSection(location) {
+    if (!space)
+        space = VoxelGeometryLookUp.createSpace(WorldSpaces.section.bounds.x + padding.x, WorldSpaces.section.bounds.y + padding.y, WorldSpaces.section.bounds.z + padding.z);
+    const [dimension, cx, cy, cz] = location;
+    const sector = WorldRegister.sectors.get(dimension, cx, cy, cz);
+    if (!sector)
+        return null;
+    const section = sector.getSection(cy);
+    SectionHeightMap.setSection(section);
+    worldCursor.setFocalPoint(...location);
+    sectionCursor.setSection(...location);
+    let [minY, maxY] = SectionHeightMap.getMinMax();
+    const maxX = WorldSpaces.section.bounds.x;
+    const maxZ = WorldSpaces.section.bounds.z;
+    if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+        return null;
+    space.start(cx - padding.x, cy - padding.y, cz - padding.z);
+    VoxelGeometryLookUp.start(space);
+    bvhTool.reset();
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        RenderedMaterials.meshers[i].bvhTool = bvhTool;
+    }
+    for (let y = minY; y <= maxY; y++) {
+        let foundVoxels = false;
+        if (!SectionHeightMap.getVoxel(y) && !SectionHeightMap.getDirty(y))
+            continue;
+        for (let x = 0; x < maxX; x++) {
+            for (let z = 0; z < maxZ; z++) {
+                let found = process(x + cx, y + cy, z + cz);
+                if (found)
+                    foundVoxels = true;
+            }
+        }
+        SectionHeightMap.setVoxel(y, foundVoxels);
+        SectionHeightMap.setDirty(y, false);
+    }
+    VoxelGeometryLookUp.stop();
+    const transfers = [];
+    const sectionEffects = [];
+    const sections = [location, [], sectionEffects, 0];
+    const meshed = [];
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        const mesher = RenderedMaterials.meshers[i];
+        for (const e in mesher.effects) {
+            const float = Float32Array.from(mesher.effects[e]);
+            transfers.push(float.buffer);
+            sectionEffects.push([e, float]);
+        }
+        if (!mesher.mesh.vertexCount) {
+            mesher.resetAll();
+            mesher.bvhTool = null;
+            continue;
+        }
+        meshed.push(mesher);
+    }
+    const [compactMesh, buffers] = CompactVoxelMesh(meshed);
+    sections[1] = compactMesh;
+    for (let i = 0; i < meshed.length; i++) {
+        meshed[i].resetAll();
+        meshed[i].bvhTool = null;
+    }
+    return [sections, [...transfers, ...buffers]];
+}

package/Mesher/Functions/MeshTexture.d.ts

@@ -0,0 +1 @@
+export declare function MeshTexture(textureId: number, textureData: number[]): import("../Geomtry/VoxelMesh").VoxelMesh | null;

package/Mesher/Functions/MeshTexture.js

@@ -0,0 +1,275 @@
+import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
+import { Quad } from "../Geomtry/Primitives/Quad";
+const Quads = {
+    north: Quad.Create([
+        [0, 0, 0],
+        [1, 1, 0],
+    ], Quad.FullUVs, false, 1),
+    south: Quad.Create([
+        [0, 0, 0],
+        [1, 1, 0],
+    ], Quad.FullUVs, false, 0),
+};
+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_node", tool);
+     */
+    return tool.mesh;
+}

package/Mesher/Functions/MeshVoxel.d.ts

@@ -0,0 +1,3 @@
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
+import { CompactMeshData } from "Mesher/Types";
+export declare function MeshVoxel(rawVoxelData: RawVoxelData): [mesh: CompactMeshData, tranfers: any[]] | false;

package/Mesher/Functions/MeshVoxel.js

@@ -0,0 +1,44 @@
+import { RenderedMaterials } from "../RenderedMaterials";
+import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
+import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
+import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
+import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
+import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+const templateCursor = new TemplateCursor();
+const voxelCursor = new VoxelCursor();
+templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
+const space = VoxelGeometryLookUp.createSpace(3, 3, 3);
+export function MeshVoxel(rawVoxelData) {
+    const voxel = templateCursor.getVoxel(1, 1, 1);
+    voxel.copyRaw(rawVoxelData);
+    voxel.process();
+    if (!voxel.isRenderable())
+        return false;
+    const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
+    if (!constructor) {
+        throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
+    }
+    const mesher = RenderedMaterials.meshersMap.get(voxel.getRenderedMaterialStringId());
+    if (!mesher) {
+        throw new Error(`Could not find material mesh for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
+    }
+    mesher.bvhTool = null;
+    mesher.resetAll();
+    VoxelGeometryLookUp.start(space);
+    mesher.origin.x = -0.5;
+    mesher.origin.y = -0.5;
+    mesher.origin.z = -0.5;
+    mesher.position.x = 1;
+    mesher.position.y = 1;
+    mesher.position.z = 1;
+    mesher.voxel = voxelCursor.copy(voxel);
+    mesher.nVoxel = templateCursor;
+    constructor.process(mesher);
+    mesher.reset();
+    VoxelGeometryLookUp.stop();
+    const compacted = CompactVoxelMesh([mesher]);
+    mesher.reset();
+    mesher.mesh.clear();
+    return compacted;
+}