@divinevoxel/vlox 0.0.75 → 0.0.77

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.js

@@ -1,5 +1,6 @@
 import { VoxelTickUpdateRegister } from "../VoxelTickUpdateRegister";
 import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+import { VoxelFaces } from "../../../../Math";
 const floodOutChecks = [
     [1, 0, 0],
     [-1, 0, 0],
@@ -56,7 +57,7 @@ VoxelTickUpdateRegister.registerType({
         const currentLevel = voxel.getLevel();
         const levelState = voxel.getLevelState();
         if (levelState == 1 && currentLevel < 7) {
-            voxel.setLevel(currentLevel + 1);
+            voxel.setLevel(7);
             voxel.updateVoxel(0);
             simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
             simulation.bounds.updateDisplay(x, y, z);
@@ -83,9 +84,7 @@ VoxelTickUpdateRegister.registerType({
                 downVoxel.getLevelState() == 1) {
                 simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
             }
-            voxel.setAir();
-            voxel.setLevel(0);
-            voxel.updateVoxel(1);
+            simulation.brush.setXYZ(x, y, z).erase();
             simulation.bounds.updateDisplay(x, y, z);
             for (let i = 0; i < CardinalNeighbors3D.length; i++) {
                 const nx = x + CardinalNeighbors3D[i][0];
@@ -128,12 +127,34 @@ VoxelTickUpdateRegister.registerType({
             simulation.bounds.updateDisplay(x, y, z);
         }
         const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
-        if (!downVoxel || downVoxel.isAir() || downVoxel.isSameVoxel(voxel)) {
-            if (downVoxel) {
-                downVoxel.setId(voxel.getId());
-                downVoxel.setLevel(0);
-                downVoxel.setLevelState(1);
-                downVoxel.updateVoxel(0);
+        const below = simulation.tickCursor[VoxelFaces.Down].getVoxel(x, y - 2, z);
+        const isSame = downVoxel && downVoxel.isSameVoxel(voxel);
+        if (downVoxel && (downVoxel.isAir() || isSame)) {
+            let addToTick = false;
+            if (downVoxel.isAir()) {
+                simulation.brush
+                    .setXYZ(x, y - 1, z)
+                    .setId(voxel.getStringId())
+                    .setLevel((!below?.isAir() && !below?.isSameVoxel(voxel)) ? 7 : 0)
+                    .setLevelState((below?.isAir() || below?.isSameVoxel(voxel)) ? 1 : 0)
+                    .paint()
+                    .clear();
+                addToTick = true;
+            }
+            else {
+                /*   if (
+                    downVoxel.getLevelState() !== 1 &&
+                    below &&
+                    below.isSameVoxel(voxel)
+                  ) {
+                    downVoxel.setLevel(7);
+                    downVoxel.setLevelState(1);
+                    downVoxel.updateVoxel(0);
+                    addToTick = true;
+                  } */
+            }
+            if (addToTick) {
+                simulation.bounds.updateDisplay(x, y - 1, z);
                 simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
             }
             return;
@@ -142,7 +163,7 @@ VoxelTickUpdateRegister.registerType({
             const nx = floodOutChecks[i][0] + x;
             const ny = floodOutChecks[i][1] + y;
             const nz = floodOutChecks[i][2] + z;
-            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
             if (!nVoxel || !(nVoxel.isSameVoxel(voxel) || nVoxel.isAir()))
                 continue;
             const vLevel = nVoxel.getLevel();
@@ -150,14 +171,18 @@ VoxelTickUpdateRegister.registerType({
             if (nState == 2)
                 continue;
             if (vLevel + 1 < currentLevel) {
-                nVoxel.setId(voxel.getId());
-                nVoxel.setLevel(vLevel + 1);
-                nVoxel.updateVoxel(0);
+                simulation.brush
+                    .setId(voxel.getStringId())
+                    .setXYZ(nx, ny, nz)
+                    .setLevel(vLevel + 1)
+                    .setLevelState(1)
+                    .paint();
                 simulation.bounds.updateDisplay(nx, ny, nz);
                 if (currentLevel - 1 > 0) {
                     simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
                 }
             }
         }
+        simulation.brush.clear();
     },
 });

package/WorldSimulation/WorldSimulation.d.ts

@@ -2,6 +2,7 @@ import { Thread, ThreadPool } from "@amodx/threads";
 import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Dimensions/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
+import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 interface WorldSimulationInitData {
     parent: Thread;
@@ -19,6 +20,15 @@ export declare class WorldSimulation {
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
+        BuildOnly: typeof BuildOnly;
+    };
+    static logTasks(): {
+        loading: number[];
+        generating: number[];
+        propagating: number[];
+        sun: number[];
+        building: number[];
+        unbuilding: number[];
     };
     static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;

package/WorldSimulation/WorldSimulation.js

@@ -5,6 +5,7 @@ import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
 import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
 import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
+import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 import { runActiveSectorUpdate } from "./Internal/runActiveSectorUpdate";
 let initalized = false;
@@ -20,7 +21,36 @@ export class WorldSimulation {
     static Procedures = {
         InitalLoad,
         SaveAllSectors,
+        BuildOnly,
     };
+    static logTasks() {
+        return {
+            loading: [
+                WorldSimulationTasks.worldLoadTasks.getTotal(0),
+                WorldSimulationTasks.worldLoadTasks.getTotalWaitingFor(0),
+            ],
+            generating: [
+                WorldSimulationTasks.worldGenTasks.getTotal(0),
+                WorldSimulationTasks.worldGenTasks.getTotalWaitingFor(0),
+            ],
+            propagating: [
+                WorldSimulationTasks.worldPropagationTasks.getTotal(0),
+                WorldSimulationTasks.worldPropagationTasks.getTotalWaitingFor(0),
+            ],
+            sun: [
+                WorldSimulationTasks.worldSunTasks.getTotal(0),
+                WorldSimulationTasks.worldSunTasks.getTotalWaitingFor(0),
+            ],
+            building: [
+                WorldSimulationTasks.buildTasks.getTotal(0),
+                WorldSimulationTasks.buildTasks.getTotalWaitingFor(0),
+            ],
+            unbuilding: [
+                WorldSimulationTasks.unbuildTasks.getTotal(0),
+                WorldSimulationTasks.unbuildTasks.getTotalWaitingFor(0),
+            ],
+        };
+    }
     static init(data) {
         initalized = true;
         WorldSimulationTools.parent = data.parent;
@@ -59,9 +89,11 @@ export class WorldSimulation {
         return false;
     }
     static tick(generationOnly = false) {
+        let total = 0;
         for (const [, dimension] of WorldSimulationDimensions._dimensions) {
             dimension.incrementTick();
             for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+                total += dimension.activeSectors._sectors[i].tickQueue.getTotalTicks();
                 dimension.activeSectors._sectors[i].tickUpdate();
                 dimension.activeSectors._sectors[i].generateUpdate();
             }
@@ -83,9 +115,17 @@ export class WorldSimulation {
         WorldSimulationTasks.worldDecorateTasks.runTask();
         WorldSimulationTasks.worldSunTasks.runTask();
         WorldSimulationTasks.worldPropagationTasks.runTask();
+        /*    console.log(
+          "total ticks",
+          total,
+          "building",
+              "building",
+          WorldSimulationTasks.buildTasks.getTotalWaitingFor(0),
+          WorldSimulationTasks.buildTasks.getTotal(0)
+        ); */
         if (generationOnly)
             return;
-        WorldSimulationTasks.buildTasks.runTask(125);
+        WorldSimulationTasks.buildTasks.runTask(32);
         WorldSimulationTasks.saveTasks.runTask(50);
         WorldSimulationTasks.unloadTasks.runTask(50);
         WorldSimulationTasks.unbuildTasks.runTask();

package/package.json

@@ -1,30 +1 @@
-{
-  "name": "@divinevoxel/vlox",
-  "version": "0.0.75",
-  "description": "Vlox a block style voxel engine.",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "type": "module",
-  "devDependencies": {},
-  "scripts": {
-    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
-    "compile": "cd src && npx tsc --watch"
-  },
-  "keywords": [],
-  "author": "Divine Star Software",
-  "license": "MIT",
-  "repository": {
-    "url": "git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
-  },
-  "dependencies": {
-    "@amodx/math": "latest",
-    "@amodx/binary": "latest",
-    "@amodx/threads": "latest"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{"name":"@divinevoxel/vlox","version":"0.0.77","description":"Vlox a block style voxel engine.","main":"index.js","types":"index.d.ts","type":"module","devDependencies":{},"scripts":{"clean:dist-ts":"test -d dist && find dist -type f \\( -name \"*.js\" -o -name \"*.d.ts\" \\) -delete || true","build":"mkdir -p dist && npm run clean:dist-ts && cp package.json dist/package.json && cd ./src && npx tsc","publish":"mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc","compile":"cd src && npx tsc --watch","compile:fresh":"npm run clean:dist-ts && cd src && npx tsc --watch"},"keywords":[],"author":"Divine Star Software","license":"MIT","repository":{"url":"git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"},"bugs":{"url":"https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"},"dependencies":{"@amodx/math":"latest","@amodx/binary":"latest","@amodx/threads":"latest"},"publishConfig":{"access":"public"}}

package/Mesher/Functions/CompactVoxelMesh.d.ts

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

package/Mesher/Functions/MeshTexture.js

@@ -1,278 +0,0 @@
-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_node", tool);
-     */
-    //  return tool.mesh;
-}

package/Mesher/Geomtry/VoxelMesh.d.ts

@@ -1,12 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
-export declare class VoxelMesh {
-    indicieCount: number;
-    vertexCount: number;
-    minBounds: Vector3Like;
-    maxBounds: Vector3Like;
-    readonly buffer: VoxelVertexBuffer;
-    readonly indices: VoxelIndiceBuffer;
-    addVerticies(vertexCount: number, indicesCount: number): void;
-    clear(): void;
-}

package/Mesher/Geomtry/VoxelMesh.js

@@ -1,25 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
-import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
-export class VoxelMesh {
-    indicieCount = 0;
-    vertexCount = 0;
-    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
-    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
-    buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1024);
-    indices = new VoxelIndiceBuffer(1024);
-    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/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -1,25 +0,0 @@
-import { Vec3Array, Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
-import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
-import { TextureId } from "Textures";
-import { VoxelFaces } from "Math";
-/**
- * Extend your data type so we can add a seed if we want, and define
- * the rotations we can choose from.
- */
-interface VoxelGeometryConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
-    type: "consistent-rotation";
-    texture: TextureId | number;
-    /**
-     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
-     */
-    rotations: (0 | 90 | 180 | 270)[];
-    rotationBounds?: Vec3Array;
-}
-export declare class ConsistentRotationTextureProcedure extends TextureProcedure<VoxelGeometryConsistentRotationTextureProcedureData> {
-    getTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
-    getOverlayTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
-    transformUVs(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
-}
-export {};