Reshuffled

src/world/chunk.c

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "chunk.h"
+
+void chunkLoad(world_t *world, chunk_t *chunk, int32_t x, int32_t y, int32_t z){
+  int32_t tx, ty, tz, i;
+  tile_t *tile;
+  tiledef_t *tileDef;
+  tilesetdiv_t *div;
+  char *buffer, *seek, *current;
+  char fileName[128];
+
+  // Determine file name of the chunk.
+  fileName[0] = '\0';
+  strcat(fileName, world->assetWorldDirectory);
+  strcat(fileName, "chunks/");
+  strcat(fileName, "%d_%d_%d.txt");
+  sprintf(fileName, fileName, x, y, z);
+
+  // Load contents of chunk
+  buffer = assetStringLoad(fileName);
+  if(buffer == NULL) return;
+  seek = buffer;
+  
+  // Determine the size of our primitive.
+  int32_t indiceCount = 0, verticeCount = 0;
+  for(i = 0; i < CHUNK_TILE_COUNT; i++) {
+    // Get the tile
+    tile = chunk->tiles + i;
+
+    // Now load from the buffer.
+    current = strtok_r(seek, ";", &seek);
+    tile->id = current[0] - CHUNK_TILE_LOAD_ASCII;
+
+    if(tile->id == TILE_NULL) continue;
+    tileDef = world->tilemap->tileDefinitions + tile->id;
+    if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
+
+    tile->verticeStart = verticeCount;
+    tile->indiceStart = indiceCount;
+
+    verticeCount += tileDef->verticeCount;
+    indiceCount += tileDef->indiceCount;
+  }
+
+  // Now we know how big the primitive needs to be!
+  free(buffer);
+  if(indiceCount > 0) {
+    chunk->primitive = primitiveCreate(verticeCount, indiceCount);
+  }
+
+  // For each tile
+  i = 0;
+  for(tx = 0; tx < CHUNK_WIDTH; tx++) {
+    for(ty = 0; ty < CHUNK_HEIGHT; ty++) {
+      for(tz = 0; tz < CHUNK_DEPTH; tz++) {
+        // Get tile for position...
+        tile = chunk->tiles + (i++);
+
+        // Should Chunk bother rendering?
+        if(tile->id == TILE_NULL) continue;
+        tileDef = world->tilemap->tileDefinitions + tile->id;
+        if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
+
+        // Render the tile's primitive
+        tileRender(world, chunk, tile, tileDef, tx, ty, tz);
+      }
+    }
+  }
+}
+
+void chunkUnload(world_t *world, chunk_t *chunk) {
+  // Unload the primitive
+  primitiveDispose(chunk->primitive);
+  chunk->primitive = NULL;
+
+  // Load chunks to zero. TODO: Necessary?
+  memset(chunk->tiles, TILE_NULL, CHUNK_TILE_COUNT);
+}

src/world/chunk.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <string.h>
+#include "worldtypes.h"
+#include "tile.h"
+#include "../file/asset.h"
+#include "../util/string.h"
+
+/** When loading a chunk, how many chars to offset (ASCII char to byte) */
+#define CHUNK_TILE_LOAD_ASCII 48
+
+/**
+ * Loads a given chunk.
+ * 
+ * @param list World to load the chunk for.
+ * @param chunk The chunk to load.
+ * @param x X of the chunk.
+ * @param y Y of the chunk.
+ * @param z Z of the chunk.
+ */
+void chunkLoad(world_t *world, chunk_t *chunk, int32_t x, int32_t y, int32_t z);
+
+/**
+ * Unload a given chunk.
+ * 
+ * @param world World that the chunk belongs to.
+ * @param chunk Chunk to unload.
+ */
+void chunkUnload(world_t *world, chunk_t *chunk);

src/world/entity/player.c

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "player.h"
+
+void playerCreate(world_t *world, entity_t *entity) {
+  // Setup the update state.
+  entity->entityUpdate = &playerUpdate;
+  entity->entityDispose = &playerDispose;
+
+  world->entityPrimitives[entity->id] = quadCreate(0,
+    0, 0, 0, 0,
+    1, 1, 1, 1
+  );
+}
+
+void playerUpdate(world_t *world, entity_t *entity, shader_t *shader,
+  camera_t *camera
+) {
+  shaderUsePosition(shader, 0, 0, 0, 0, 0, 0);
+  primitiveDraw(world->entityPrimitives[entity->id],
+    0, world->entityPrimitives[entity->id]->indiceCount
+  );
+}
+
+void playerDispose(world_t *world, entity_t *entity) {
+  primitiveDispose(world->entityPrimitives[entity->id]);
+
+  entity->entityDispose = NULL;
+  entity->entityUpdate = NULL;
+}

src/world/entity/player.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../worldtypes.h"
+#include "../../display/primitives/quad.h"
+#include "../../input/input.h"
+
+void playerCreate(world_t *world, entity_t *entity);
+void playerUpdate(world_t *world, entity_t *entity, shader_t *shader,
+  camera_t *camera
+);
+
+void playerDispose(world_t *world, entity_t *entity);

src/world/tile.c

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "tile.h"
+
+tilemap_t * tileMapCreate(int32_t columns, int32_t rows) {
+  tilemap_t *tilemap = malloc(sizeof(tilemap_t));
+  if(tilemap == NULL) return NULL;
+
+  tilemap->tileDefinitions = calloc(columns * rows, sizeof(tiledef_t));
+  if(!tilemap->tileDefinitions) {
+    free(tilemap);
+    return NULL;
+  }
+  return tilemap;
+}
+
+void tileMapDispose(tilemap_t *tilemap) {
+  free(tilemap->tileDefinitions);
+  free(tilemap);
+}
+
+void tileRender(world_t *world, chunk_t *chunk,
+  tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
+) {
+  if(tileDef->indiceCount == 6) {
+    tilesetdiv_t *div = world->tileset->divisions + tile->id;
+    quadBuffer(chunk->primitive, z,
+        x,   y, div->x0, div->y0,
+      x+1, y+1, div->x1, div->y1,
+      tile->verticeStart, tile->indiceStart
+    );
+  }
+}

src/world/tile.h

@@ -0,0 +1,46 @@
+// 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>
+#include "worldtypes.h"
+#include "../display/tileset.h"
+#include "../display/primitives/quad.h"
+#include "../display/primitives/cube.h"
+
+/** The tile id that represents a NULL tile */
+#define TILE_NULL (tileid_t)0
+
+/**
+ * Creates a tilemap from a tileset.
+ * 
+ * @param columns Count of columns in the tilemap.
+ * @param rows Count of rows in the tilemap.
+ * @returns The tilemap.
+ */
+tilemap_t * tileMapCreate(int32_t columns, int32_t rows);
+
+/**
+ * Destroys a previously created tilemap.
+ * 
+ * @param tilemap Tilemap to dispose.
+ */
+void tileMapDispose(tilemap_t *tilemap);
+
+/**
+ * Rendedrs a given chunk tile.
+ * 
+ * @param world The world that the chunk belongs to.
+ * @param chunk The chunk to render against.
+ * @param tile The tile to render.
+ * @param tileDef The tile's definition information.
+ * @param x The X Coordinate of the tile (chunk space).
+ * @param y The Y Coordinate of the tile (chunk space).
+ * @param z The Z Coordinate of the tile (chunk space).
+ */
+void tileRender(world_t *world, chunk_t *chunk,
+  tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
+);

src/world/world.c

@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "world.h"
+
+world_t * worldLoad(char *assetWorldDirectory) {
+  // Define our local variables
+  char file [128];
+  char *reading, *version, *textureFilename, *temp;
+  world_t *world;
+  chunk_t *chunk;
+  entity_t *entity;
+  tiledef_t *tileDef;
+  int32_t i, x, y, z;
+
+  // Load the world file.
+  file[0] = '\0';
+  strcat(file, assetWorldDirectory);
+  strcat(file, "world.txt");
+  char *worldData = assetStringLoad(file);
+  if(worldData == NULL) return NULL;
+
+  // Create the world
+  world = malloc(sizeof(world_t));
+  world->assetWorldDirectory = assetWorldDirectory;
+  world->x = 0, world->y = 0, world->z = 0;
+
+  // Init the entities
+  for(i = 0; i < WORLD_ENTITY_COUNT; i++) {
+    entity = world->entities + i;
+    entity->id = (entityid_t)i;
+    entity->entityUpdate = NULL;
+    entity->entityDispose = NULL;
+  }
+
+  // Now begin parsing, first we need to know which version of the file format
+  // we are using.
+  reading = worldData;
+  version = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
+
+  // Now load the tileset texture filename
+  textureFilename = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
+
+  // Load tileset texture.
+  file[0] = '\0';
+  strcat(file, assetWorldDirectory);
+  strcat(file, textureFilename);
+  world->texture = assetTextureLoad(file);
+  
+  // Create the tileset
+  world->tileset = tilesetCreate(
+    world->texture->width/TILE_WIDTH, world->texture->height/TILE_HEIGHT,
+    world->texture->width,            world->texture->height,
+    0, 0, 0, 0
+  );
+  
+  // Create the Tilemap
+  world->tilemap = tileMapCreate(world->tileset->columns, world->tileset->rows);
+
+  // Load Tilemap Definitions. Skip 
+  for(i = 0; i < world->tileset->count; i++) {
+    tileDef = world->tilemap->tileDefinitions + i;
+    
+    temp = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
+    tileDef->verticeCount = atoi(temp);
+
+    temp = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
+    tileDef->indiceCount = atoi(temp);
+
+    temp = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
+    tileDef->flags = 0x00;
+  }
+
+  // Finished actual loading.
+  free(worldData);
+
+  // Load initial chunks, ZYX order is important here.
+  i = 0;
+  for(z = 0; z < WORLD_DEPTH; z++) {
+    for(y = 0; y < WORLD_HEIGHT; y++) {
+      for(x = 0; x < WORLD_WIDTH; x++) {
+        chunk = world->chunks + i;
+        world->chunkList[i] = chunk;
+
+        // Load initial coordinates
+        chunk->x = x;
+        chunk->y = y;
+        chunk->z = z;
+        chunk->primitive = NULL;
+
+        // Init the chunk.
+        chunkLoad(world, chunk, x, y, z);
+        i++;
+      }
+    }
+  }
+
+  return world;
+}
+
+void worldRender(world_t *world, shader_t *shader, camera_t *camera) {
+  int32_t i, j, tx, ty, tz;
+  float x, y, z;
+  chunk_t *chunk;
+  tile_t *tile;
+  tiledef_t *tileDef;
+  entity_t *entity;
+
+  // Bind world texture
+  shaderUseTexture(shader, world->texture);
+
+  // Render each chunk.
+  for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
+    chunk = world->chunks + i;
+    if(chunk->primitive == NULL) continue;
+
+    x = (chunk->x * CHUNK_WIDTH);
+    y = (chunk->y * CHUNK_HEIGHT);
+    z = (chunk->z * CHUNK_DEPTH);
+
+    shaderUsePosition(shader, x, y, z, 0, 0, 0);
+    primitiveDraw(chunk->primitive, 0, chunk->primitive->indiceCount);
+  }
+
+  // Tick entities
+  for(i = 0; i < WORLD_ENTITY_COUNT; i++) {
+    entity = world->entities + i;
+    if(entity->entityUpdate == NULL) break;
+
+    entity->entityUpdate(world, entity, shader, camera);
+  }
+}
+
+void worldDispose(world_t *world) {
+  int32_t i;
+  chunk_t *chunk;
+
+  // Unload the chunks
+  for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
+    chunk = world->chunks + i;
+    chunkUnload(world, chunk);
+  }
+
+  textureDispose(world->texture);
+  tilesetDispose(world->tileset);
+  tileMapDispose(world->tilemap);
+  free(world);
+}
+
+void worldShift(world_t *world, int32_t x, int32_t y, int32_t z) {
+  int32_t i,
+    /** New List Coordinates */
+    lx, ly, lz,
+    /** New Local Chunk Coordinates */
+    nx, ny, nz,
+    /** New Absolute Chunk Coordinates */
+    ax, ay, az,
+    /** New Chunk Index */
+    ni,
+    /** Precalculated width * height */
+    wh
+  ;
+  chunk_t *chunk;
+  chunk_t *chunkList[WORLD_CHUNK_COUNT];
+
+  // Calculate the new chunklist coordinates
+  lx = world->x + x;
+  ly = world->y + y;
+  lz = world->z + z;
+
+  // Precalc width * height.
+  wh = WORLD_WIDTH * WORLD_HEIGHT;
+
+  for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
+    chunk = world->chunkList[i];
+
+    // Calculate the new local positions for the chunk.
+    nx = mathMod(chunk->x - world->x - x, WORLD_WIDTH);
+    ny = mathMod(chunk->y - world->y - y, WORLD_HEIGHT);
+    nz = mathMod(chunk->z - world->z - z, WORLD_DEPTH);
+
+    // Load the chunk if we need to. We also use this to calculate new absolutes
+    if(
+      (ax = lx + nx) != chunk->x ||
+      (ly + ny) != chunk->y ||
+      (lz + nz) != chunk->z
+    ) {
+      // Calculate those things that may have not been done within the if
+      ay = ly + ny;
+      az = lz + nz;
+      
+      // Load new chunk.
+      chunkUnload(world, chunk);
+      chunkLoad(world, chunk, ax, ay, az);
+
+      // Update the absolute coordinates.
+      chunk->x = ax;
+      chunk->y = ay;
+      chunk->z = az; 
+    }
+
+    // Now, based off those new local positions, calculate the new index.
+    ni = (
+      nx +
+      (ny * WORLD_WIDTH) +
+      (nz * wh)
+    );
+    chunkList[ni] = chunk;
+  }
+
+  // Update Absolutes.
+  world->x = lx;
+  world->y = ly;
+  world->z = lz;
+
+  // Now copy that array over.
+  memcpy(world->chunkList, chunkList, sizeof(chunk_t *) * WORLD_CHUNK_COUNT);
+  free(chunkList);
+}
+
+void worldAlign(world_t *world, int32_t x, int32_t y, int32_t z) {
+  int32_t lx, ly, lz;
+  lx = x - world->x;
+  ly = y - world->y;
+  lz = z - world->z;
+  worldShift(world, lx, ly, lz);
+}

src/world/world.h

@@ -0,0 +1,64 @@
+// Copyright (c) 2021 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <malloc.h>
+#include <stdint.h>
+#include "worldtypes.h"
+#include "tile.h"
+#include "chunk.h"
+#include "../display/shader.h"
+#include "../display/camera.h"
+#include "../display/primitive.h"
+#include "../display/tileset.h"
+#include "../display/texture.h"
+#include "../file/asset.h"
+#include "../util/string.h"
+#include "../util/math.h"
+
+/** Token in the world data file to split on. */
+#define WORLD_LOAD_TOKEN ";"
+
+/**
+ * Create a world object.
+ * 
+ * @returns The newly created world.
+ */
+world_t * worldLoad(char *fileName);
+
+/**
+ * Render a world object to the graphics device.
+ * 
+ * @param world The world to render.
+ * @param shader The shader to render to.
+ */
+void worldRender(world_t *world, shader_t *shader, camera_t *camera);
+
+/**
+ * Cleans up a previously created world.
+ * 
+ * @param world World to cleanup.
+ */
+void worldDispose(world_t *world);
+
+/**
+ * Shift the world chunk list along a set of axis (in absolute space).
+ * 
+ * @param world World to shift.
+ * @param x X movement to shift chunk along.
+ * @param y Y movement to shift chunk along.
+ * @param z Z movement to shift chunk along.
+ */
+void worldShift(world_t *world, int32_t x, int32_t y, int32_t z);
+
+/**
+ * Align the world chunk list (in absolute space).
+ * 
+ * @param world World to align.
+ * @param x X movement to shift chunk along.
+ * @param y Y movement to shift chunk along.
+ * @param z Z movement to shift chunk along.
+ */
+void worldAlign(world_t *world, int32_t x, int32_t y, int32_t z);

src/world/worldtypes.h

@@ -0,0 +1,150 @@
+/**
+ * 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>
+#include "../display/shader.h"
+#include "../display/primitive.h"
+#include "../display/camera.h"
+#include "../display/texture.h"
+#include "../display/tileset.h"
+
+// Forwarders
+typedef struct entity_t entity_t;
+typedef struct world_t world_t;
+
+////////////////////////////////////////////////////////////////////////////////
+// Entities
+////////////////////////////////////////////////////////////////////////////////
+
+typedef uint8_t entityid_t;
+
+/** Entity ID */
+typedef struct entity_t {
+  entityid_t id;
+
+  /** Callback for frame events, or NULL */
+  void (*entityUpdate)(world_t *world, entity_t *entity, shader_t *shader,
+    camera_t *camera
+  );
+
+  /** Callback for cleanup events, or NULL */
+  void (*entityDispose)(world_t *world, entity_t *entity);
+} entity_t;
+
+typedef struct {
+  float x, y, z;
+} entitypos_t;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Tiles
+////////////////////////////////////////////////////////////////////////////////
+
+/** Width of a tile (in pixels) */
+#define TILE_WIDTH 16
+/** Height of a tile (in pixels) */
+#define TILE_HEIGHT 16
+
+/** Bitwise Flags from tiles. */
+typedef uint8_t tileflag_t;
+
+/** Tile ID */
+typedef uint8_t tileid_t;
+
+/** Representation of a unique tile within a chunk. */
+typedef struct {
+  /** ID of the tile */
+  tileid_t id;
+  /** Rendering indice and vertice offsets for the tile. */
+  int32_t indiceStart, verticeStart;
+} tile_t;
+
+/** Representation of the information of a tile within a tilemap. */
+typedef struct {
+  /** Flags of the tile */
+  tileflag_t flags;
+
+  /** How many indices and vertices a tile with this definition has. */
+  int32_t indiceCount, verticeCount;
+} tiledef_t;
+
+/** Representation of the tile definitions within a tilemap. */
+typedef struct {
+  /** Tile definitions within the tilemap */
+  tiledef_t *tileDefinitions;
+} tilemap_t;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Chunks
+////////////////////////////////////////////////////////////////////////////////
+
+/** Width (in tiles) of chunks. */
+#define CHUNK_WIDTH 16
+/** Heihgt (in tiles) of chunks. */
+#define CHUNK_HEIGHT 16
+/** Depth (in tiles) of chunks. */
+#define CHUNK_DEPTH 8
+/** Count of tiles in the chunk. */
+#define CHUNK_TILE_COUNT CHUNK_WIDTH*CHUNK_HEIGHT*CHUNK_DEPTH
+
+
+
+/** Representation of a chunk, a group of tiles that can be buffered around. */
+typedef struct {
+  /** Position (in absolute chunk coordinates) of this chunk */
+  int32_t x, y, z;
+  /** Array of tiles within the chunk */
+  tile_t tiles[CHUNK_TILE_COUNT];
+  /** Ready to be rendered chunk 3d primitive */
+  primitive_t *primitive;
+} chunk_t;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Worlds
+////////////////////////////////////////////////////////////////////////////////
+/** Width of world (in chunks) */
+#define WORLD_WIDTH 5
+/** Height of world (in chunks) */
+#define WORLD_HEIGHT WORLD_WIDTH
+/** Depth of world (in chunks) */
+#define WORLD_DEPTH 2
+
+/** Count of chunks in the world */
+#define WORLD_CHUNK_COUNT WORLD_WIDTH*WORLD_HEIGHT*WORLD_DEPTH
+
+#define WORLD_ENTITY_COUNT 32
+
+/** Representation of the world. */
+typedef struct world_t {
+  /** Asset subdir name */
+  char *assetWorldDirectory;
+
+  // Tiles
+  /** Tileset texture */
+  texture_t *texture;
+  /** Tileset predivided */
+  tileset_t *tileset;
+  /** Tilemap of the world */
+  tilemap_t *tilemap;
+
+  // Chunks
+  /** Current (chunk) coordinates of the first chunk in the chunk list */
+  int32_t x, y, z;
+  /** Current chunk list, ordered */
+  chunk_t *chunkList[WORLD_CHUNK_COUNT];
+  /** Chunk array (unordered) */
+  chunk_t chunks[WORLD_CHUNK_COUNT];
+
+  /** Entity Definitions */
+  entity_t entities[WORLD_ENTITY_COUNT];
+  entitypos_t entityPositions[WORLD_ENTITY_COUNT];
+  primitive_t *entityPrimitives[WORLD_ENTITY_COUNT];
+} world_t;