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

3D Tiles working

Browse Source
This commit is contained in:
Dominic Masters
2021-04-16 06:51:00 +10:00
parent 8198f3d854
commit 7b8afa20a1
12 changed files with 290 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
src/engine/display/primitives/cube.c
View File

@ -7,66 +7,106 @@
#include "cube.h"
primitive_t * cubeCreate(float w, float h, float d) {
primitive_t *cube = primitiveCreate(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
void cubeBuffer(primitive_t *prim,
float x, float y, float z,
float w, float h, float d,
int32_t verticeStart, int32_t indiceStart
) {
vertice_t *vertices = malloc(sizeof(vertice_t) * CUBE_VERTICE_COUNT);
indice_t *indices = malloc(sizeof(indice_t) * CUBE_INDICE_COUNT);
vertice_t *vertices = malloc(sizeof(vertice_t) * cube->verticeCount);
indice_t *indices = malloc(sizeof(indice_t) * cube->indiceCount);
float hw = w / 2, hh = h / 2, hd = d / 2;
vertices[0].x = -hw, vertices[0].y = -hh, vertices[0].z = -hd;
vertices[0].x = x, vertices[0].y = y, vertices[0].z = z;
vertices[0].u = 0, vertices[0].v = 0;
vertices[1].x = hw, vertices[1].y = -hh, vertices[1].z = -hd;
vertices[1].x = x+w, vertices[1].y = y, vertices[1].z = z;
vertices[1].u = 1, vertices[1].v = 0;
vertices[2].x = -hw, vertices[2].y = hh, vertices[2].z = -hd;
vertices[2].x = x, vertices[2].y = y+h, vertices[2].z = z;
vertices[2].u = 0, vertices[2].v = 1;
vertices[3].x = hw, vertices[3].y = hh, vertices[3].z = -hd;
vertices[3].x = x+w, vertices[3].y = y+h, vertices[3].z = z;
vertices[3].u = 1, vertices[3].v = 1;
vertices[4].x = -hw, vertices[4].y = -hh, vertices[4].z = hd;
vertices[4].x = x, vertices[4].y = y, vertices[4].z = z+d;
vertices[4].u = 0, vertices[4].v = 0;
vertices[5].x = hw, vertices[5].y = -hh, vertices[5].z = hd;
vertices[5].x = x+w, vertices[5].y = y, vertices[5].z = z+d;
vertices[5].u = 1, vertices[5].v = 0;
vertices[6].x = -hw, vertices[6].y = hh, vertices[6].z = hd;
vertices[6].x = x, vertices[6].y = y+h, vertices[6].z = z+d;
vertices[6].u = 0, vertices[6].v = 1;
vertices[7].x = hw, vertices[7].y = hh, vertices[7].z = hd;
vertices[7].x = x+w, vertices[7].y = y+h, vertices[7].z = z+d;
vertices[7].u = 1, vertices[7].v = 1;
// Back
indices[ 0] = 0, indices[ 1] = 1, indices[ 2] = 3;
indices[ 3] = 0, indices[ 4] = 2, indices[ 5] = 3;
indices[ 0] = (indice_t)(verticeStart + 0);
indices[ 1] = (indice_t)(verticeStart + 1);
indices[ 2] = (indice_t)(verticeStart + 3);
indices[ 3] = (indice_t)(verticeStart + 0);
indices[ 4] = (indice_t)(verticeStart + 2);
indices[ 5] = (indice_t)(verticeStart + 3);
// Right
indices[ 6] = 1, indices[ 7] = 5, indices[ 8] = 7;
indices[ 9] = 1, indices[10] = 3, indices[11] = 7;
indices[ 6] = (indice_t)(verticeStart + 1);
indices[ 7] = (indice_t)(verticeStart + 5);
indices[ 8] = (indice_t)(verticeStart + 7);
indices[ 9] = (indice_t)(verticeStart + 1);
indices[10] = (indice_t)(verticeStart + 3);
indices[11] = (indice_t)(verticeStart + 7);
// Left
indices[12] = 4, indices[13] = 0, indices[14] = 2;
indices[15] = 4, indices[16] = 6, indices[17] = 2;
indices[12] = (indice_t)(verticeStart + 4);
indices[13] = (indice_t)(verticeStart + 0);
indices[14] = (indice_t)(verticeStart + 2);
indices[15] = (indice_t)(verticeStart + 4);
indices[16] = (indice_t)(verticeStart + 6);
indices[17] = (indice_t)(verticeStart + 2);
// Front
indices[18] = 5, indices[19] = 4, indices[20] = 6;
indices[21] = 5, indices[22] = 7, indices[23] = 6;
indices[18] = (indice_t)(verticeStart + 5);
indices[19] = (indice_t)(verticeStart + 4);
indices[20] = (indice_t)(verticeStart + 6);
indices[21] = (indice_t)(verticeStart + 5);
indices[22] = (indice_t)(verticeStart + 7);
indices[23] = (indice_t)(verticeStart + 6);
// Top
indices[24] = 7, indices[25] = 2, indices[26] = 6;
indices[27] = 7, indices[28] = 3, indices[29] = 2;
indices[24] = (indice_t)(verticeStart + 7);
indices[25] = (indice_t)(verticeStart + 2);
indices[26] = (indice_t)(verticeStart + 6);
indices[27] = (indice_t)(verticeStart + 7);
indices[28] = (indice_t)(verticeStart + 3);
indices[29] = (indice_t)(verticeStart + 2);
// Bottom
indices[30] = 1, indices[31] = 0, indices[32] = 4;
indices[33] = 1, indices[34] = 4, indices[35] = 5;
indices[30] = (indice_t)(verticeStart + 1);
indices[31] = (indice_t)(verticeStart + 0);
indices[32] = (indice_t)(verticeStart + 4);
indices[33] = (indice_t)(verticeStart + 1);
indices[34] = (indice_t)(verticeStart + 4);
indices[35] = (indice_t)(verticeStart + 5);
primitiveBufferVertices(cube, 0, cube->verticeCount, vertices);
primitiveBufferIndices(cube, 0, cube->indiceCount, indices);
primitiveBufferVertices(prim, verticeStart, CUBE_VERTICE_COUNT, vertices);
primitiveBufferIndices(prim, indiceStart, CUBE_INDICE_COUNT, indices);
free(vertices);
free(indices);
}
primitive_t * cubeCreate(float w, float h, float d) {
primitive_t *cube = primitiveCreate(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
cubeBuffer(cube,
-0.5, -0.5, -0.5,
w, h, d,
0, 0
);
return cube;
}

19
src/engine/display/primitives/cube.h
View File

@ -11,6 +11,25 @@
#define CUBE_VERTICE_COUNT 8
#define CUBE_INDICE_COUNT 36
/**
* Buffer the vertices and indices of a cube onto a primitive.
* @param primitive Primitive to buffer to.
* @param x X position of the cube.
* @param y Y position of the cube.
* @param z Z position of the cube.
* @param w Width of cube.
* @param h Height of cube.
* @param d Depth of cube.
* @param verticeStart The position of the vertex buffer to buffer into.
* @param indiceStart The position of the index buffer to buffer into.
*/
void cubeBuffer(primitive_t *primitive,
float x, float y, float z,
float w, float h, float d,
int32_t verticeStart, int32_t indiceStart
);
/**
* Creates a cube primitive of given size.
* @param w Width of cube.

10
src/engine/engine.c
View File

@ -14,7 +14,7 @@ texture_t *texture;
spritebatch_t *batch;
tileset_t *tileset;
int i;
primitive_t *primitive;
engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
// Create the engine instance.
@ -46,14 +46,13 @@ engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
0, 0, 0
);
cameraLookAt(camera,
4, 4, -4,
6, 6, 8,
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,
@ -61,7 +60,6 @@ engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
0, 0,
0, 0
);
i = 0;
return engine;
}
@ -72,10 +70,6 @@ uint32_t engineUpdate(engine_t *engine) {
worldRender(world, shader);
if((++i % 10000) == 0) {
// chunkListShift(world->chunkList, 0, 0, 1);
}
inputUpdate(engine->input);
return 0;
}

1
src/engine/engine.h
View File

@ -18,7 +18,6 @@
#include "display/tileset.h"
#include "display/texture.h"
/** Information about the current engine context. */
typedef struct {
/** Name of the game running. */

61
src/engine/world/chunk.c Normal file
View File

@ -0,0 +1,61 @@
#include "chunk.h"
void chunkLoad(chunklist_t *list, 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;
//TODO: Actually load here, this should be combined with below
for(i = 0; i < list->tileCount; i++) {
(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;
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!
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 = list->tilemap->tileDefinitions + tile->id;
if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
// Render the tile's primitive
tileRender(list, chunk, tile, tileDef, tx, ty, tz);
}
}
}
}
void chunkUnload(chunklist_t *list, chunk_t *chunk) {
// Unload the primitive
primitiveDispose(chunk->primitive);
chunk->primitive = NULL;
// Load chunks to zero. TODO: Necessary?
memset(chunk->tiles, TILE_NULL, list->count);
}

28
src/engine/world/chunk.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include "defs.h"
#include "tile.h"
#define CHUNK_WIDTH 3
#define CHUNK_HEIGHT CHUNK_WIDTH
#define CHUNK_DEPTH CHUNK_HEIGHT
/**
* Loads a given chunk.
*
* @param list List 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(chunklist_t *list, chunk_t *chunk,
int32_t x, int32_t y, int32_t z
);
/**
* Unload a given chunk.
*
* @param list List that the chunk belongs to.
* @param chunk Chunk to unload.
*/
void chunkUnload(chunklist_t *list, chunk_t *chunk);

109
src/engine/world/chunklist.c
View File

@ -52,7 +52,7 @@ chunklist_t * chunkListCreate(int32_t width, int32_t height, int32_t depth,
// Init the chunk.
chunk->tiles = calloc(list->tileCount, sizeof(tile_t));
chunkListChunkLoad(list, chunk, x, y, z);
chunkLoad(list, chunk, x, y, z);
i++;
}
}
@ -68,7 +68,7 @@ void chunkListDispose(chunklist_t *list) {
// Unload the chunks
for(i = 0; i < list->count; i++) {
chunk = list->chunks + i;
chunkListChunkUnload(list, chunk);
chunkUnload(list, chunk);
free(chunk->tiles);
}
@ -120,8 +120,8 @@ void chunkListShift(chunklist_t *list, int32_t x, int32_t y, int32_t z) {
az = lz + nz;
// Load new chunk.
chunkListChunkUnload(list, chunk);
chunkListChunkLoad(list, chunk, ax, ay, az);
chunkUnload(list, chunk);
chunkLoad(list, chunk, ax, ay, az);
// Update the absolute coordinates.
chunk->x = ax;
@ -171,96 +171,25 @@ void chunkListRender(chunklist_t *list, shader_t *shader) {
y = (chunk->y * CHUNK_HEIGHT);
z = (chunk->z * CHUNK_DEPTH);
// Re-render every single tile in the chunk.
j = 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 + (j++);
// // Re-render every single tile in the chunk.
// j = 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 + (j++);
// Should Tile bother rendering?
if(tile->id == TILE_NULL) continue;
tileDef = list->tilemap->tileDefinitions + tile->id;
if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
// // Should Tile bother rendering?
// if(tile->id == TILE_NULL) continue;
// tileDef = list->tilemap->tileDefinitions + tile->id;
// if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
chunkListTileRender(list, chunk, tile, tileDef, tx, ty, tz);
}
}
}
// tileRender(list, chunk, tile, tileDef, tx, ty, tz);
// }
// }
// }
shaderUsePosition(shader, x, y, z, 0, 0, 0);
primitiveDraw(chunk->primitive, 0, chunk->primitive->indiceCount);
}
}
void chunkListChunkLoad(chunklist_t *list, 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;
//TODO: Actually load here, this should be combined with below
for(i = 0; i < list->tileCount; i++) {
(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;
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!
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 = list->tilemap->tileDefinitions + tile->id;
if(tileDef->verticeCount == 0 || tileDef->indiceCount == 0) continue;
// Render the tile's primitive
chunkListTileRender(list, chunk, tile, tileDef, tx, ty, tz);
}
}
}
}
void chunkListChunkUnload(chunklist_t *list, chunk_t *chunk) {
// Unload the primitive
primitiveDispose(chunk->primitive);
chunk->primitive = NULL;
// Load chunks to zero. TODO: Necessary?
memset(chunk->tiles, TILE_NULL, list->count);
}
void chunkListTileRender(chunklist_t *list, chunk_t *chunk,
tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
) {
tilesetdiv_t *div = list->tilemap->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
);
}

78
src/engine/world/chunklist.h
View File

@ -6,50 +6,14 @@
#pragma once
#include <stdint.h>
#include <malloc.h>
#include "defs.h"
#include "tile.h"
#include "chunk.h"
#include "./../util/math.h"
#include "../display/shader.h"
#include "../display/primitive.h"
#include "../display/texture.h"
#define CHUNK_WIDTH 3
#define CHUNK_HEIGHT CHUNK_WIDTH
#define CHUNK_DEPTH CHUNK_HEIGHT
typedef struct {
/** Absolute X Y Z chunklist coordinates */
int32_t x, y, z;
/** Tiles stored within the chunk. */
tile_t *tiles;
/** Primitive used for rendering the chunk */
primitive_t *primitive;
} chunk_t;
typedef struct {
/** Dimensions of the chunk list */
int32_t width, height, depth;
/** Position of index 0 */
int32_t x, y, z;
/** 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;
/** Chunk list tile map. */
tilemap_t *tilemap;
/** The actual chunks in the list */
chunk_t *chunks;
} chunklist_t;
/**
* Creates a new chunk list. Chunk lists are managed to be memory efficient by
* only keeping a small fraction of the overall size loaded at any given time.
@ -98,40 +62,4 @@ void chunkListAlign(chunklist_t *list, int32_t x, int32_t y, int32_t z);
* @param list The list to render.
* @param shader The shader to use.
*/
void chunkListRender(chunklist_t *list, shader_t *shader);
/**
* Loads a given chunk.
*
* @param list List 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 chunkListChunkLoad(chunklist_t *list, chunk_t *chunk,
int32_t x, int32_t y, int32_t z
);
/**
* Unload a given chunk.
*
* @param list List that the chunk belongs to.
* @param chunk Chunk to unload.
*/
void chunkListChunkUnload(chunklist_t *list, chunk_t *chunk);
/**
* Rendedrs a given chunk tile.
*
* @param list The chunk list 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 chunkListTileRender(chunklist_t *list, chunk_t *chunk,
tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
);
void chunkListRender(chunklist_t *list, shader_t *shader);

48
src/engine/world/defs.h Normal file
View File

@ -0,0 +1,48 @@
#pragma once
#include <stdint.h>
#include <malloc.h>
#include "../display/primitive.h"
#include "../display/texture.h"
#include "../display/tileset.h"
typedef uint8_t tileflag_t;
typedef uint8_t tileid_t;
typedef struct {
tileid_t id;
void *data;
int32_t indiceStart, verticeStart;
} tile_t;
typedef struct {
tileflag_t flags;
int32_t indiceCount, verticeCount;
} tiledef_t;
typedef struct {
tiledef_t *tileDefinitions;
tileset_t *tileset;
} tilemap_t;
typedef struct chunk_t {
int32_t x, y, z;
tile_t *tiles;
primitive_t *primitive;
} chunk_t;
typedef struct chunklist_t {
int32_t width, height, depth;
int32_t x, y, z;
int32_t count;
int32_t tileCount;
chunk_t **chunkList;
tilemap_t *tilemap;
chunk_t *chunks;
} chunklist_t;
typedef struct {
chunklist_t *chunkList;
texture_t *texture;
tileset_t *tileset;
tilemap_t *tilemap;
} world_t;

32
src/engine/world/tile.c
View File

@ -20,16 +20,11 @@ tilemap_t * tileMapCreate(tileset_t *tileset) {
return NULL;
}
(tilemap->tileDefinitions + 1)->verticeCount = 4;
(tilemap->tileDefinitions + 1)->indiceCount = 6;
// 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;
(tilemap->tileDefinitions + 2)->verticeCount = 8;
(tilemap->tileDefinitions + 2)->indiceCount = 36;
return tilemap;
}
@ -37,4 +32,23 @@ tilemap_t * tileMapCreate(tileset_t *tileset) {
void tileMapDispose(tilemap_t *tilemap) {
free(tilemap->tileDefinitions);
free(tilemap);
}
void tileRender(chunklist_t *list, chunk_t *chunk,
tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
) {
if(tile->id == 2) {
cubeBuffer(chunk->primitive,
x, y, z,
1, 1, 1,
tile->verticeStart, tile->indiceStart
);
} else {
tilesetdiv_t *div = list->tilemap->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
);
}
}

41
src/engine/world/tile.h
View File

@ -6,30 +6,10 @@
#pragma once
#include <stdint.h>
#include <malloc.h>
#include "defs.h"
#include "../display/tileset.h"
#include "../display/primitives/quad.h"
typedef uint8_t tileflag_t;
typedef uint8_t tileid_t;
typedef struct {
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 {
tileflag_t flags;
int32_t indiceCount, verticeCount;
} tiledef_t;
typedef struct {
tiledef_t *tileDefinitions;
tileset_t *tileset;
} tilemap_t;
#include "../display/primitives/cube.h"
#define TILE_NULL 0
#define TILE_FLAG_DYNAMIC (tileflag_t)1
@ -47,4 +27,19 @@ tilemap_t * tileMapCreate(tileset_t *tileset);
*
* @param tilemap Tilemap to dispose.
*/
void tileMapDispose(tilemap_t *tilemap);
void tileMapDispose(tilemap_t *tilemap);
/**
* Rendedrs a given chunk tile.
*
* @param list The chunk list 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(chunklist_t *list, chunk_t *chunk,
tile_t *tile, tiledef_t *tileDef, int32_t x, int32_t y, int32_t z
);

7
src/engine/world/world.h
View File

@ -4,6 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include "defs.h"
#include "chunklist.h"
#include "tile.h"
#include "../display/shader.h"
@ -11,12 +12,6 @@
#include "../display/texture.h"
#include "../file/asset.h"
typedef struct {
chunklist_t *chunkList;
texture_t *texture;
tileset_t *tileset;
tilemap_t *tilemap;
} world_t;
world_t * worldCreate();