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

Fixed some stuff.

Browse Source
This commit is contained in:
Dominic Masters
2021-04-19 19:02:09 +10:00
parent 786cff50f1
commit cc94f7c775
9 changed files with 65 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/dawn/dawngame.c
View File

@ -7,9 +7,6 @@
#include "dawngame.h"
primitive_t *primitive;
float i;
game_t * gameInit(platform_t *platform) {
// Create the game
game_t *game = malloc(sizeof(game_t));

1
src/dawn/dawngame.h
View File

@ -6,7 +6,6 @@
#pragma once
#include <malloc.h>
#include "../engine/engine.h"
#include "../engine/file/asset.h"
#include "../engine/display/shader.h"
#include "../engine/display/camera.h"

6
src/dawn/entity/entity.h
View File

@ -1,6 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once

4
src/dawn/world/chunk.c
View File

@ -29,7 +29,7 @@ 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 < world->tileCount; i++) {
for(i = 0; i < CHUNK_TILE_COUNT; i++) {
// Get the tile
tile = chunk->tiles + i;
@ -80,5 +80,5 @@ void chunkUnload(world_t *world, chunk_t *chunk) {
chunk->primitive = NULL;
// Load chunks to zero. TODO: Necessary?
memset(chunk->tiles, TILE_NULL, world->count);
memset(chunk->tiles, TILE_NULL, CHUNK_TILE_COUNT);
}

7
src/dawn/world/chunk.h
View File

@ -5,13 +5,6 @@
#include "../../engine/file/asset.h"
#include "../../engine/util/string.h"
/** 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
/** When loading a chunk, how many chars to offset (ASCII char to byte) */
#define CHUNK_TILE_LOAD_ASCII 48

8
src/dawn/world/tile.h
View File

@ -4,12 +4,9 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <stdint.h>
#include <malloc.h>
#include "worldtypes.h"
#include "../../engine/display/tileset.h"
#include "../../engine/display/primitives/quad.h"
#include "../../engine/display/primitives/cube.h"
@ -17,11 +14,6 @@
/** 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
/**
* Creates a tilemap from a tileset.
*

20
src/dawn/world/world.c
View File

@ -27,8 +27,6 @@ world_t * worldLoad(char *assetWorldDirectory) {
world = malloc(sizeof(world_t));
world->assetWorldDirectory = assetWorldDirectory;
world->x = 0, world->y = 0, world->z = 0;
world->count = WORLD_WIDTH * WORLD_HEIGHT * WORLD_DEPTH;
world->tileCount = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH;
// Now begin parsing, first we need to know which version of the file format
// we are using.
@ -71,10 +69,6 @@ world_t * worldLoad(char *assetWorldDirectory) {
// Finished actual loading.
free(worldData);
//Create chunks
world->chunks = malloc(world->count * sizeof(chunk_t));
world->chunkList = malloc(world->count * sizeof(chunk_t *));
// Load initial chunks, ZYX order is important here.
i = 0;
for(z = 0; z < WORLD_DEPTH; z++) {
@ -90,7 +84,6 @@ world_t * worldLoad(char *assetWorldDirectory) {
chunk->primitive = NULL;
// Init the chunk.
chunk->tiles = calloc(world->tileCount, sizeof(tile_t));
chunkLoad(world, chunk, x, y, z);
i++;
}
@ -109,7 +102,7 @@ void worldRender(world_t *world, shader_t *shader) {
shaderUseTexture(shader, world->texture);
for(i = 0; i < world->count; i++) {
for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
chunk = world->chunks + i;
if(chunk->primitive == NULL) continue;
@ -127,13 +120,11 @@ void worldDispose(world_t *world) {
chunk_t *chunk;
// Unload the chunks
for(i = 0; i < world->count; i++) {
for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
chunk = world->chunks + i;
chunkUnload(world, chunk);
free(chunk->tiles);
}
free(world->chunks);
textureDispose(world->texture);
tilesetDispose(world->tileset);
tileMapDispose(world->tilemap);
@ -154,7 +145,7 @@ void worldShift(world_t *world, int32_t x, int32_t y, int32_t z) {
wh
;
chunk_t *chunk;
chunk_t **chunkList;
chunk_t *chunkList[WORLD_CHUNK_COUNT];
// Calculate the new chunklist coordinates
lx = world->x + x;
@ -164,8 +155,7 @@ void worldShift(world_t *world, int32_t x, int32_t y, int32_t z) {
// Precalc width * height.
wh = WORLD_WIDTH * WORLD_HEIGHT;
chunkList = malloc(world->count * sizeof(chunk_t *));
for(i = 0; i < world->count; i++) {
for(i = 0; i < WORLD_CHUNK_COUNT; i++) {
chunk = world->chunkList[i];
// Calculate the new local positions for the chunk.
@ -208,7 +198,7 @@ void worldShift(world_t *world, int32_t x, int32_t y, int32_t z) {
world->z = lz;
// Now copy that array over.
memcpy(world->chunkList, chunkList, sizeof(chunk_t *) * world->count);
memcpy(world->chunkList, chunkList, sizeof(chunk_t *) * WORLD_CHUNK_COUNT);
free(chunkList);
}

8
src/dawn/world/world.h
View File

@ -17,17 +17,9 @@
#include "../../engine/util/string.h"
#include "../../engine/util/math.h"
/** 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
/** Token in the world data file to split on. */
#define WORLD_LOAD_TOKEN ";"
/**
* Create a world object.
*

76
src/dawn/world/worldtypes.h
View File

@ -1,20 +1,44 @@
#pragma once
/**
* 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 "../../engine/display/primitive.h"
#include "../../engine/display/texture.h"
#include "../../engine/display/tileset.h"
////////////////////////////////////////////////////////////////////////////////
// Entities
////////////////////////////////////////////////////////////////////////////////
/** Entity ID */
typedef uint8_t entityid_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 */
@ -24,7 +48,6 @@ typedef struct {
int32_t indiceStart, verticeStart;
} tile_t;
/** Representation of the information of a tile within a tilemap. */
typedef struct {
/** Flags of the tile */
@ -34,7 +57,6 @@ typedef struct {
int32_t indiceCount, verticeCount;
} tiledef_t;
/** Representation of the tile definitions within a tilemap. */
typedef struct {
/** Tile definitions within the tilemap */
@ -42,19 +64,47 @@ typedef struct {
} 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 chunk_t {
/** Position (in absolute chunk coordinates) of this chunk */
int32_t x, y, z;
/** Array of tiles within the chunk */
tile_t *tiles;
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
/** Representation of the world. */
typedef struct {
/** Asset subdir name */
@ -62,25 +112,15 @@ typedef struct {
/** Tileset texture */
texture_t *texture;
/** Tileset predivided */
tileset_t *tileset;
/** Tilemap of the world */
tilemap_t *tilemap;
/** Current (chunk) coordinates of the first chunk in the chunk list */
int32_t x, y, z;
/** Count of chunks within the chunk list */
int32_t count;
/** Count of tiles within each chunk */
int32_t tileCount;
/** Current chunk list, ordered */
chunk_t **chunkList;
chunk_t *chunkList[WORLD_CHUNK_COUNT];
/** Chunk array (unordered) */
chunk_t *chunks;
chunk_t chunks[WORLD_CHUNK_COUNT];
} world_t;