Migrated more voxelising code to CPP addon

.gitignore

@@ -16,4 +16,6 @@ ObjToSchematic-darwin-x64
 notes.txt
 *.DS_Store
 .dependency-cruiser.js
-dependencygraph.svg
+dependencygraph.svg
+/build/
+/.vscode/c_cpp_properties.json

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "src/cpp/external/glm"]
+	path = src/cpp/external/glm
+	url = https://github.com/g-truc/glm

.vscode/settings.json

@@ -0,0 +1,79 @@
+{
+    "files.associations": {
+        "*.ejs": "html",
+        "*.config": "editorconfig",
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "queue": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "__functional_base": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "utility": "cpp",
+        "__functional_03": "cpp"
+    }
+}

binding.gyp

@@ -0,0 +1,14 @@
+{
+    "targets": [
+        {
+            "target_name": "addon",
+            "cflags!": ["-fno-exceptions"],
+            "cflags_cc!": ["-fno-exceptions"],
+            "sources": ["./src/cpp/Addon.cc", "./src/cpp/VoxelMesh.cc", "./src/cpp/wrapper/WVoxelMesh.cc", "./src/cpp/util/Geometry.cc", "./src/cpp/VoxelMeshRenderBuffer.cc", "./src/cpp/util/Timer.cc", "./src/cpp/Texture.cc"],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")"
+            ],
+            'defines': ['NAPI_DISABLE_CPP_EXCEPTIONS'],
+        }
+    ]
+}

package.json

@@ -10,6 +10,7 @@
   "scripts": {
     "lint": "eslint --fix src tools tests --ext .ts",
     "build": "tsc",
+    "build-addon": "node-gyp clean configure build",
     "test": "jest --config jestconfig.json",
     "start": "npm run build && electron ./dist/src/main.js --enable-logging --remote-debugging-port=9222",
     "atlas": "node ./dist/tools/build-atlas.js",
@@ -58,11 +59,16 @@
     "typescript": "^4.3.5"
   },
   "dependencies": {
+    "bindings": "^1.5.0",
     "bvh-tree": "^1.0.1",
     "jpeg-js": "^0.4.4",
+    "libxmljs": "^0.19.10",
+    "node-addon-api": "^5.0.0",
+    "node-gyp": "^9.3.0",
     "pngjs": "^6.0.0",
     "prismarine-nbt": "^1.6.0",
     "twgl.js": "^4.19.1",
     "varint-array": "^0.0.0"
-  }
-}
+  },
+  "gypfile": true
+}

src/app_context.ts

@@ -25,6 +25,8 @@ export class AppContext {
     private _lastAction?: EAction;
 
     public constructor() {
+        require('./test');
+
         Logger.Get.enableLogToFile();
         Logger.Get.initLogFile('client');
         Logger.Get.enableLOG();

src/block_mesh.ts

@@ -90,6 +90,7 @@ export class BlockMesh {
         const palette = Palette.load(blockMeshParams.blockPalette);
         ASSERT(palette !== undefined, 'Could not load palette');
 
+        /*
         const atlasPalette = new AtlasPalette(atlas, palette);
         const allBlockCollection = atlasPalette.createBlockCollection([]);
         const nonFallableBlockCollection = atlasPalette.createBlockCollection(this._fallableBlocks);
@@ -132,10 +133,11 @@ export class BlockMesh {
             this._blocksUsed.add(block.name);
         }
         ProgressManager.Get.end(taskHandle);
-
+        
         if (blockMeshParams.fallable === 'do-nothing' && countFalling > 0) {
             StatusHandler.Get.add('warning', `${countFalling.toLocaleString()} blocks will fall under gravity when this structure is placed`);
         }
+        */
     }
 
     public getBlocks(): Block[] {

src/buffer.ts

@@ -59,30 +59,21 @@ export class ChunkedBufferGenerator {
     public static fromVoxelMesh(voxelMesh: VoxelMesh, params: RenderNextVoxelMeshChunkParams.Input, chunkIndex: number): TVoxelMeshBufferDescription & { moreVoxelsToBuffer: boolean, progress: number } {
         const numTotalVoxels = voxelMesh.getVoxelCount();
         const voxelsStartIndex = chunkIndex * AppConfig.Get.VOXEL_BUFFER_CHUNK_SIZE;
+        //const voxelsEndIndex = numTotalVoxels;
         const voxelsEndIndex = Math.min((chunkIndex + 1) * AppConfig.Get.VOXEL_BUFFER_CHUNK_SIZE, numTotalVoxels);
+        //const voxelsEndIndex = numTotalVoxels;
         ASSERT(voxelsStartIndex < numTotalVoxels, 'Invalid voxel start index');
 
         const numBufferVoxels = voxelsEndIndex - voxelsStartIndex;
         const newBuffer: TVoxelMeshBuffer = BufferGenerator.createVoxelMeshBuffer(numBufferVoxels);
 
         const cube: AttributeData = GeometryTemplates.getBoxBufferData(new Vector3(0, 0, 0));
-        const voxels = voxelMesh.getVoxels();
+        //const voxels = voxelMesh.getVoxels();
+
+        newBuffer.position.data = voxelMesh.getInternal().getPositionsRenderBuffer(voxelsStartIndex, voxelsEndIndex);
+        newBuffer.colour.data = voxelMesh.getInternal().getColoursRenderBuffer(voxelsStartIndex, voxelsEndIndex);
 
         for (let i = 0; i < numBufferVoxels; ++i) {
-            const voxelIndex = i + voxelsStartIndex;
-            
-            const voxel = voxels[voxelIndex];
-            const voxelColourArray = [voxel.colour.r, voxel.colour.g, voxel.colour.b, voxel.colour.a];
-            const voxelPositionArray = voxel.position.toArray();
-
-            for (let j = 0; j < AppConstants.VoxelMeshBufferComponentOffsets.POSITION; ++j) {
-                newBuffer.position.data[i * AppConstants.VoxelMeshBufferComponentOffsets.POSITION + j] = cube.custom.position[j] + voxelPositionArray[j % 3];
-            }
-
-            for (let j = 0; j < AppConstants.VoxelMeshBufferComponentOffsets.COLOUR; ++j) {
-                newBuffer.colour.data[i * AppConstants.VoxelMeshBufferComponentOffsets.COLOUR + j] = voxelColourArray[j % 4];
-            }
-
             for (let j = 0; j < AppConstants.VoxelMeshBufferComponentOffsets.NORMAL; ++j) {
                 newBuffer.normal.data[i * AppConstants.VoxelMeshBufferComponentOffsets.NORMAL + j] = cube.custom.normal[j];
             }
@@ -96,7 +87,7 @@ export class ChunkedBufferGenerator {
             }
 
             if (params.enableAmbientOcclusion) {
-                const voxelOcclusionArray = OcclusionManager.Get.getOcclusions(voxel.position, voxelMesh);
+                const voxelOcclusionArray = OcclusionManager.Get.getBlankOcclusions();
                 for (let j = 0; j < AppConstants.VoxelMeshBufferComponentOffsets.OCCLUSION; ++j) {
                     newBuffer.occlusion.data[i * AppConstants.VoxelMeshBufferComponentOffsets.OCCLUSION + j] = voxelOcclusionArray[j];
                 }

src/colour.ts

@@ -11,6 +11,15 @@ export type RGBA = {
 export type RGBA_255 = TBrand<RGBA, '255'>;
 
 export namespace RGBAUtil {
+    export function fromArray(arr: ArrayLike<number>) {
+        return {
+            r: arr[0],
+            g: arr[1],
+            b: arr[2],
+            a: arr[3],
+        };
+    }
+
     export function toRGBA255(c: RGBA): RGBA_255 {
         const out: RGBA = {
             r: c.r * 255,

src/config.ts

@@ -36,7 +36,7 @@ export class AppConfig {
     private constructor() {
         this.RELEASE_MODE = false;
         this.RELEASE_VERSION = '0.7.0d';
-        this.VOXEL_BUFFER_CHUNK_SIZE = 5_000;
+        this.VOXEL_BUFFER_CHUNK_SIZE = 50_000;
 
         const configFile = fs.readFileSync(PathUtil.join(AppPaths.Get.resources, 'config.json'), 'utf8');
         const configJSON = JSON.parse(configFile);

src/cpp/Addon.cc

@@ -0,0 +1,10 @@
+#include <napi.h>
+
+#include "./wrapper/WVoxelMesh.h"
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports)
+{
+    return WVoxelMesh::Init(env, exports);
+}
+
+NODE_API_MODULE(addon, InitAll)

src/cpp/Core.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "./util/Timer.h"
+
+#define RANDF() (float)rand()/RAND_MAX

src/cpp/RGBA.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <stdint.h>
+
+class RGBA
+{
+public:
+    RGBA(uint8_t in_r, uint8_t in_g, uint8_t in_b, uint8_t in_a)
+        : r(in_r), g(in_g), b(in_b), a(in_a)
+    {
+    }
+
+public:
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+    uint8_t a;
+};

src/cpp/Texture.cc

@@ -0,0 +1,56 @@
+#include "Texture.h"
+#include "RGBA.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "./external/stb_image.h"
+
+Texture::Texture()
+{
+}
+
+Texture::~Texture()
+{
+    stbi_image_free(this->data_);
+}
+
+bool Texture::Load(const std::string& file_path)
+{
+    int width, height, channels;
+    unsigned char *image = stbi_load(file_path.c_str(), &width, &height, &channels, 0);
+    if(image == nullptr)
+    {
+        printf("Error in loading the image\n");
+        return false;
+    }
+
+    assert(channels == 3 || channels == 4);
+
+    this->width_ = width;
+    this->height_ = height;
+    this->channels_ = channels;
+    this->data_ = image;
+
+    return true;
+}
+
+RGBA Texture::GetColour(const uint32_t x, const uint32_t y) const
+{
+    assert(0 <= x && x < this->width_);
+    assert(0 <= y && y < this->height_);
+
+    const size_t base_index = this->channels_ * (y * this->width_ + x);
+    const uint8_t r = this->data_[base_index + 0];
+    const uint8_t g = this->data_[base_index + 1];
+    const uint8_t b = this->data_[base_index + 2];
+    const uint8_t a = (channels_ == 4) ? this->data_[base_index + 3] : 255;
+
+    return RGBA(r, g, b, a);
+}
+
+RGBA Texture::GetColour(const float u, const float v) const
+{
+    const uint32_t x = u * (this->width_ - 1);
+    const uint32_t y = v * (this->height_ - 1);
+
+    return this->GetColour(x, y);
+}

src/cpp/Texture.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <stdint.h>
+
+class RGBA;
+
+class Texture
+{
+public:
+    Texture();
+    ~Texture();
+
+    bool Load(const std::string& file_path);
+
+    RGBA GetColour(const float u, const float v) const;
+
+private:
+    RGBA GetColour(const uint32_t x, const uint32_t y) const;
+
+private:
+    uint8_t* data_;
+    uint32_t width_;
+    uint32_t height_;
+    uint32_t channels_;
+};

src/cpp/VoxelMesh.cc

@@ -0,0 +1,372 @@
+#include "VoxelMesh.h"
+#include <algorithm>
+#include <cmath>
+#include "RGBA.h"
+#include "VoxelMeshRenderBuffer.h"
+#include "Core.h"
+#include "./util/Vec3.h"
+
+#define MIN(a, b) a < b ? a : b
+#define MAX(a, b) a > b ? a : b
+
+struct UV
+{
+    UV(float in_u, float in_v)
+        : u(in_u)
+        , v(in_v)
+    {
+    }
+
+    float u;
+    float v;
+};
+
+struct Vertex
+{
+    Vertex(glm::vec3& in_position, UV& in_texcoord)
+        : position(in_position)
+        , texcoord(in_texcoord)
+    {
+    }
+
+    glm::vec3 position;
+    UV texcoord; 
+};
+
+static const std::vector<glm::ivec3> NEIGHBOURS = {
+    glm::ivec3(1, 1, -1),
+    glm::ivec3(0, 1, -1),
+    glm::ivec3(-1, 1, -1),
+    glm::ivec3(1, 0, -1),
+    glm::ivec3(-1, 0, -1),
+    glm::ivec3(1, -1, -1),
+    glm::ivec3(0, -1, -1),
+    glm::ivec3(-1, -1, -1),
+    glm::ivec3(1, 1, 0),
+    glm::ivec3(-1, 1, 0),
+    glm::ivec3(1, -1, 0),
+    glm::ivec3(-1, -1, 0),
+    glm::ivec3(1, 1, 1),
+    glm::ivec3(0, 1, 1),
+    glm::ivec3(-1, 1, 1),
+    glm::ivec3(1, 0, 1),
+    glm::ivec3(-1, 0, 1),
+    glm::ivec3(1, -1, 1),
+    glm::ivec3(0, -1, 1),
+    glm::ivec3(-1, -1, 1),
+};
+
+VoxelMesh::VoxelMesh()
+    : bounds_min(-10000, 100000, -10000), bounds_max(10000, 10000, 10000)
+{
+    render_buffer_ = new VoxelMeshRenderBuffer(this);
+}
+
+void VoxelMesh::InternalSetVertices(const float *data, size_t length)
+{
+    this->vertices_.assign(data, data + length);
+}
+
+void VoxelMesh::InternalSetTexcoords(const float *data, size_t length)
+{
+    this->texcoords_.assign(data, data + length);
+}
+
+void VoxelMesh::InternalSetTriangles(const int32_t *data, size_t length)
+{
+    this->triangles_.assign(data, data + length);
+}
+
+void VoxelMesh::InternalVoxelise(const uint32_t desired_height)
+{
+    {
+        ScopedTimer("Load Texture");
+        this->texture.Load("/Users/lucasdower/ObjToSchematic/res/samples/skull.jpg");
+    }
+
+    {
+        ScopedTimer("Voxelise");
+
+        static const float mesh_desired_height = 8.0f;
+
+        const float scale = desired_height / mesh_desired_height;
+        const float y_offset = desired_height % 2 == 0 ? 0.5f : 0.0f;
+
+        // Transform the vertices
+        const size_t num_vertices = this->vertices_.size() / 3;
+        for (size_t i = 0; i < num_vertices; ++i)
+        {
+            this->vertices_[i * 3 + 0] *= scale;
+            this->vertices_[i * 3 + 1] *= scale;
+            this->vertices_[i * 3 + 2] *= scale;
+
+            this->vertices_[i * 3 + 1] += y_offset;
+        }
+
+        const size_t num_triangles = this->triangles_.size() / 6;
+        for (size_t i = 0; i < num_triangles; ++i)
+        {
+
+            this->InternalVoxeliseTriangle(i);
+        }
+    }
+
+    this->Finalise();
+}
+
+bool VoxelMesh::InternalIntersect(const Ray &ray, const glm::vec3 &v0, const glm::vec3 &v1, const glm::vec3 &v2, glm::vec3 &out_vertex)
+{
+    const glm::vec3 edge1(v1.x - v0.x, v1.y - v0.y, v1.z - v0.z);
+    const glm::vec3 edge2(v2.x - v0.x, v2.y - v0.y, v2.z - v0.z);
+
+    const glm::vec3 ray_direction(ray.direction == Direction::x, ray.direction == Direction::y, ray.direction == Direction::z);
+    const glm::vec3 h(ray_direction.y * edge2.z - ray_direction.z * edge2.y,
+                  ray_direction.z * edge2.x - ray_direction.x * edge2.z,
+                  ray_direction.x * edge2.y - ray_direction.y * edge2.x);
+    const float a = (edge1.x * h.x) + (edge1.y * h.y) + (edge1.z * h.z);
+
+    static const float EPSILON = 1e-7;
+    if (a > -EPSILON && a < EPSILON)
+    {
+        return false; // Ray is parallel to triangle
+    }
+
+    const float f = 1.0f / a;
+    const glm::vec3 s(ray.origin.x - v0.x, ray.origin.y - v0.y, ray.origin.z - v0.z);
+    const float u = f * (s.x * h.x + s.y * h.y + s.z * h.z);
+
+    if (u < 0.0 || u > 1.0)
+    {
+        return false;
+    }
+
+    const glm::vec3 q(s.y * edge1.z - s.z * edge1.y,
+                  s.z * edge1.x - s.x * edge1.z,
+                  s.x * edge1.y - s.y * edge1.x);
+    const float v = f * (ray_direction.x * q.x + ray_direction.y * q.y + ray_direction.z * q.z);
+
+    if (v < 0.0 || u + v > 1.0)
+    {
+        return false;
+    }
+
+    const float t = f * (edge2.x * q.x + edge2.y * q.y + edge2.z * q.z);
+
+    if (t > EPSILON)
+    {
+        out_vertex.x = ray.origin.x + (ray_direction.x * t);
+        out_vertex.y = ray.origin.y + (ray_direction.y * t);
+        out_vertex.z = ray.origin.z + (ray_direction.z * t);
+
+        return true;
+    }
+
+    return false;
+}
+
+Vertex VoxelMesh::InternalGetVertex(const size_t pos_index, const size_t uv_index)
+{
+    float &x = this->vertices_[pos_index * 3 + 0];
+    float &y = this->vertices_[pos_index * 3 + 1];
+    float &z = this->vertices_[pos_index * 3 + 2];
+    glm::vec3 pos(x, y, z);
+
+    const float u = this->texcoords_[uv_index * 2 + 0];
+    const float v = this->texcoords_[uv_index * 2 + 1];
+    UV texcoord(u, v);
+
+    Vertex vertex(pos, texcoord);
+
+    return vertex;
+}
+
+void VoxelMesh::InternalVoxeliseTriangle(const size_t i)
+{
+    const Vertex& vertex_a = this->InternalGetVertex(this->triangles_[i * 6 + 0], this->triangles_[i * 6 + 3]);
+    const Vertex& vertex_b = this->InternalGetVertex(this->triangles_[i * 6 + 1], this->triangles_[i * 6 + 4]);
+    const Vertex& vertex_c = this->InternalGetVertex(this->triangles_[i * 6 + 2], this->triangles_[i * 6 + 5]);
+
+    std::vector<Ray> ray_list;
+    {
+        glm::ivec3 bounds_min(0.0f, 0.0f, 0.0f);
+        bounds_min.x = (int32_t)std::floor(std::min(std::min(vertex_a.position.x, vertex_b.position.x), vertex_c.position.x));
+        bounds_min.y = (int32_t)std::floor(std::min(std::min(vertex_a.position.y, vertex_b.position.y), vertex_c.position.y));
+        bounds_min.z = (int32_t)std::floor(std::min(std::min(vertex_a.position.z, vertex_b.position.z), vertex_c.position.z));
+
+        glm::ivec3 bounds_max(0.0f, 0.0f, 0.0f);
+        bounds_max.x = (int32_t)std::ceil(std::max(std::max(vertex_a.position.x, vertex_b.position.x), vertex_c.position.x));
+        bounds_max.y = (int32_t)std::ceil(std::max(std::max(vertex_a.position.y, vertex_b.position.y), vertex_c.position.y));
+        bounds_max.z = (int32_t)std::ceil(std::max(std::max(vertex_a.position.z, vertex_b.position.z), vertex_c.position.z));
+
+        // Traverse x
+        for (int32_t y = bounds_min.y; y <= bounds_max.y; ++y)
+        {
+            for (int32_t z = bounds_min.z; z <= bounds_max.z; ++z)
+            {
+                ray_list.push_back({glm::ivec3(bounds_min.x - 1, y, z),
+                                    Direction::x});
+            }
+        }
+
+        // Traverse y
+        for (int32_t x = bounds_min.x; x <= bounds_max.x; ++x)
+        {
+            for (int32_t z = bounds_min.z; z <= bounds_max.z; ++z)
+            {
+                ray_list.push_back({glm::ivec3(x, bounds_min.y - 1, z),
+                                    Direction::y});
+            }
+        }
+
+        // Traverse z
+        for (int32_t x = bounds_min.x; x <= bounds_max.x; ++x)
+        {
+            for (int32_t y = bounds_min.y; y <= bounds_max.y; ++y)
+            {
+                ray_list.push_back({glm::ivec3(x, y, bounds_min.z - 1),
+                                    Direction::z});
+            }
+        }
+    }
+
+    glm::vec3 intersection(0.0f, 0.0f, 0.0f);
+    for (const Ray &ray : ray_list)
+    {
+        const bool success = this->InternalIntersect(ray, vertex_a.position, vertex_b.position, vertex_c.position, intersection);
+        if (success)
+        {
+            const glm::ivec3 voxel_position(
+                (int32_t)std::round(intersection.x),
+                (int32_t)std::round(intersection.y),
+                (int32_t)std::round(intersection.z));
+
+            //const RGBA voxel_colour = RGBA(1.0, 1.0, 1.0, 1.0);
+            const RGBA voxel_colour = this->texture.GetColour(vertex_a.texcoord.u, 1.0f - vertex_a.texcoord.v);
+
+            this->InternalAddVoxel(voxel_position, voxel_colour);
+        }
+    }
+}
+
+void VoxelMesh::InternalAddVoxel(const glm::ivec3 &position, const RGBA &colour)
+{
+    const size_t hash = Vec3::hash(position);
+
+    const auto &tmp = this->voxel_hash_.find(hash);
+    const bool is_new_voxel = tmp == this->voxel_hash_.end();
+    if (is_new_voxel)
+    {
+        const size_t base_index = this->voxel_positions_.size() / 3;
+        this->voxel_hash_[hash] = base_index;
+
+        this->voxel_positions_.push_back(position.x);
+        this->voxel_positions_.push_back(position.y);
+        this->voxel_positions_.push_back(position.z);
+
+        this->voxel_colours_.push_back(colour.r / 255.0); // TODO: Fix
+        this->voxel_colours_.push_back(colour.g / 255.0);
+        this->voxel_colours_.push_back(colour.b / 255.0);
+        this->voxel_colours_.push_back(colour.a / 255.0);
+    }
+    else
+    {
+        const size_t base_index = tmp->second;
+        /*
+        this->voxel_colours_[base_index * 4 + 0] = (float)rand()/ 1.0; // TODO: Fix
+        this->voxel_colours_[base_index * 4 + 1] = RANDF;
+        this->voxel_colours_[base_index * 4 + 2] = 1.0;
+        this->voxel_colours_[base_index * 4 + 3] = 1.0;
+        */
+    }
+}
+
+size_t VoxelMesh::InternalGetNeighbourIndex(const glm::ivec3 &neighbour) const
+{
+    return 9 * (neighbour.x + 1) + 3 * (neighbour.y + 1) + (neighbour.z + 1);
+}
+
+size_t &VoxelMesh::InternalGetNeighbours(const glm::ivec3 &neighbour)
+{
+    const size_t hash = Vec3::hash(neighbour);
+
+    const auto &tmp = this->neighbour_map_.find(hash);
+    const bool is_new_voxel = tmp == this->neighbour_map_.end();
+    if (is_new_voxel)
+    {
+        this->neighbour_map_[hash] = 0;
+        return this->neighbour_map_[hash];
+    }
+    else
+    {
+        return tmp->second;
+    }
+}
+
+void VoxelMesh::Finalise()
+{
+    // Update bounds
+    {
+        ScopedTimer("Update Bounds");
+
+        for (size_t i = 0; i < this->voxel_positions_.size(); ++i)
+        {
+            const int32_t x = this->voxel_positions_[i * 3 + 0];
+            const int32_t y = this->voxel_positions_[i * 3 + 1];
+            const int32_t z = this->voxel_positions_[i * 3 + 2];
+
+            if (x < bounds_min.x)
+            {
+                bounds_min.x = x;
+            }
+            if (y < bounds_min.y)
+            {
+                bounds_min.y = y;
+            }
+            if (z < bounds_min.z)
+            {
+                bounds_min.z = z;
+            }
+
+            if (x > bounds_max.x)
+            {
+                bounds_max.x = x;
+            }
+            if (y > bounds_max.y)
+            {
+                bounds_max.y = y;
+            }
+            if (z > bounds_max.z)
+            {
+                bounds_max.z = z;
+            }
+        }
+    }
+
+    // Update neighbours
+    {
+        ScopedTimer("Update Neighbours");
+
+        for (size_t i = 0; i < this->voxel_positions_.size(); ++i)
+        {
+            for (const glm::ivec3 &neighbour : NEIGHBOURS)
+            {
+                const int32_t x = this->voxel_positions_[i * 3 + 0];
+                const int32_t y = this->voxel_positions_[i * 3 + 1];
+                const int32_t z = this->voxel_positions_[i * 3 + 2];
+
+                const glm::ivec3 neighbour_voxel(neighbour.x + x,
+                                               neighbour.y + y,
+                                               neighbour.z + z);
+                const glm::ivec3 inverse_offset(-neighbour_voxel.x, -neighbour_voxel.y, -neighbour_voxel.z);
+                const size_t inverse_index = this->InternalGetNeighbourIndex(inverse_offset);
+                size_t &neighbours = this->InternalGetNeighbours(neighbour_voxel);
+                neighbours |= (1 << inverse_index);
+            }
+        }
+    }
+}
+
+RGBA VoxelMesh::GetVoxelColour(const Vertex& v0, const Vertex& v1, const Vertex& v2, const glm::vec3& position) const
+{
+    return RGBA(0, 0, 0, 0);
+}

src/cpp/VoxelMesh.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <unordered_map>
+#include "./external/glm/glm/vec3.hpp"
+
+#include "Texture.h"
+
+class RGBA;
+class VoxelMeshRenderBuffer;
+
+enum class Direction
+{
+    x,
+    y,
+    z
+};
+
+struct Ray
+{
+    glm::ivec3 origin;
+    Direction direction;
+};
+
+struct Vertex;
+
+class VoxelMesh
+{
+public:
+    VoxelMesh();
+
+    void InternalSetVertices(const float *array, size_t length);
+    void InternalSetTexcoords(const float *array, size_t length);
+    void InternalSetTriangles(const int32_t *array, size_t length);
+    void InternalVoxelise(const uint32_t desired_height);
+    void InternalVoxeliseTriangle(const size_t i);
+
+    Vertex InternalGetVertex(const size_t index, const size_t uv_index);
+    bool InternalIntersect(const Ray &ray, const glm::vec3 &vertex_a, const glm::vec3 &vertex_b, const glm::vec3 &vertex_c, glm::vec3 &out_vertex);
+
+    void InternalAddVoxel(const glm::ivec3 &position, const RGBA &colour);
+    void Finalise();
+
+    size_t InternalGetNeighbourIndex(const glm::ivec3 &neighbour) const;
+    size_t &InternalGetNeighbours(const glm::ivec3 &neighbour);
+
+    size_t GetNumVoxels() const { return voxel_positions_.size() / 3; }
+
+    RGBA GetVoxelColour(const Vertex& v0, const Vertex& v1, const Vertex& v2, const glm::vec3& position) const;
+
+    std::vector<float> vertices_;
+    std::vector<float> texcoords_;
+    std::vector<uint32_t> triangles_;
+
+    std::vector<int32_t> voxel_positions_;
+    std::vector<float> voxel_colours_;
+
+    std::unordered_map<size_t, size_t> voxel_hash_;
+    std::unordered_map<size_t, size_t> neighbour_map_;
+    glm::ivec3 bounds_min;
+    glm::ivec3 bounds_max;
+
+    VoxelMeshRenderBuffer* render_buffer_;
+    Texture texture;
+};

src/cpp/VoxelMeshRenderBuffer.cc

@@ -0,0 +1,71 @@
+#include "VoxelMeshRenderBuffer.h"
+
+#include <stdio.h>
+
+#include "Core.h"
+#include "VoxelMesh.h"
+#include "./util/Geometry.h"
+
+VoxelMeshRenderBuffer::VoxelMeshRenderBuffer(const VoxelMesh* in_owner)
+    : owner(in_owner)
+{
+}
+
+std::vector<float> VoxelMeshRenderBuffer::GetPositions(const size_t start_index, const size_t end_index) const
+{
+    ScopedTimer("VoxelMeshRenderBuffer::GetPositions");
+
+    static const Geometry::CubeGeometry cube_data = Geometry::GetCubeData();
+    static const size_t num_cube_vertices = cube_data.positions.size();
+
+    const std::vector<int32_t>& raw_positions = this->owner->voxel_positions_;
+
+    const size_t num_voxels = end_index - start_index;
+
+    std::vector<float> result(num_cube_vertices * num_voxels);
+
+    for (size_t base_voxel_index = 0; base_voxel_index < num_voxels; ++base_voxel_index)
+    {
+        const size_t voxel_index = base_voxel_index + start_index;
+        for (size_t vertex_index = 0; vertex_index < num_cube_vertices; ++vertex_index)
+        {
+            const size_t result_index = base_voxel_index * num_cube_vertices + vertex_index;
+            result[result_index] = cube_data.positions[vertex_index] + raw_positions[(voxel_index * 3) + (vertex_index % 3)];
+        }
+    }
+
+    return result;
+}
+
+std::vector<float> VoxelMeshRenderBuffer::GetColours(const size_t start_index, const size_t end_index) const
+{
+    ScopedTimer("VoxelMeshRenderBuffer::GetColours");
+    static const size_t num_cube_vertices = 8;
+
+    static const size_t component_offset = 4 * 6 * 4;
+
+    const std::vector<float>& raw_colours = this->owner->voxel_colours_;
+
+    const size_t num_voxels = end_index - start_index;
+
+    std::vector<float> result(component_offset * num_voxels);
+
+    for (size_t base_voxel_index = 0; base_voxel_index < num_voxels; ++base_voxel_index)
+    {
+        const size_t voxel_index = base_voxel_index + start_index;
+
+        const std::vector<float> colour_array = {
+            raw_colours[voxel_index * 4 + 0],
+            raw_colours[voxel_index * 4 + 1],
+            raw_colours[voxel_index * 4 + 2],
+            raw_colours[voxel_index * 4 + 3]
+        };
+        
+        for (size_t i = 0; i < component_offset; ++i)
+        {
+            result[base_voxel_index * component_offset + i] = colour_array[i % 4];
+        }
+    }
+
+    return result;
+}

src/cpp/VoxelMeshRenderBuffer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <stdint.h>
+#include <vector>
+
+class VoxelMesh;
+
+class VoxelMeshRenderBuffer
+{
+public:
+    VoxelMeshRenderBuffer(const VoxelMesh* owner);
+
+    std::vector<float> GetPositions(const size_t start_index, const size_t end_index) const;
+    std::vector<float> GetColours(const size_t start_index, const size_t end_index) const;
+
+private:
+    const VoxelMesh* owner;
+};

src/cpp/external/glm

@@ -0,0 +1 @@
+Subproject commit fc8f4bb442b9540969f2f3f351c4960d91bca17a

src/cpp/util/Geometry.cc

@@ -0,0 +1,15 @@
+#include "Geometry.h"
+
+Geometry::CubeGeometry Geometry::GetCubeData()
+{
+    CubeGeometry output;
+    output.positions = {0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5};
+
+    output.texcoords = {1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1};
+
+    output.normals = {1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1};
+
+    output.indices = {0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23};
+
+    return output;
+}

src/cpp/util/Geometry.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+#include <vector>
+
+namespace Geometry
+{
+    struct CubeGeometry
+    {
+        std::vector<float> positions;
+        std::vector<float> texcoords;
+        std::vector<float> normals;
+        std::vector<uint32_t> indices;
+    };
+
+    CubeGeometry GetCubeData();
+};

src/cpp/util/Timer.cc

@@ -0,0 +1,16 @@
+#include "Timer.h"
+
+#include <stdio.h>
+
+ScopedTimer::ScopedTimer(const std::string& in_label)
+    : label_(in_label)
+    , start_time_(std::chrono::high_resolution_clock::now())
+{
+}
+
+ScopedTimer::~ScopedTimer()
+{
+    const auto end_time = std::chrono::high_resolution_clock::now();
+    const auto duration = end_time - start_time_;
+    printf("[CPP]: '%s' took %lldns\n", label_.c_str(), duration);
+}

src/cpp/util/Timer.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+
+class ScopedTimer
+{
+public:
+    ScopedTimer(const std::string& label);
+    ~ScopedTimer();
+
+private:
+    const std::string label_;
+    const std::chrono::steady_clock::time_point start_time_;
+};

src/cpp/util/Vec3.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "../external/glm/glm/vec3.hpp"
+
+namespace Vec3
+{
+    size_t hash(const glm::ivec3& vec)
+    {
+        return ((vec.x + 10000) << 24) + ((vec.y + 10000) << 12) + ((vec.z + 10000) << 0); 
+    }
+}

src/cpp/wrapper/WVoxelMesh.cc

@@ -0,0 +1,209 @@
+#include "WVoxelMesh.h"
+#include <algorithm>
+#include <cmath>
+#include <cassert>
+
+#include "../VoxelMeshRenderBuffer.h"
+
+Napi::Object WVoxelMesh::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::Function func =
+        DefineClass(env,
+                    "VoxelMesh", {InstanceMethod("setVertices", &WVoxelMesh::SetVertices), InstanceMethod("setTexcoords", &WVoxelMesh::SetTexcoords), InstanceMethod("setTriangles", &WVoxelMesh::SetTriangles), InstanceMethod("voxelise", &WVoxelMesh::Voxelise), InstanceMethod("getVoxelPositions", &WVoxelMesh::GetVoxelPositions), InstanceMethod("getVoxelColours", &WVoxelMesh::GetVoxelColours), InstanceMethod("getVoxelCount", &WVoxelMesh::GetVoxelCount), InstanceMethod("getVoxelBounds", &WVoxelMesh::GetVoxelBounds), InstanceMethod("isVoxelAt", &WVoxelMesh::IsVoxelAt), InstanceMethod("getVoxelIndex", &WVoxelMesh::GetVoxelIndex), InstanceMethod("getNeighbours", &WVoxelMesh::GetNeighbours), InstanceMethod("getPositionsRenderBuffer", &WVoxelMesh::GetPositionsRenderBuffer), InstanceMethod("getColoursRenderBuffer", &WVoxelMesh::GetColoursRenderBuffer)});
+
+    Napi::FunctionReference *constructor = new Napi::FunctionReference();
+    *constructor = Napi::Persistent(func);
+    env.SetInstanceData(constructor);
+
+    exports.Set("VoxelMesh", func);
+    return exports;
+}
+
+WVoxelMesh::WVoxelMesh(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<WVoxelMesh>(info), VoxelMesh()
+{
+}
+
+Napi::Value WVoxelMesh::SetVertices(const Napi::CallbackInfo &info)
+{
+    if (info.Length() != 1)
+    {
+        Napi::Error::New(info.Env(), "Expected exactly one argument")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    if (!info[0].IsArrayBuffer())
+    {
+        Napi::Error::New(info.Env(), "Expected an ArrayBuffer")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    Napi::ArrayBuffer buf = info[0].As<Napi::ArrayBuffer>();
+
+    const float *data = reinterpret_cast<float *>(buf.Data());
+    const size_t length = buf.ByteLength() / sizeof(float);
+    VoxelMesh::InternalSetVertices(data, length);
+
+    return info.Env().Undefined();
+}
+
+Napi::Value WVoxelMesh::SetTexcoords(const Napi::CallbackInfo &info)
+{
+    if (info.Length() != 1)
+    {
+        Napi::Error::New(info.Env(), "Expected exactly one argument")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    if (!info[0].IsArrayBuffer())
+    {
+        Napi::Error::New(info.Env(), "Expected an ArrayBuffer")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    Napi::ArrayBuffer buf = info[0].As<Napi::ArrayBuffer>();
+
+    const float *data = reinterpret_cast<float *>(buf.Data());
+    const size_t length = buf.ByteLength() / sizeof(float);
+    VoxelMesh::InternalSetTexcoords(data, length);
+
+    return info.Env().Undefined();
+}
+
+Napi::Value WVoxelMesh::IsVoxelAt(const Napi::CallbackInfo &info)
+{
+    const int32_t x = info[0].As<Napi::Number>().Int32Value();
+    const int32_t y = info[1].As<Napi::Number>().Int32Value();
+    const int32_t z = info[2].As<Napi::Number>().Int32Value();
+
+    //const bool is_voxel = this->voxel_hash_.find(Vec3_i32(x, y, z).hash()) != this->voxel_hash_.end();
+    const bool is_voxel = false;
+    return Napi::Boolean::New(info.Env(), is_voxel);
+}
+
+Napi::Value WVoxelMesh::GetVoxelIndex(const Napi::CallbackInfo &info)
+{
+    const int32_t x = info[0].As<Napi::Number>().Int32Value();
+    const int32_t y = info[1].As<Napi::Number>().Int32Value();
+    const int32_t z = info[2].As<Napi::Number>().Int32Value();
+
+    //const auto &tmp = this->voxel_hash_.find(Vec3_i32(x, y, z).hash());
+    //const bool is_new_voxel = tmp == this->voxel_hash_.end();
+
+    //const int32_t voxel_index = is_new_voxel ? -1 : tmp->second;
+    const int32_t voxel_index = -1;
+
+    return Napi::Number::New(info.Env(), voxel_index);
+}
+
+Napi::Value WVoxelMesh::GetNeighbours(const Napi::CallbackInfo &info)
+{
+    const int32_t x = info[0].As<Napi::Number>().Int32Value();
+    const int32_t y = info[1].As<Napi::Number>().Int32Value();
+    const int32_t z = info[2].As<Napi::Number>().Int32Value();
+
+    //const auto &tmp = this->neighbour_map_.find(Vec3_i32(x, y, z).hash());
+    //const bool is_new_voxel = tmp == this->neighbour_map_.end();
+
+    //const int32_t neighbour_value = is_new_voxel ? -1 : tmp->second;
+    const int32_t neighbour_value = -1;
+
+
+    return Napi::Number::New(info.Env(), neighbour_value);
+}
+
+Napi::Value WVoxelMesh::SetTriangles(const Napi::CallbackInfo &info)
+{
+    if (info.Length() != 1)
+    {
+        Napi::Error::New(info.Env(), "Expected exactly one argument")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    if (!info[0].IsArrayBuffer())
+    {
+        Napi::Error::New(info.Env(), "Expected an ArrayBuffer")
+            .ThrowAsJavaScriptException();
+        return info.Env().Undefined();
+    }
+
+    Napi::ArrayBuffer buf = info[0].As<Napi::ArrayBuffer>();
+
+    const int32_t *data = reinterpret_cast<int32_t *>(buf.Data());
+    const size_t length = buf.ByteLength() / sizeof(int32_t);
+    InternalSetTriangles(data, length);
+
+    return info.Env().Undefined();
+}
+
+Napi::Value WVoxelMesh::Voxelise(const Napi::CallbackInfo &info)
+{
+    const int32_t desired_height = info[0].As<Napi::Number>().Uint32Value();
+
+    InternalVoxelise(desired_height);
+
+    return info.Env().Undefined();
+}
+
+Napi::Value WVoxelMesh::GetVoxelBounds(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    std::vector<int32_t> bounds_encoded = {
+        bounds_min.x, bounds_min.y, bounds_min.z, bounds_max.x, bounds_max.y, bounds_max.z};
+
+    const auto buffer = Napi::ArrayBuffer::New(env, bounds_encoded.data(), bounds_encoded.size() * sizeof(int32_t));
+    return Napi::Int32Array::New(env, bounds_encoded.size(), buffer, 0);
+}
+
+Napi::Value WVoxelMesh::GetVoxelCount(const Napi::CallbackInfo &info)
+{
+    return Napi::Number::New(info.Env(), this->voxel_positions_.size() / 3);
+}
+
+Napi::Value WVoxelMesh::GetVoxelPositions(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    const auto buffer = Napi::ArrayBuffer::New(env, this->voxel_positions_.data(), this->voxel_positions_.size() * sizeof(int32_t));
+    return Napi::Int32Array::New(env, this->voxel_positions_.size(), buffer, 0);
+}
+
+Napi::Value WVoxelMesh::GetVoxelColours(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    const auto buffer = Napi::ArrayBuffer::New(env, this->voxel_colours_.data(), this->voxel_colours_.size() * sizeof(float));
+    return Napi::Float32Array::New(env, voxel_colours_.size(), buffer, 0);
+}
+
+Napi::Value WVoxelMesh::GetPositionsRenderBuffer(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    const int32_t start_index = info[0].As<Napi::Number>().Int32Value();
+    const int32_t end_index = info[1].As<Napi::Number>().Int32Value();
+
+    std::vector<float> positions = this->render_buffer_->GetPositions(start_index, end_index);
+
+    const auto buffer = Napi::ArrayBuffer::New(env, positions.data(), positions.size() * sizeof(float));
+    return Napi::Float32Array::New(env, positions.size(), buffer, 0);
+}
+
+Napi::Value WVoxelMesh::GetColoursRenderBuffer(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    const int32_t start_index = info[0].As<Napi::Number>().Int32Value();
+    const int32_t end_index = info[1].As<Napi::Number>().Int32Value();
+
+    std::vector<float> colours = this->render_buffer_->GetColours(start_index, end_index);
+
+    const auto buffer = Napi::ArrayBuffer::New(env, colours.data(), colours.size() * sizeof(float));
+    return Napi::Float32Array::New(env, colours.size(), buffer, 0);
+}

src/cpp/wrapper/WVoxelMesh.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <napi.h>
+
+#include "../VoxelMesh.h"
+
+class WVoxelMesh : public Napi::ObjectWrap<WVoxelMesh>, VoxelMesh
+{
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    WVoxelMesh(const Napi::CallbackInfo &info);
+
+private:
+    Napi::Value SetVertices(const Napi::CallbackInfo &info);
+    Napi::Value SetTexcoords(const Napi::CallbackInfo &info);
+    Napi::Value SetTriangles(const Napi::CallbackInfo &info);
+    Napi::Value Voxelise(const Napi::CallbackInfo &info);
+    Napi::Value GetVoxelPositions(const Napi::CallbackInfo &info);
+    Napi::Value GetVoxelColours(const Napi::CallbackInfo &info);
+    Napi::Value GetVoxelCount(const Napi::CallbackInfo &info);
+    Napi::Value GetVoxelBounds(const Napi::CallbackInfo &info);
+    Napi::Value IsVoxelAt(const Napi::CallbackInfo &info);
+    Napi::Value GetVoxelIndex(const Napi::CallbackInfo &info);
+    Napi::Value GetNeighbours(const Napi::CallbackInfo &info);
+
+    // Render buffers
+    Napi::Value GetPositionsRenderBuffer(const Napi::CallbackInfo &info);
+    Napi::Value GetColoursRenderBuffer(const Napi::CallbackInfo &info);
+};

src/geometry.ts

@@ -105,8 +105,8 @@ export class DebugGeometryTemplates {
     }
 
     public static cube(centre: Vector3, size: number, colour: RGBA): AttributeData {
-        const min = Vector3.sub(centre, size/2);
-        const max = Vector3.add(centre, size/2);
+        const min = Vector3.sub(centre, size / 2);
+        const max = Vector3.add(centre, size / 2);
         const bounds = new Bounds(min, max);
         return this.bounds(bounds, colour);
     }
@@ -161,7 +161,7 @@ export class DebugGeometryTemplates {
         for (let i = 0; i < steps; ++i) {
             const point = circlePoints[i];
             positions.push(point.x, point.y, point.z);
-            indices.push(i, (i+1) % steps);
+            indices.push(i, (i + 1) % steps);
             colours.push(colour.r, colour.g, colour.b, colour.a);
         }
 
@@ -187,7 +187,7 @@ export class DebugGeometryTemplates {
         for (let i = 0; i < steps; ++i) {
             const point = circlePoints[i];
             positions.push(point.x, point.y, point.z);
-            indices.push(i, (i+1) % steps);
+            indices.push(i, (i + 1) % steps);
             colours.push(colour.r, colour.g, colour.b, colour.a);
         }
         // Add cone tip
@@ -217,7 +217,7 @@ export class DebugGeometryTemplates {
 
         const normal = Vector3.sub(end, start).normalise();
         const cone = DebugGeometryTemplates.cone(end, coneHeight, normal, coneRadius, colour, 1);
-        
+
         return MergeAttributeData(line, cone);
     }
 
@@ -229,7 +229,7 @@ export class DebugGeometryTemplates {
             { name: 'position', numComponents: 3 },
             { name: 'colour', numComponents: 4 },
         ]);
-        
+
         buffer.add(DebugGeometryTemplates.line(
             new Vector3(0, -dimensions.y / 2, -dimensions.z / 2),
             new Vector3(0, -dimensions.y / 2, dimensions.z / 2),
@@ -281,7 +281,7 @@ export class DebugGeometryTemplates {
             { name: 'position', numComponents: 3 },
             { name: 'colour', numComponents: 4 },
         ]);
-        
+
         buffer.add(DebugGeometryTemplates.line(
             new Vector3(-dimensions.x / 2, 0, -dimensions.z / 2),
             new Vector3(-dimensions.x / 2, 0, dimensions.z / 2),
@@ -333,7 +333,7 @@ export class DebugGeometryTemplates {
             { name: 'position', numComponents: 3 },
             { name: 'colour', numComponents: 4 },
         ]);
-        
+
         buffer.add(DebugGeometryTemplates.line(
             new Vector3(-dimensions.x / 2, -dimensions.y / 2, 0),
             new Vector3(-dimensions.x / 2, dimensions.y / 2, 0),
@@ -417,11 +417,13 @@ export class DebugGeometryTemplates {
             dimensions.y % 2 === 0 ? 0 : -0.5,
             dimensions.z % 2 === 0 ? 0 : -0.5,
         );
+        /*
         for (const voxel of voxelMesh.getVoxels()) {
             buffer.add(DebugGeometryTemplates.cube(
                 Vector3.mulScalar(Vector3.add(voxel.position, gridOffset), voxelSize), voxelSize, colour,
             ));
         }
+        */
 
         return buffer;
     }

src/mesh.ts

@@ -59,6 +59,39 @@ export class Mesh {
         this._loadedTextures = {};
     }
 
+    public getFlatVertices(): Float32Array {
+        const flat = new Float32Array(this._vertices.length * 3);
+        this._vertices.forEach((vertex, index) => {
+            flat[index * 3 + 0] = vertex.x;
+            flat[index * 3 + 1] = vertex.y;
+            flat[index * 3 + 2] = vertex.z;
+        });
+        return flat;
+    }
+
+    public getFlatTexcoords(): Float32Array {
+        const flat = new Float32Array(this._uvs.length * 2);
+        this._uvs.forEach((vertex, index) => {
+            flat[index * 2 + 0] = vertex.u;
+            flat[index * 2 + 1] = vertex.v;
+        });
+        return flat;
+    }
+
+    public getFlatTriangles(): Int32Array {
+        const flat = new Int32Array(this._tris.length * 6);
+        this._tris.forEach((tri, index) => {
+            flat[index * 6 + 0] = tri.positionIndices.x;
+            flat[index * 6 + 1] = tri.positionIndices.y;
+            flat[index * 6 + 2] = tri.positionIndices.z;
+            
+            flat[index * 6 + 3] = tri.texcoordIndices?.x ?? -1;
+            flat[index * 6 + 4] = tri.texcoordIndices?.y ?? -1;
+            flat[index * 6 + 5] = tri.texcoordIndices?.z ?? -1;
+        });
+        return flat;
+    }
+
     // TODO: Always check
     public processMesh() {
         this._checkMesh();

src/occlusion.ts

@@ -29,7 +29,7 @@ export class OcclusionManager {
 
     public getOcclusions(centre: Vector3, voxelMesh: VoxelMesh) {
         // Cache local neighbours
-        const neighbourData = voxelMesh.getNeighbourhoodMap().get(centre.hash());
+        const neighbourData = voxelMesh.getNeighbours(centre);
         if (neighbourData === undefined) {
             // This voxel has no neighbours within a 1-block radius
             return this.getBlankOcclusions();
@@ -64,9 +64,9 @@ export class OcclusionManager {
 
 
                 const baseIndex = f * 16 + v;
-                this._occlusions[baseIndex +  0] = occlusionValue;
-                this._occlusions[baseIndex +  4] = occlusionValue;
-                this._occlusions[baseIndex +  8] = occlusionValue;
+                this._occlusions[baseIndex + 0] = occlusionValue;
+                this._occlusions[baseIndex + 4] = occlusionValue;
+                this._occlusions[baseIndex + 8] = occlusionValue;
                 this._occlusions[baseIndex + 12] = occlusionValue;
             }
         }
@@ -83,7 +83,7 @@ export class OcclusionManager {
     }
 
     public static getNeighbourIndex(neighbour: Vector3) {
-        return 9*(neighbour.x+1) + 3*(neighbour.y+1) + (neighbour.z+1);
+        return 9 * (neighbour.x + 1) + 3 * (neighbour.y + 1) + (neighbour.z + 1);
     }
 
     private _setupOcclusions() {

src/renderer.ts

@@ -194,9 +194,9 @@ export class Renderer {
             }
         }
 
-        this._gridBuffers.x[MeshType.TriangleMesh] = DebugGeometryTemplates.gridX(params.dimensions);
-        this._gridBuffers.y[MeshType.TriangleMesh] = DebugGeometryTemplates.gridY(params.dimensions);
-        this._gridBuffers.z[MeshType.TriangleMesh] = DebugGeometryTemplates.gridZ(params.dimensions);
+        //this._gridBuffers.x[MeshType.TriangleMesh] = DebugGeometryTemplates.gridX(params.dimensions);
+        //this._gridBuffers.y[MeshType.TriangleMesh] = DebugGeometryTemplates.gridY(params.dimensions);
+        //this._gridBuffers.z[MeshType.TriangleMesh] = DebugGeometryTemplates.gridZ(params.dimensions);
 
         this._modelsAvailable = 1;
         this.setModelToUse(MeshType.TriangleMesh);
@@ -225,9 +225,9 @@ export class Renderer {
             );
             dimensions.add(1);
 
-            this._gridBuffers.x[MeshType.VoxelMesh] = DebugGeometryTemplates.gridX(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
-            this._gridBuffers.y[MeshType.VoxelMesh] = DebugGeometryTemplates.gridY(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
-            this._gridBuffers.z[MeshType.VoxelMesh] = DebugGeometryTemplates.gridZ(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
+            //this._gridBuffers.x[MeshType.VoxelMesh] = DebugGeometryTemplates.gridX(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
+            //this._gridBuffers.y[MeshType.VoxelMesh] = DebugGeometryTemplates.gridY(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
+            //this._gridBuffers.z[MeshType.VoxelMesh] = DebugGeometryTemplates.gridZ(Vector3.mulScalar(dimensions, voxelSize), voxelSize);
 
             this._modelsAvailable = 2;
             this.setModelToUse(MeshType.VoxelMesh);

src/test.ts

@@ -0,0 +1 @@
+const addon = require('bindings')('addon');

src/vector.ts

@@ -24,7 +24,7 @@ export class Vector3 implements IHashable {
         this.z = vec.z;
     }
 
-    static fromArray(arr: number[]) {
+    static fromArray(arr: ArrayLike<number>) {
         ASSERT(arr.length === 3);
         return new Vector3(arr[0], arr[1], arr[2]);
     }
@@ -43,7 +43,7 @@ export class Vector3 implements IHashable {
 
     static parse(line: string) {
         const regex = /[+-]?\d+(\.\d+)?/g;
-        const floats = line.match(regex)!.map(function(v) {
+        const floats = line.match(regex)!.map(function (v) {
             return parseFloat(v);
         });
 

src/voxel_mesh.ts

@@ -1,7 +1,7 @@
 import { EFaceVisibility } from './block_assigner';
 import { Bounds } from './bounds';
 import { ChunkedBufferGenerator, TVoxelMeshBufferDescription } from './buffer';
-import { RGBA } from './colour';
+import { RGBA, RGBAUtil } from './colour';
 import { OcclusionManager } from './occlusion';
 import { TOptional } from './util';
 import { ASSERT } from './util/error_util';
@@ -9,10 +9,11 @@ import { LOGF } from './util/log_util';
 import { Vector3 } from './vector';
 import { RenderNextVoxelMeshChunkParams, VoxeliseParams } from './worker_types';
 
+const addon = require('bindings')('addon');
+
 export interface Voxel {
     position: Vector3;
     colour: RGBA;
-    collisions: number;
 }
 
 export type TVoxelOverlapRule = 'first' | 'average';
@@ -20,27 +21,21 @@ export type TVoxelOverlapRule = 'first' | 'average';
 export type TVoxelMeshParams = Pick<VoxeliseParams.Input, 'voxelOverlapRule' | 'enableAmbientOcclusion'>;
 
 export class VoxelMesh {
-    private _voxels: (Voxel & { collisions: number })[];
-    private _voxelsHash: Map<number, number>;
-    private _bounds: Bounds;
-    private _neighbourMap: Map<number, { value: number }>;
+    private _internal: any;
     private _voxelMeshParams: TVoxelMeshParams;
 
     public constructor(voxelMeshParams: TVoxelMeshParams) {
-        this._voxels = [];
-        this._voxelsHash = new Map();
-        this._neighbourMap = new Map();
-        this._bounds = Bounds.getInfiniteBounds();
         this._voxelMeshParams = voxelMeshParams;
-        this._recreateBuffer = true;
+
+        this._internal = new addon.VoxelMesh();
     }
 
-    public getVoxels() {
-        return this._voxels;
+    public getInternal() {
+        return this._internal;
     }
 
     public isVoxelAt(pos: Vector3) {
-        return this._voxelsHash.has(pos.hash());
+        return this._internal.isVoxelAt(pos.x, pos.y, pos.z);
     }
 
     public isOpaqueVoxelAt(pos: Vector3) {
@@ -51,13 +46,25 @@ export class VoxelMesh {
         return false;
     }
 
+    public addVoxel(pos: Vector3, colour: RGBA) {
+
+    }
+
     public getVoxelAt(pos: Vector3): TOptional<Voxel> {
-        const voxelIndex = this._voxelsHash.get(pos.hash());
-        if (voxelIndex !== undefined) {
-            const voxel = this._voxels[voxelIndex];
-            ASSERT(voxel !== undefined);
-            return voxel;
+        return undefined;
+        /*
+        ASSERT(this._hasReadRawData);
+        const voxelIndex = this._internal.GetVoxelIndex(pos.x, pos.y, pos.z);
+        if (voxelIndex !== -1) {
+            const voxelPosition = Vector3.fromArray(this._rawPositions.subarray(voxelIndex * 3, voxelIndex * 3 + 3));
+            const voxelColour = RGBAUtil.fromArray(this._rawColours.subarray(voxelIndex * 4, voxelIndex * 4 + 4));
+
+            return {
+                colour: voxelColour,
+                position: voxelPosition,
+            };
         }
+        */
     }
 
     public static getFullFaceVisibility(): EFaceVisibility {
@@ -87,95 +94,22 @@ export class VoxelMesh {
         return visibility;
     }
 
-    public addVoxel(pos: Vector3, colour: RGBA) {
-        if (colour.a === 0) {
-            return;
-        }
-
-        pos.round();
-
-        const voxelIndex = this._voxelsHash.get(pos.hash());
-        if (voxelIndex !== undefined) {
-            // A voxel at this position already exists
-            const voxel = this._voxels[voxelIndex];
-            voxel.colour.r = ((voxel.colour.r * voxel.collisions) + colour.r) / (voxel.collisions + 1);
-            voxel.colour.g = ((voxel.colour.g * voxel.collisions) + colour.g) / (voxel.collisions + 1);
-            voxel.colour.b = ((voxel.colour.b * voxel.collisions) + colour.b) / (voxel.collisions + 1);
-            voxel.colour.a = ((voxel.colour.a * voxel.collisions) + colour.a) / (voxel.collisions + 1);
-            ++voxel.collisions;
-        } else {
-            // This is a new voxel
-            this._voxels.push({
-                position: pos,
-                colour: colour,
-                collisions: 1,
-            });
-            this._voxelsHash.set(pos.hash(), this._voxels.length - 1);
-            this._bounds.extendByPoint(pos);
-            this._updateNeighbours(pos);
-        }
-    }
-
-    public getBounds() {
-        return this._bounds;
+    public getBounds(): Bounds {
+        const boundsEncoded: Int32Array = this._internal.getVoxelBounds();
+        return new Bounds(new Vector3(boundsEncoded[0], boundsEncoded[1], boundsEncoded[2]), new Vector3(boundsEncoded[3], boundsEncoded[4], boundsEncoded[5]));
     }
 
     public getVoxelCount() {
-        return this._voxels.length;
-    }
-
-    private _neighbours = [
-        new Vector3(1, 1, -1),
-        new Vector3(0, 1, -1),
-        new Vector3(-1, 1, -1),
-        new Vector3(1, 0, -1),
-        new Vector3(-1, 0, -1),
-        new Vector3(1, -1, -1),
-        new Vector3(0, -1, -1),
-        new Vector3(-1, -1, -1),
-        new Vector3(1, 1, 0),
-        new Vector3(-1, 1, 0),
-        new Vector3(1, -1, 0),
-        new Vector3(-1, -1, 0),
-        new Vector3(1, 1, 1),
-        new Vector3(0, 1, 1),
-        new Vector3(-1, 1, 1),
-        new Vector3(1, 0, 1),
-        new Vector3(-1, 0, 1),
-        new Vector3(1, -1, 1),
-        new Vector3(0, -1, 1),
-        new Vector3(-1, -1, 1),
-    ];
-
-    private _updateNeighbours(pos: Vector3) {
-        if (this._voxelMeshParams.enableAmbientOcclusion) {
-            for (const neighbourOffset of this._neighbours) {
-                const neighbour = Vector3.add(pos, neighbourOffset);
-                const inverseOffset = neighbourOffset.copy().negate();
-                const inverseIndex = OcclusionManager.getNeighbourIndex(inverseOffset);
-                // ASSERT(inverseIndex >= 0 && inverseIndex < 27);
-                const neighbourData = this.getNeighbours(neighbour);
-                neighbourData.value |= (1 << inverseIndex);
-                // ASSERT((this.getNeighbours(neighbour).value & (1 << inverseIndex)) !== 0);
-            }
-        }
+        return this._internal.getVoxelCount();
     }
 
     public getNeighbours(pos: Vector3) {
         ASSERT(this._voxelMeshParams.enableAmbientOcclusion, 'Ambient occlusion is disabled');
 
-        const hash = pos.hash();
-        const neighbours = this._neighbourMap.get(hash);
-        if (neighbours === undefined) {
-            this._neighbourMap.set(hash, { value: 0 });
-            return this._neighbourMap.get(hash)!;
-        } else {
-            return neighbours;
-        }
-    }
+        //const value = this._internal.getNeighbours(pos.x, pos.y, pos.z);
 
-    public getNeighbourhoodMap() {
-        return this._neighbourMap;
+        // TODO: Fix
+        return { value: 0 };
     }
 
     /*
@@ -187,25 +121,11 @@ export class VoxelMesh {
     }
 
     private _renderParams?: RenderNextVoxelMeshChunkParams.Input;
-    private _recreateBuffer: boolean;
     public setRenderParams(params: RenderNextVoxelMeshChunkParams.Input) {
         this._renderParams = params;
-        this._recreateBuffer = true;
         this._bufferChunks = [];
     }
 
-    /*
-    private _buffer?: TVoxelMeshBufferDescription;
-    public getBuffer(): TVoxelMeshBufferDescription {
-        ASSERT(this._renderParams, 'Called VoxelMesh.getBuffer() without setting render params');
-        if (this._buffer === undefined || this._recreateBuffer) {
-            this._buffer = BufferGenerator.fromVoxelMesh(this, this._renderParams);
-            this._recreateBuffer = false;
-        }
-        return this._buffer;
-    }
-    */
-
     private _bufferChunks: Array<TVoxelMeshBufferDescription & { moreVoxelsToBuffer: boolean, progress: number }> = [];
     public getChunkedBuffer(chunkIndex: number): TVoxelMeshBufferDescription & { moreVoxelsToBuffer: boolean, progress: number } {
         ASSERT(this._renderParams, 'Called VoxelMesh.getChunkedBuffer() without setting render params');

src/worker_client.ts

@@ -1,17 +1,18 @@
 import { Atlas } from './atlas';
 import { BlockMesh } from './block_mesh';
 import { BufferGenerator } from './buffer';
+import { RGBAUtil } from './colour';
 import { EAppEvent, EventManager } from './event';
 import { IExporter } from './exporters/base_exporter';
 import { ExporterFactory } from './exporters/exporters';
 import { ObjImporter } from './importers/obj_importer';
 import { Mesh } from './mesh';
 import { ProgressManager, TTaskHandle } from './progress';
+import { StatusHandler } from './status';
 import { ASSERT } from './util/error_util';
-import { Logger } from './util/log_util';
+import { LOG, Logger } from './util/log_util';
+import { Vector3 } from './vector';
 import { VoxelMesh } from './voxel_mesh';
-import { IVoxeliser } from './voxelisers/base-voxeliser';
-import { VoxeliserFactory } from './voxelisers/voxelisers';
 import { AssignParams, ExportParams, ImportParams, InitParams, RenderMeshParams, RenderNextBlockMeshChunkParams, RenderNextVoxelMeshChunkParams, TFromWorkerMessage, VoxeliseParams } from './worker_types';
 
 export class WorkerClient {
@@ -90,19 +91,22 @@ export class WorkerClient {
         };
     }
 
-    
+
     public voxelise(params: VoxeliseParams.Input): VoxeliseParams.Output {
         ASSERT(this._loadedMesh !== undefined);
-        
-        const voxeliser: IVoxeliser = VoxeliserFactory.GetVoxeliser(params.voxeliser);
-        this._loadedVoxelMesh = voxeliser.voxelise(this._loadedMesh, params);
-        
+
+        this._loadedVoxelMesh = new VoxelMesh(params);
+        this._loadedVoxelMesh.getInternal().setVertices(this._loadedMesh.getFlatVertices().buffer);
+        this._loadedVoxelMesh.getInternal().setTexcoords(this._loadedMesh.getFlatTexcoords().buffer);
+        this._loadedVoxelMesh.getInternal().setTriangles(this._loadedMesh.getFlatTriangles().buffer);
+        this._loadedVoxelMesh.getInternal().voxelise(params.desiredHeight);
+
         this._voxelMeshChunkIndex = 0;
-        
+
         return {
         };
     }
-    
+
     private _voxelMeshChunkIndex = 0;
     private _voxelMeshProgressHandle?: TTaskHandle;
     public renderChunkedVoxelMesh(params: RenderNextVoxelMeshChunkParams.Input): RenderNextVoxelMeshChunkParams.Output {

src/worker_controller.ts

@@ -108,7 +108,7 @@ export class WorkerController {
             this._worker.postMessage(this._jobPending.payload);
         } else {
             const result = doWork(this._jobPending.payload);
-            if (this._jobPending.callback) {
+            if (this._jobPending.callback && result) {
                 this._jobPending.callback(result);
             }
         }

src/worker_interface.ts

@@ -1,5 +1,8 @@
 const workerInstance = require('./worker');
 
 addEventListener('message', (e) => {
-    postMessage(workerInstance.doWork(e.data));
+    const res = workerInstance.doWork(e.data);
+    if (res) {
+        postMessage(res);
+    }
 });

tools/headless.ts

@@ -57,6 +57,7 @@ export function runHeadless(headlessConfig: THeadlessConfig) {
          * to create its data, in headless mode this render buffer is not created so we must
          * generate it manually
          */
+        /*
         {
             let result;
             do {
@@ -64,8 +65,9 @@ export function runHeadless(headlessConfig: THeadlessConfig) {
                     enableAmbientOcclusion: headlessConfig.voxelise.enableAmbientOcclusion,
                     desiredHeight: headlessConfig.voxelise.desiredHeight,
                 });
-            } while (result.moreVoxelsToBuffer);
+            } while (result && result.moreVoxelsToBuffer);
         }
+        */
 
         worker.export(headlessConfig.export);
         StatusHandler.Get.dump().clear();