Added world chunking.

src/engine/engine.c

@@ -56,17 +56,11 @@ engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
      1,  1, 1, 1
   );
 
-
-  texture = textureCreate(2, 2, NULL);
-  pixel_t *p = malloc(sizeof(pixel_t) * 2 * 2);
+  int32_t w = 1, h = 1;
+  pixel_t *p = calloc(w * h, sizeof(pixel_t));
   p[0].r=0xFF, p[0].g=0x00, p[0].b=0x00, p[0].a = 0xFF;
-  p[1].r=0x00, p[1].g=0xFF, p[1].b=0x00, p[1].a = 0xFF;
-  p[2].r=0x00, p[2].g=0x00, p[2].b=0xFF, p[2].a = 0xFF;
-  p[3].r=0xFF, p[3].g=0xFF, p[3].b=0xFF, p[3].a = 0xFF;
-
-
-  textureBufferPixels(texture, 0, 0, 2, 2, p);
-  shaderUseTexture(shader, texture);
+  texture = textureCreate(w, h, NULL);
+  textureBufferPixels(texture, 0, 0, w, h, p);
 
   return engine;
 }

src/engine/input/input.h

@@ -9,7 +9,7 @@
 #include <malloc.h>
 #include <memory.h>
 #include <string.h>
-#include "../util/list/list.h"
+#include "../util/list.h"
 #include "../platform.h"
 
 /////////////////////////////////// CONSTANTS //////////////////////////////////

src/engine/world/chunk.c

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "chunk.h"
+
+chunklist_t * chunksCreate(uint32_t width,uint32_t height, uint32_t depth) {
+  chunklist_t *chunks;
+  uint32_t i;
+  
+  chunks = malloc(sizeof(chunklist_t));
+  if(!chunks) return NULL;
+
+  chunks->width = width;
+  chunks->height = height;
+  chunks->depth = depth;
+  chunks->count = width * height * depth;
+
+  chunks->indexes = malloc(sizeof(uint32_t) * chunks->count);
+  if(!chunks->indexes) {
+    free(chunks);
+    return NULL;
+  }
+
+  for(i = 0; i < chunks->count; i++) chunks->indexes[i] = i;
+
+  return chunks;
+}
+
+void chunksDispose(chunklist_t *list) {
+  free(list->indexes);
+  free(list);
+}
+
+void chunksShift(chunklist_t *list, uint32_t direction[3]) {
+  uint32_t i, x, y, z, my, mz;
+
+  // Precalculate these values
+  my = list->width * list->height;
+  mz = my * list->depth;
+
+  // For each chunk
+  for(i = 0; i < list->count; i++) {
+    // Precalculate, store here for now.
+    x = i / list->width;
+
+    // Calculate the new xyz for the current index.
+    y = (x + direction[0]) % list->height;
+    z = (x / list->height + direction[1]) % list->depth;
+    x = (i + direction[2]) % list->width;
+
+    // Set back into the indexes array.
+    list->indexes[i] = (x * list->width) + (y * my) + (z * mz);
+  }
+}

src/engine/world/chunk.h

@@ -0,0 +1,39 @@
+// Copyright (c) 2021 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <stdint.h>
+#include <malloc.h>
+
+typedef struct {
+  uint32_t width, height, depth;
+  uint32_t count;
+  uint32_t *indexes;
+} chunklist_t;
+
+/**
+ * Create a new chunk manager.
+ * 
+ * @param width Width of the chunk list.
+ * @param height Height of the chunk list.
+ * @param depth Depth of the chunk list.
+ * @returns The new chunk list manager
+ */
+chunklist_t * chunksCreate(uint32_t width,uint32_t height, uint32_t depth);
+
+/**
+ * Cleans up a previously created chunk list.
+ * 
+ * @param list List to dispose.
+ */
+void chunksDispose(chunklist_t *list);
+
+/**
+ * Shift the chunk list along a set of axis.
+ * 
+ * @param list List to shift.
+ * @param direction Array of directions to shift along.
+ */
+void chunksShift(chunklist_t *list, uint32_t direction[3]);