YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bruh(2)

Browse Source
This commit is contained in:
Dominic Masters
2021-04-20 18:44:41 +10:00
parent 0ca0783b95
commit 5897c1045d
17 changed files with 278 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
assets/testworld/chunks/0_0_0.txt → assets/world/chunks/0_0_0.txt
View File

BIN
assets/world/tileset.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 149 KiB

0
assets/testworld/world.txt → assets/world/world.txt
View File

7
src/display/primitive.c
View File

@ -1,3 +1,10 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "primitive.h"
primitive_t * primitiveCreate(int32_t verticeCount, int32_t indiceCount) {

7
src/display/primitive.h
View File

@ -1,3 +1,10 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <stdint.h>
#include <glad/glad.h>

6
src/game/game.c
View File

@ -30,6 +30,7 @@ game_t * gameInit(platform_t *platform) {
// Load the world
game->world = worldLoad("testworld/");
playerCreate(&game->world->entities, 0);
// Pass to the main game to handle
return game;
@ -45,7 +46,10 @@ uint32_t gameUpdate(game_t *game) {
// Prepare for rendering
shaderUse(game->shader);
shaderUseCamera(game->shader, game->camera);
worldRender(game->world, game->shader, game->camera);
worldRender(game->world,
game->shader, game->camera,
game->engine->input
);
return 0;
}

5
src/game/game.h
View File

@ -13,6 +13,8 @@
#include "../display/shader.h"
#include "../world/world.h"
#include "../world/entity/player.h"
/////////////////////////////////// CONSTANTS //////////////////////////////////
/** Name of the Game */
#define GAME_NAME "Dawn Game"
@ -27,13 +29,14 @@
/////////////////////////////// TYPE DEFINITIONS ///////////////////////////////
/** Information about the current game context. */
typedef struct {
typedef struct game_t {
/** The engine context for the game */
engine_t *engine;
/** Rendering items */
camera_t *camera;
shader_t *shader;
world_t *world;
} game_t;

62
src/world/chunk.c
View File

@ -7,9 +7,11 @@
#include "chunk.h"
void chunkLoad(world_t *world, chunk_t *chunk, int32_t x, int32_t y, int32_t z){
void chunkLoad(chunk_t *chunk, tilemap_t *tilemap,
int32_t x, int32_t y, int32_t z
){
int32_t tx, ty, tz, i;
tile_t *tile;
tileid_t tileId;
tiledef_t *tileDef;
tilesetdiv_t *div;
char *buffer, *seek, *current;
@ -17,9 +19,7 @@ void chunkLoad(world_t *world, chunk_t *chunk, int32_t x, int32_t y, int32_t z){
// Determine file name of the chunk.
fileName[0] = '\0';
strcat(fileName, world->assetWorldDirectory);
strcat(fileName, "chunks/");
strcat(fileName, "%d_%d_%d.txt");
strcat(fileName, "world/chunks/%d_%d_%d.txt");
sprintf(fileName, fileName, x, y, z);
// Load contents of chunk
@ -30,55 +30,57 @@ void chunkLoad(world_t *world, chunk_t *chunk, int32_t x, int32_t y, int32_t z){
// 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;
*(chunk->tiles + i) = current[0] - CHUNK_TILE_LOAD_ASCII;
tileId = *(chunk->tiles + i);
if(tileId == TILE_NULL) continue;
// Increment tile definition.
tileDef = tilemap->tileDefinitions+tileId;
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);
}
if(indiceCount == 0) return;
chunk->primitive = primitiveCreate(verticeCount, indiceCount);
// For each tile
i = 0;
verticeCount = 0, indiceCount = 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++);
tileId = *(chunk->tiles + (i++));
if(tileId == TILE_NULL) continue;
// Should Chunk bother rendering?
if(tile->id == TILE_NULL) continue;
tileDef = world->tilemap->tileDefinitions + tile->id;
if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
// Get the definition.
tileDef = tilemap->tileDefinitions+tileId;
if(tileDef->tileRender == NULL) continue;
// Render the tile's primitive
tileRender(world, chunk, tile, tileDef, tx, ty, tz);
tileDef->tileRender(tileId, tilemap, tileDef,
chunk->primitive, verticeCount, indiceCount,
tx, ty, tz
);
// Prepare for the next render.
verticeCount += tileDef->verticeCount;
indiceCount += tileDef->indiceCount;
}
}
}
}
void chunkUnload(world_t *world, chunk_t *chunk) {
// Unload the primitive
primitiveDispose(chunk->primitive);
chunk->primitive = NULL;
void chunkUnload(chunk_t *chunk) {
// Load chunks to zero. TODO: Necessary?
memset(chunk->tiles, TILE_NULL, CHUNK_TILE_COUNT);
// Unload the primitive
if(chunk->primitive == NULL) return;
primitiveDispose(chunk->primitive);
chunk->primitive = NULL;
}

31
src/world/chunk.h
View File

@ -1,28 +1,49 @@
#pragma once
#include <string.h>
#include "worldtypes.h"
#include "tile.h"
#include "../file/asset.h"
#include "../input/input.h"
#include "../util/string.h"
/** When loading a chunk, how many chars to offset (ASCII char to byte) */
#define CHUNK_TILE_LOAD_ASCII 48
/** 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 */
tileid_t tiles[CHUNK_TILE_COUNT];
/** Ready to be rendered chunk 3d primitive */
primitive_t *primitive;
} chunk_t;
/**
* 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);
void chunkLoad(chunk_t *chunk, tilemap_t *tilemap,
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);
void chunkUnload(chunk_t *chunk);

21
src/world/entity/entity.c Normal file
View File

@ -0,0 +1,21 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "entity.h"
void entitySystemInit(entitysystem_t *entitySystem) {
memset(&entitySystem->entities, ENTITY_TYPE_NULL,
sizeof(entityid_t) * ENTITY_COUNT_MAX
);
}
void entitySystemUpdate(entitysystem_t *entitySystem,
shader_t *shader, camera_t *camera,
input_t *input
) {
entitySystem->callbacks[0].render(entitySystem, 0, shader, camera, input);
}

42
src/world/entity/player.c
View File

@ -7,29 +7,33 @@
#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,
void playerCreate(entitysystem_t *system, int32_t index) {
system->entities[index] = ENTITY_TYPE_PLAYER;
system->callbacks[index].dispose = &playerDispose;
system->callbacks[index].render = &playerRender;
system->positions[index].x = 0;
system->positions[index].y = 0;
system->positions[index].z = 0;
system->primitives[index] = 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(entitysystem_t *system, int32_t index) {
}
void playerDispose(world_t *world, entity_t *entity) {
primitiveDispose(world->entityPrimitives[entity->id]);
entity->entityDispose = NULL;
entity->entityUpdate = NULL;
}
void playerRender(entitysystem_t *system, int32_t index,
shader_t *shader, camera_t *camera,
input_t *input
) {
shaderUsePosition(shader,
system->positions[index].x,
system->positions[index].y,
system->positions[index].z,
0, 0, 0
);
primitiveDraw(system->primitives[index],
0, system->primitives[index]->indiceCount
);
}

16
src/world/entity/player.h
View File

@ -6,13 +6,13 @@
*/
#pragma once
#include "../worldtypes.h"
#include "entity.h"
#include "../../display/primitive.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);
void playerCreate(entitysystem_t *system, int32_t index);
void playerDispose(entitysystem_t *system, int32_t index);
void playerRender(entitysystem_t *system, int32_t index,
shader_t *shader, camera_t *camera,
input_t *input
);

42
src/world/tile.c
View File

@ -7,32 +7,48 @@
#include "tile.h"
tilemap_t * tileMapCreate(int32_t columns, int32_t rows) {
tilemap_t * tileMapCreate(texture_t *texture) {
tilemap_t *tilemap = malloc(sizeof(tilemap_t));
if(tilemap == NULL) return NULL;
tilemap->texture = texture;
tilemap->tileDefinitions = calloc(columns * rows, sizeof(tiledef_t));
if(!tilemap->tileDefinitions) {
// Create the tileset for the texture.
tilemap->tileset = tilesetCreate(
texture->width/TILE_WIDTH, texture->height/TILE_HEIGHT,
texture->width, texture->height,
0, 0, 0, 0
);
if(tilemap->tileset == NULL) {
free(tilemap);
return NULL;
}
// Setup the tile definitions for each tile within the tileset.
tilemap->tileDefinitions = calloc(tilemap->tileset->count, sizeof(tiledef_t));
if(!tilemap->tileDefinitions) {
tilesetDispose(tilemap->tileset);
free(tilemap);
return NULL;
}
return tilemap;
}
void tileMapDispose(tilemap_t *tilemap) {
free(tilemap->tileDefinitions);
tilesetDispose(tilemap->tileset);
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
void tileQuadRender(tileid_t id, tilemap_t *tilemap, tiledef_t *tileDef,
primitive_t *primitive, int32_t verticeStart, int32_t indiceStart,
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
);
}
tilesetdiv_t *div = tilemap->tileset->divisions + id;
quadBuffer(primitive, z,
x, y, div->x0, div->y0,
x+1, y+1, div->x1, div->y1,
verticeStart, indiceStart
);
}

73
src/world/tile.h
View File

@ -6,22 +6,62 @@
#pragma once
#include <stdint.h>
#include <malloc.h>
#include "worldtypes.h"
#include "../display/tileset.h"
#include "../display/texture.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
/** 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;
// Forwarders
typedef struct tiledef_t tiledef_t;
typedef struct tilemap_t tilemap_t;
/** Representation of the information of a tile within a tilemap. */
typedef struct tiledef_t {
/** Flags of the tile */
tileflag_t flags;
/** How many indices and vertices a tile with this definition has. */
int32_t indiceCount, verticeCount;
/** Callback for the tile definition for rendering the tile */
void (*tileRender)(tileid_t id, tilemap_t *tilemap, tiledef_t *tileDef,
primitive_t *primitive, int32_t verticeStart, int32_t indiceStart,
int32_t x, int32_t y, int32_t z
);
} tiledef_t;
/** Representation of the tile definitions within a tilemap. */
typedef struct tilemap_t {
/** Tile definitions within the tilemap */
tiledef_t *tileDefinitions;
/** Tileset predivided */
tileset_t *tileset;
/** Texture of the tileset */
texture_t *texture;
} tilemap_t;
/**
* Creates a tilemap from a tileset.
*
* @param columns Count of columns in the tilemap.
* @param rows Count of rows in the tilemap.
* @param The texture to base the tilemap on.
* @returns The tilemap.
*/
tilemap_t * tileMapCreate(int32_t columns, int32_t rows);
tilemap_t * tileMapCreate(texture_t *texture);
/**
* Destroys a previously created tilemap.
@ -31,16 +71,19 @@ tilemap_t * tileMapCreate(int32_t columns, int32_t rows);
void tileMapDispose(tilemap_t *tilemap);
/**
* Rendedrs a given chunk tile.
* Renders a tile as a standard quad.
*
* @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).
* @param id ID of the Tile.
* @param tilemap The tilemap that the tile belongs to.
* @param tileDef The tiledef of the tile.
* @param primitive The primitive to render to.
* @param verticeStart The start index of the vertice.
* @param indiceStart The start index of the indice.
* @param x Tile (local) X position coordinate.
* @param y Tile (local) Y position coordinate.
* @param z Tile (local) Z position coordinate.
*/
void tileRender(world_t *world, chunk_t *chunk,
tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
void tileQuadRender(tileid_t id, tilemap_t *tilemap, tiledef_t *tileDef,
primitive_t *primitive, int32_t verticeStart, int32_t indiceStart,
int32_t x, int32_t y, int32_t z
);

72
src/world/world.c
View File

@ -7,36 +7,26 @@
#include "world.h"
world_t * worldLoad(char *assetWorldDirectory) {
world_t * worldLoad() {
// Define our local variables
char file [128];
char *reading, *version, *textureFilename, *temp;
world_t *world;
chunk_t *chunk;
entity_t *entity;
tiledef_t *tileDef;
texture_t *texture;
int32_t i, x, y, z;
// Load the world file.
file[0] = '\0';
strcat(file, assetWorldDirectory);
strcat(file, "world.txt");
strcat(file, "world/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;
@ -47,22 +37,15 @@ world_t * worldLoad(char *assetWorldDirectory) {
// Load tileset texture.
file[0] = '\0';
strcat(file, assetWorldDirectory);
strcat(file, "world/");
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
);
texture = assetTextureLoad(file);
// Create the Tilemap
world->tilemap = tileMapCreate(world->tileset->columns, world->tileset->rows);
world->tilemap = tileMapCreate(texture);
// Load Tilemap Definitions. Skip
for(i = 0; i < world->tileset->count; i++) {
for(i = 0; i < world->tilemap->tileset->count; i++) {
tileDef = world->tilemap->tileDefinitions + i;
temp = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
@ -72,7 +55,9 @@ world_t * worldLoad(char *assetWorldDirectory) {
tileDef->indiceCount = atoi(temp);
temp = strtok_r(reading, WORLD_LOAD_TOKEN, &reading);
tileDef->flags = 0x00;
tileDef->tileRender = &tileQuadRender;
}
// Finished actual loading.
@ -93,46 +78,44 @@ world_t * worldLoad(char *assetWorldDirectory) {
chunk->primitive = NULL;
// Init the chunk.
chunkLoad(world, chunk, x, y, z);
chunkLoad(chunk, world->tilemap, x, y, z);
i++;
}
}
}
// Prepare the entity system
entitySystemInit(&world->entities);
return world;
}
void worldRender(world_t *world, shader_t *shader, camera_t *camera) {
void worldRender(world_t *world,
shader_t *shader, camera_t *camera,
input_t *input
) {
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);
// Bind tilemap texture
shaderUseTexture(shader, world->tilemap->texture);
// Render each chunk.
for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
chunk = world->chunks + i;
if(chunk->primitive == NULL) continue;
// Offset the primitive (into world space)
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);
}
// Entity System tick
entitySystemUpdate(&world->entities, shader, camera, input);
}
void worldDispose(world_t *world) {
@ -142,11 +125,10 @@ void worldDispose(world_t *world) {
// Unload the chunks
for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
chunk = world->chunks + i;
chunkUnload(world, chunk);
chunkUnload(chunk);
}
textureDispose(world->texture);
tilesetDispose(world->tileset);
textureDispose(world->tilemap->texture);
tileMapDispose(world->tilemap);
free(world);
}
@ -194,8 +176,8 @@ void worldShift(world_t *world, int32_t x, int32_t y, int32_t z) {
az = lz + nz;
// Load new chunk.
chunkUnload(world, chunk);
chunkLoad(world, chunk, ax, ay, az);
chunkUnload(chunk);
chunkLoad(chunk, world->tilemap, ax, ay, az);
// Update the absolute coordinates.
chunk->x = ax;

34
src/world/world.h
View File

@ -6,27 +6,52 @@
#pragma once
#include <malloc.h>
#include <stdint.h>
#include "worldtypes.h"
#include "tile.h"
#include "chunk.h"
#include "entity/entity.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 "../input/input.h"
#include "../util/string.h"
#include "../util/math.h"
/** Token in the world data file to split on. */
#define WORLD_LOAD_TOKEN ";"
/** 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
/** Representation of the world. */
typedef struct world_t {
// Chunks
/** Tilemap of the world */
tilemap_t *tilemap;
/** 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];
entitysystem_t entities;
} world_t;
/**
* Create a world object.
*
* @returns The newly created world.
*/
world_t * worldLoad(char *fileName);
world_t * worldLoad();
/**
* Render a world object to the graphics device.
@ -34,7 +59,10 @@ world_t * worldLoad(char *fileName);
* @param world The world to render.
* @param shader The shader to render to.
*/
void worldRender(world_t *world, shader_t *shader, camera_t *camera);
void worldRender(world_t *world,
shader_t *shader, camera_t *camera,
input_t *input
);
/**
* Cleans up a previously created world.

150
src/world/worldtypes.h
View File

@ -1,150 +0,0 @@
/**
* 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;