Working on optimizing the engine.

src/engine/engine.c

@@ -42,13 +42,18 @@ engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
   shader = assetShaderLoad("shaders/test.vert", "shaders/test.frag");
   camera = cameraCreate();
   cameraLookAt(camera,
-    30, 30, 30,
+    20, 20, 20,
+    0, 0, 0
+  );
+  cameraLookAt(camera,
+    4, 4, -4,
     0, 0, 0
   );
   cameraPerspective(camera, 45.0f, 1920.0f/1080.0f, 0.5f, 100.0f);
   shaderUseCamera(shader, camera);
 
   world = worldCreate();
+  
   texture = assetTextureLoad("tileset.png");
   tileset = tilesetCreate(
     texture->width/16, texture->height/16,
@@ -68,7 +73,7 @@ uint32_t engineUpdate(engine_t *engine) {
   worldRender(world, shader);
 
   if((++i % 10000) == 0) {
-    chunkListShift(world->chunkList, 0, 0, 1);
+    // chunkListShift(world->chunkList, 0, 0, 1);
   }
 
   inputUpdate(engine->input);

src/engine/world/chunk.c

@@ -6,13 +6,6 @@
  */
 #include "chunk.h"
 
-void chunkCreate(chunk_t *chunk) {
-  int32_t count, x, y, i;
-
-  count = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH;
-  chunk->batch = spriteBatchCreate(count);
-}
-
 void chunkRender(chunk_t *chunk, shader_t *shader) {
   // Coordinates of the chunk.
   float x, y, z;
@@ -20,7 +13,7 @@ void chunkRender(chunk_t *chunk, shader_t *shader) {
   y = (chunk->y * CHUNK_HEIGHT);
   z = (chunk->z * CHUNK_DEPTH);
 
-  // Render the batch.
+  // Render the primitive
   shaderUsePosition(shader, x, y, z, 0, 0, 0);
-  spriteBatchDraw(chunk->batch, 0, -1);
+  primitiveDraw(chunk->primitive, 0, chunk->primitive->indiceCount);
 }

src/engine/world/chunk.h

@@ -5,9 +5,8 @@
 
 #pragma once
 #include <stdint.h>
-#include <memory.h>
 #include "../display/shader.h"
-#include "../display/spritebatch.h"
+#include "../display/primitive.h"
 #include "tile.h"
 
 #define CHUNK_WIDTH 3
@@ -15,21 +14,17 @@
 #define CHUNK_DEPTH CHUNK_HEIGHT
 
 typedef struct {
-  /** Absolute X Y Z chunklist coordinates */
+  /** Absolute X Y Z chunklist coordinates, a */
   int32_t x, y, z;
+  
+  /** Tiles stored within the chunk. */
+  tile_t *tiles;
 
-  /** Sprite Batch for holding static tiles */
+  /** Primitive used for rendering the chunk */
-  spritebatch_t *batch;
+  primitive_t *primitive;
 } chunk_t;
 
 
-/**
- * Initializes a chunk for the first time.
- * 
- * @param chunk Pointer to the chunk to initialize.
- */
-void chunkCreate(chunk_t *chunk);
-
 /**
  * Render a given chunk.
  * 

src/engine/world/chunklist.c

@@ -20,6 +20,7 @@ chunklist_t * chunkListCreate(int32_t width, int32_t height, int32_t depth,
   list->width = width, list->height = height, list->depth = depth;
   list->x = 0, list->y = 0, list->z = 0;
   list->count = width * height * depth;
+  list->tileCount = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH;
   list->tilemap = tilemap;
 
   //Create chunks
@@ -36,7 +37,7 @@ chunklist_t * chunkListCreate(int32_t width, int32_t height, int32_t depth,
     return NULL;
   }
 
-  // Load initial chunks, ZYX order is important.
+  // Load initial chunks, ZYX order is important here.
   i = 0;
   for(z = 0; z < depth; z++) {
     for(y = 0; y < height; y++) {
@@ -49,7 +50,8 @@ chunklist_t * chunkListCreate(int32_t width, int32_t height, int32_t depth,
         chunk->y = y;
         chunk->z = z;
 
-        chunkCreate(chunk);
+        // Init the chunk.
+        chunk->tiles = calloc(list->tileCount, sizeof(tile_t));
         chunkListChunkLoad(list, chunk, x, y, z);
         i++;
       }
@@ -60,6 +62,16 @@ chunklist_t * chunkListCreate(int32_t width, int32_t height, int32_t depth,
 }
 
 void chunkListDispose(chunklist_t *list) {
+  int32_t i;
+  chunk_t *chunk;
+
+  // Unload the chunks
+  for(i = 0; i < list->count; i++) {
+    chunk = list->chunks + i;
+    chunkListChunkUnload(list, chunk);
+    free(chunk->tiles);
+  }
+
   free(list->chunks);
   free(list);
 }
@@ -149,38 +161,64 @@ void chunkListAlign(chunklist_t *list, int32_t x, int32_t y, int32_t z) {
 void chunkListChunkLoad(chunklist_t *list, chunk_t *chunk,
   int32_t x, int32_t y, int32_t z
 ) {
-  int32_t tx, ty, tz, i, count;
+  int32_t tx, ty, tz, i;
-  tilesetdiv_t *div;
-  tileref_t *tiles;
-  tileref_t tileRef;
   tile_t *tile;
+  tiledef_t *tileDef;
+  tilesetdiv_t *div;
 
-  count = CHUNK_WIDTH * CHUNK_DEPTH * CHUNK_HEIGHT;
+  //TODO: Actually load here, this should be combined with below
-  tiles = calloc(count, sizeof(tileref_t));
+  for(i = 0; i < list->tileCount; i++) {
-  tiles[0] = 0x01;
+    (chunk->tiles + i)->id = (i%2) + 1;
+  }
+  
+  // Determine the size of our primitive.
+  int32_t indiceCount = 0, verticeCount = 0;
+  for(i = 0; i < list->tileCount; i++) {
+    tile = chunk->tiles + i;
+    if(tile->id == TILE_NULL) continue;
+    tileDef = list->tilemap->tileDefinitions + tile->id;
 
-  // Render the quads.
+    verticeCount += tileDef->verticeCount;
-  i = -1;
+    indiceCount += tileDef->indiceCount;
+  }
+
+  // Now we know how big the primitive needs to be!
+  chunk->primitive = primitiveCreate(verticeCount, indiceCount);
+  indiceCount =  0, verticeCount = 0;//Reset for rendering
+
+  i = 0;
   for(tx = 0; tx < CHUNK_WIDTH; tx++) {
     for(ty = 0; ty < CHUNK_HEIGHT; ty++) {
       for(tz = 0; tz < CHUNK_DEPTH; tz++) {
-        tileRef = tiles[++i];
+        // Get tile for position...
-        if(tileRef == TILE_NULL) continue;
+        tile = chunk->tiles + (i++);
-        div = list->tilemap->tileset->divisions + tileRef;
+        if(tile->id == TILE_NULL) continue;
-        tile = list->tilemap->tiles + tileRef;
+        tileDef = list->tilemap->tileDefinitions + tile->id;
 
-        spriteBatchQuad(chunk->batch, -1,
+        if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
-          tx, ty, tz, 1, 1,
+
-          div->x0, div->y0, div->x1, div->y1
+        tile->indiceStart = indiceCount;
+        tile->verticeStart = verticeCount;
+
+        div = list->tilemap->tileset->divisions + tile->id;
+        quadBuffer(chunk->primitive, tz,
+            tx,   ty, div->x0, div->y0,
+          tx+1, ty+1, div->x1, div->y1,
+          verticeCount, indiceCount
         );
+
+        indiceCount += tileDef->indiceCount;
+        verticeCount += tileDef->verticeCount;
       }
     }
   }
-
-  free(tiles);
 }
 
 void chunkListChunkUnload(chunklist_t *list, chunk_t *chunk) {
-  // Flush the sprite batch.
+  // Unload the primitive
-  spriteBatchFlush(chunk->batch);
+  primitiveDispose(chunk->primitive);
+  chunk->primitive = NULL;
+
+  // Load chunks to zero. TODO: Necessary?
+  memset(chunk->tiles, TILE_NULL, list->count);
 }

src/engine/world/chunklist.h

@@ -21,6 +21,9 @@ typedef struct {
   /** Count of chunks in the internal array */
   int32_t count;
 
+  /** Count of tiles within each chunk */
+  int32_t tileCount;
+
   /** Current order of each chunk in the list. */
   chunk_t **chunkList;
 

src/engine/world/tile.c

@@ -12,11 +12,28 @@ tilemap_t * tileMapCreate(tileset_t *tileset) {
   if(tilemap == NULL) return NULL;
 
   tilemap->tileset = tileset;
-  tilemap->tiles = calloc(tileset->columns * tileset->rows, sizeof(tile_t));
+  tilemap->tileDefinitions = calloc(tileset->columns * tileset->rows,
+    sizeof(tiledef_t)
+  );
+  if(!tilemap->tileDefinitions) {
+    free(tilemap);
+    return NULL;
+  }
+
+
+  // tilemap->tileDefinitions->indiceCount = 6;
+  // tilemap->tileDefinitions->verticeCount = 4;
+
+  // (tilemap->tileDefinitions + 1)->indiceCount = 6;
+  // (tilemap->tileDefinitions + 1)->verticeCount = 4;
+
+  (tilemap->tileDefinitions + 2)->indiceCount = 6;
+  (tilemap->tileDefinitions + 2)->verticeCount = 4;
 
   return tilemap;
 }
 
 void tileMapDispose(tilemap_t *tilemap) {
+  free(tilemap->tileDefinitions);
   free(tilemap);
 }

src/engine/world/tile.h

@@ -7,23 +7,32 @@
 #include <stdint.h>
 #include <malloc.h>
 #include "../display/tileset.h"
+#include "../display/primitives/quad.h"
 
 typedef uint8_t tileflag_t;
-typedef uint16_t tileref_t;
+typedef uint8_t tileid_t;
 
 typedef struct {
-  tileflag_t flags;
+  tileid_t id;
+  void *data;
+  int32_t indiceStart, verticeStart;
+
+  //todo: do I need to store the position within the prim where my verts are, or
+  //should that be apart of the data?
 } tile_t;
 
 typedef struct {
-  tile_t *tiles;
+  tileflag_t flags;
+  int32_t indiceCount, verticeCount;
+} tiledef_t;
+
+typedef struct {
+  tiledef_t *tileDefinitions;
   tileset_t *tileset;
 } tilemap_t;
 
-#define TILE_NULL (tileref_t)0
+#define TILE_NULL 0
 #define TILE_FLAG_DYNAMIC (tileflag_t)1
-#define TILE_FLAG_3D (tileflag_t)2
-#define TILE_FLAG_SOLID (tileflag_t)4
 
 /**
  * Creates a tilemap from a tileset.

src/engine/world/world.c

@@ -20,9 +20,9 @@ world_t * worldCreate() {
 
   // Tileset
   world->tileset = tilesetCreate(
-    world->texture->width / 16, world->texture->height / 16,
+    world->texture->width/16, world->texture->height/16,
-    world->texture->width, world->texture->height,
+    world->texture->width,    world->texture->height,
-    0, 0, 0, 0, 0
+    0, 0, 0, 0
   );
   if(world->tileset == NULL) {
     textureDispose(world->texture);
@@ -40,7 +40,7 @@ world_t * worldCreate() {
   }
 
   // Chunk Lists
-  world->chunkList = chunkListCreate(3, 3, 3, world->tilemap);
+  world->chunkList = chunkListCreate(1, 1, 1, world->tilemap);
   if(world->chunkList == NULL) {
     textureDispose(world->texture);
     tilesetDispose(world->tileset);
@@ -63,5 +63,9 @@ void worldRender(world_t *world, shader_t *shader) {
 }
 
 void worldDispose(world_t *world) {
+  textureDispose(world->texture);
+  tilesetDispose(world->tileset);
+  tileMapDispose(world->tilemap);
+  chunkListDispose(world->chunkList);
   free(world);
 }