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

FPS

Browse Source
This commit is contained in:
Dominic Masters
2025-10-08 14:17:58 -05:00
parent 46f820690d
commit 67604eca8d
17 changed files with 230 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
assets/config/init-base.dcf
View File

@@ -1,4 +1,4 @@
echo " = Dawn Init = ";
fps 1;
scene test;
scene map;

6
src/display/display.c
View File

@@ -13,6 +13,7 @@
#include "display/spritebatch.h"
#include "display/mesh/quad.h"
#include "display/screen.h"
#include "ui/ui.h"
display_t DISPLAY;
@@ -110,7 +111,12 @@ errorret_t displayUpdate(void) {
// Bind screen and render scene
screenBind();
frameBufferClear(
FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH,
COLOR_CORNFLOWER_BLUE
);
sceneManagerRender();
uiRender();
// UI will probs go here

4
src/engine/engine.c
View File

@@ -13,6 +13,7 @@
#include "display/display.h"
#include "scene/scenemanager.h"
#include "asset/assetmanager.h"
#include "ui/ui.h"
#include "rpg/rpg.h"
engine_t ENGINE;
@@ -30,6 +31,7 @@ errorret_t engineInit(void) {
inputInit();
errorChain(assetManagerInit());
errorChain(displayInit());
errorChain(uiInit());
errorChain(rpgInit());
errorChain(sceneManagerInit());
@@ -50,6 +52,7 @@ errorret_t engineUpdate(void) {
assetManagerUpdate();
rpgUpdate();
uiUpdate();
sceneManagerUpdate();
errorChain(displayUpdate());
@@ -63,6 +66,7 @@ void engineExit(void) {
errorret_t engineDispose(void) {
sceneManagerDispose();
rpgDispose();
uiDispose();
errorChain(displayDispose());
assetManagerDispose();
consoleDispose();

73
src/rpg/entity/entity.c
View File

@@ -6,22 +6,25 @@
*/
#include "entity.h"
#include "rpg/world/map.h"
#include "assert/assert.h"
#include "util/memory.h"
#include "display/tileset/tileset_entities.h"
#include "time/time.h"
#include "util/math.h"
void entityInit(entity_t *entity, const entitytype_t type, map_t *map) {
entity_t ENTITIES[ENTITY_COUNT];
void entityInit(entity_t *entity, const entitytype_t type) {
assertNotNull(entity, "Entity pointer cannot be NULL");
assertNotNull(map, "Map pointer cannot be NULL");
assertTrue(type < ENTITY_TYPE_COUNT, "Invalid entity type");
assertTrue(type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
assertTrue(
entity >= ENTITIES && entity < ENTITIES + ENTITY_COUNT,
"Entity pointer is out of bounds"
);
memoryZero(entity, sizeof(entity_t));
entity->type = type;
entity->map = map;
// Init. I did use a callback struct but it was not flexible enough.
switch(type) {
@@ -42,66 +45,4 @@ void entityUpdate(entity_t *entity) {
assertNotNull(entity, "Entity pointer cannot be NULL");
assertTrue(entity->type < ENTITY_TYPE_COUNT, "Invalid entity type");
assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
// Handle movement logic
switch(entity->type) {
case ENTITY_TYPE_PLAYER:
playerMovement(entity);
break;
case ENTITY_TYPE_NPC:
npcUpdate(entity);
break;
default:
break;
}
// Apply velocity
if(entity->velocity[0] != 0.0f || entity->velocity[1] != 0.0f) {
entity->position[0] += entity->velocity[0] * TIME.delta;
entity->position[1] += entity->velocity[1] * TIME.delta;
// Hit test on other entities.
entity_t *start = entity->map->entities;
entity_t *end = &entity->map->entities[entity->map->entityCount];
// Our hitbox
physicscircle_t self;
glm_vec2_copy(entity->position, self.position);
self.radius = TILESET_ENTITIES.tileWidth / 2.0f;
physicscircle_t other;
other.radius = self.radius;
// TODO: what if multiple collisions?
do {
if(start == entity) continue;
if(start->type == ENTITY_TYPE_NULL) continue;
glm_vec2_copy(start->position, other.position);
physicscirclecircleresult_t result;
physicsCircleCheckCircle(self, other, &result);
if(result.hit) {
entity->position[0] -= result.normal[0] * result.depth;
entity->position[1] -= result.normal[1] * result.depth;
break;
}
} while((start++) != end);
// Friction (and dampening)
entity->velocity[0] *= ENTITY_FRICTION * TIME.delta;
entity->velocity[1] *= ENTITY_FRICTION * TIME.delta;
if(mathAbs(entity->velocity[0]) < ENTITY_MIN_VELOCITY) {
entity->velocity[0] = 0.0f;
}
if(mathAbs(entity->velocity[1]) < ENTITY_MIN_VELOCITY) {
entity->velocity[1] = 0.0f;
}
}
if(entity->type == ENTITY_TYPE_PLAYER) {
playerInteraction(entity);
}
}

17
src/rpg/entity/entity.h
View File

@@ -10,9 +10,11 @@
#include "rpg/entity/player.h"
#include "npc.h"
#include "physics/physics.h"
#include "rpg/world/worldunit.h"
#define ENTITY_FRICTION 0.9f
#define ENTITY_MIN_VELOCITY 0.05f
#define ENTITY_FRICTION 1
#define ENTITY_MIN_VELOCITY 1
#define ENTITY_COUNT 256
typedef struct map_s map_t;
@@ -25,12 +27,10 @@ typedef enum {
} entitytype_t;
typedef struct entity_s {
map_t *map;
entitytype_t type;
direction_t direction;
vec2 position;
vec2 velocity;
worldchunkpos_t position[3];
worldsubtile_t velocity[3];
union {
player_t player;
@@ -38,14 +38,15 @@ typedef struct entity_s {
};
} entity_t;
extern entity_t ENTITIES[ENTITY_COUNT];
/**
* Initializes an entity structure.
*
* @param entity Pointer to the entity structure to initialize.
* @param type The type of the entity.
* @param map Pointer to the map the entity belongs to.
*/
void entityInit(entity_t *entity, const entitytype_t type, map_t *map);
void entityInit(entity_t *entity, const entitytype_t type);
/**
* Updates an entity.

152
src/rpg/entity/player.c
View File

@@ -17,98 +17,98 @@ void playerInit(entity_t *entity) {
void playerMovement(entity_t *entity) {
assertNotNull(entity, "Entity pointer cannot be NULL");
// Update velocity.
vec2 dir = {
inputAxis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT),
inputAxis(INPUT_ACTION_DOWN, INPUT_ACTION_UP)
};
if(dir[0] == 0 && dir[1] == 0) return;
// // Update velocity.
// vec2 dir = {
// inputAxis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT),
// inputAxis(INPUT_ACTION_DOWN, INPUT_ACTION_UP)
// };
// if(dir[0] == 0 && dir[1] == 0) return;
glm_vec2_normalize(dir);
entity->velocity[0] += PLAYER_SPEED * dir[0];
entity->velocity[1] += PLAYER_SPEED * dir[1];
// glm_vec2_normalize(dir);
// entity->velocity[0] += PLAYER_SPEED * dir[0];
// entity->velocity[1] += PLAYER_SPEED * dir[1];
// Update direction.
if(dir[0] > 0) {
if(entity->direction == DIRECTION_RIGHT) {
entity->direction = DIRECTION_RIGHT;
} else {
if(dir[1] < 0) {
entity->direction = DIRECTION_UP;
} else if(dir[1] > 0) {
entity->direction = DIRECTION_DOWN;
} else {
entity->direction = DIRECTION_RIGHT;
}
}
} else if(dir[0] < 0) {
if(entity->direction == DIRECTION_LEFT) {
entity->direction = DIRECTION_LEFT;
} else {
if(dir[1] < 0) {
entity->direction = DIRECTION_UP;
} else if(dir[1] > 0) {
entity->direction = DIRECTION_DOWN;
} else {
entity->direction = DIRECTION_LEFT;
}
}
} else if(dir[1] < 0) {
entity->direction = DIRECTION_UP;
} else if(dir[1] > 0) {
entity->direction = DIRECTION_DOWN;
}
// // Update direction.
// if(dir[0] > 0) {
// if(entity->direction == DIRECTION_RIGHT) {
// entity->direction = DIRECTION_RIGHT;
// } else {
// if(dir[1] < 0) {
// entity->direction = DIRECTION_UP;
// } else if(dir[1] > 0) {
// entity->direction = DIRECTION_DOWN;
// } else {
// entity->direction = DIRECTION_RIGHT;
// }
// }
// } else if(dir[0] < 0) {
// if(entity->direction == DIRECTION_LEFT) {
// entity->direction = DIRECTION_LEFT;
// } else {
// if(dir[1] < 0) {
// entity->direction = DIRECTION_UP;
// } else if(dir[1] > 0) {
// entity->direction = DIRECTION_DOWN;
// } else {
// entity->direction = DIRECTION_LEFT;
// }
// }
// } else if(dir[1] < 0) {
// entity->direction = DIRECTION_UP;
// } else if(dir[1] > 0) {
// entity->direction = DIRECTION_DOWN;
// }
}
void playerInteraction(entity_t *entity) {
assertNotNull(entity, "Entity pointer cannot be NULL");
// assertNotNull(entity, "Entity pointer cannot be NULL");
if(!inputPressed(INPUT_ACTION_ACCEPT)) return;
// if(!inputPressed(INPUT_ACTION_ACCEPT)) return;
physicsbox_t interactBox;
// physicsbox_t interactBox;
// Get direction vector
directionGetVec2(entity->direction, interactBox.min);
// // Get direction vector
// directionGetVec2(entity->direction, interactBox.min);
// Scale by interact range
glm_vec2_scale(interactBox.min, PLAYER_INTERACTION_RANGE, interactBox.min);
// // Scale by interact range
// glm_vec2_scale(interactBox.min, PLAYER_INTERACTION_RANGE, interactBox.min);
// Add entity position, this makes the center of the box.
glm_vec2_add(interactBox.min, entity->position, interactBox.min);
// // Add entity position, this makes the center of the box.
// glm_vec2_add(interactBox.min, entity->position, interactBox.min);
// Copy to max
glm_vec2_copy(interactBox.min, interactBox.max);
// // Copy to max
// glm_vec2_copy(interactBox.min, interactBox.max);
// Size of the hitbox
vec2 halfSize = {
TILESET_ENTITIES.tileWidth * PLAYER_INTERACTION_SIZE * 0.5f,
TILESET_ENTITIES.tileHeight * PLAYER_INTERACTION_SIZE * 0.5f
};
// // Size of the hitbox
// vec2 halfSize = {
// TILESET_ENTITIES.tileWidth * PLAYER_INTERACTION_SIZE * 0.5f,
// TILESET_ENTITIES.tileHeight * PLAYER_INTERACTION_SIZE * 0.5f
// };
// Subtract from min, add to max.
glm_vec2_sub(interactBox.min, halfSize, interactBox.min);
glm_vec2_add(interactBox.max, halfSize, interactBox.max);
// // Subtract from min, add to max.
// glm_vec2_sub(interactBox.min, halfSize, interactBox.min);
// glm_vec2_add(interactBox.max, halfSize, interactBox.max);
// For each entity
entity_t *start = entity->map->entities;
entity_t *end = &entity->map->entities[entity->map->entityCount];
vec2 otherSize = { TILESET_ENTITIES.tileWidth, TILESET_ENTITIES.tileHeight };
physicsbox_t otherBox;
physicsboxboxresult_t result;
// // For each entity
// entity_t *start = entity->map->entities;
// entity_t *end = &entity->map->entities[entity->map->entityCount];
// vec2 otherSize = { TILESET_ENTITIES.tileWidth, TILESET_ENTITIES.tileHeight };
// physicsbox_t otherBox;
// physicsboxboxresult_t result;
do {
if(start->type != ENTITY_TYPE_NPC) continue;
// do {
// if(start->type != ENTITY_TYPE_NPC) continue;
// Setup other box.
glm_vec2_copy(start->position, otherBox.min);
glm_vec2_copy(start->position, otherBox.max);
glm_vec2_sub(otherBox.min, otherSize, otherBox.min);
glm_vec2_add(otherBox.min, otherSize, otherBox.max);
// // Setup other box.
// glm_vec2_copy(start->position, otherBox.min);
// glm_vec2_copy(start->position, otherBox.max);
// glm_vec2_sub(otherBox.min, otherSize, otherBox.min);
// glm_vec2_add(otherBox.min, otherSize, otherBox.max);
physicsBoxCheckBox(interactBox, otherBox, &result);
if(!result.hit) continue;
// physicsBoxCheckBox(interactBox, otherBox, &result);
// if(!result.hit) continue;
printf("Interacted with entity at (%.2f, %.2f)\n", start->position[0], start->position[1]);
break;
} while(++start != end);
// printf("Interacted with entity at (%.2f, %.2f)\n", start->position[0], start->position[1]);
// break;
// } while(++start != end);
}

10
src/rpg/rpg.c
View File

@@ -6,13 +6,21 @@
*/
#include "rpg.h"
#include "entity/entity.h"
errorret_t rpgInit(void) {
// TEST
entityInit(&ENTITIES[0], ENTITY_TYPE_PLAYER);
errorOk();
}
void rpgUpdate(void) {
entity_t *ent = &ENTITIES[0];
do {
if(ent->type == ENTITY_TYPE_NULL) continue;
entityUpdate(ent);
} while(++ent < &ENTITIES[ENTITY_COUNT]);
}
void rpgDispose(void) {

1
src/scene/scene.h
View File

@@ -21,5 +21,4 @@ typedef struct {
void (*render)(scenedata_t *data);
void (*dispose)(scenedata_t *data);
uint8_t flags;
color_t background;
} scene_t;

1
src/scene/scene/CMakeLists.txt
View File

@@ -7,6 +7,7 @@
target_sources(${DUSK_TARGET_NAME}
PRIVATE
scenetest.c
scenemap.c
)
# Subdirs

22
src/scene/scene/scenemap.c Normal file
View File

@@ -0,0 +1,22 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "scenemap.h"
errorret_t sceneMapInit(scenedata_t *data) {
errorOk();
}
void sceneMapUpdate(scenedata_t *data) {
}
void sceneMapRender(scenedata_t *data) {
}
void sceneMapDispose(scenedata_t *data) {
}

27
src/scene/scene/scenemap.h Normal file
View File

@@ -0,0 +1,27 @@
/**
* Copyright (c) 2025 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "scene/scene.h"
typedef struct {
int32_t nothing;
} scenemap_t;
errorret_t sceneMapInit(scenedata_t *data);
void sceneMapUpdate(scenedata_t *data);
void sceneMapRender(scenedata_t *data);
void sceneMapDispose(scenedata_t *data);
static scene_t SCENE_MAP = {
.name = "map",
.init = sceneMapInit,
.update = sceneMapUpdate,
.render = sceneMapRender,
.dispose = sceneMapDispose,
.flags = 0
};

2
src/scene/scenedata.h
View File

@@ -9,9 +9,11 @@
#include "scene/scene.h"
#include "scene/scene/scenetest.h"
#include "scene/scene/scenemap.h"
typedef struct scenedata_s {
union {
scenetest_t sceneTest;
scenemap_t sceneMap;
};
} scenedata_t;

6
src/scene/scenemanager.c
View File

@@ -18,6 +18,7 @@ errorret_t sceneManagerInit(void) {
memoryZero(&SCENE_MANAGER, sizeof(scenemanager_t));
sceneManagerRegisterScene(&SCENE_TEST);
sceneManagerRegisterScene(&SCENE_MAP);
errorOk();
}
@@ -91,11 +92,6 @@ void sceneManagerRender(void) {
SCENE_MANAGER.current->flags & SCENE_FLAG_INITIALIZED,
"Current scene not initialized"
);
frameBufferClear(
FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH,
SCENE_MANAGER.current->background
);
if(SCENE_MANAGER.current->render) {
SCENE_MANAGER.current->render(&SCENE_MANAGER.sceneData);

42
src/ui/ui.c
View File

@@ -6,21 +6,59 @@
*/
#include "ui.h"
#include "ui/uiconsole.h"
#include "ui/uifps.h"
#include "util/memory.h"
#include "display/tileset/tileset_minogram.h"
#include "display/screen.h"
ui_t UI;
void uiInit(void) {
errorret_t uiInit(void) {
memoryZero(&UI, sizeof(ui_t));
cameraInitOrthographic(&UI.camera);
// Initialize UI components here
uiSetFont(&TILESET_MINOGRAM);
errorOk();
}
void uiUpdate(void) {
// Update UI state here
UI.camera.orthographic.left = 0;
UI.camera.orthographic.right = SCREEN.width;
UI.camera.orthographic.top = 0;
UI.camera.orthographic.bottom = SCREEN.height;
}
void uiRender(void) {
cameraPushMatrix(&UI.camera);
// Render UI elements here
if(UI.font) {
uiConsoleRender(0, 0, UI.fontTileset, &UI.font->alphaImage.texture);
uiFPSRender(UI.fontTileset, &UI.font->alphaImage.texture);
}
cameraPopMatrix();
}
errorret_t uiSetFont(const tileset_t *fontTileset) {
if(UI.font) {
assetUnlock(UI.font, UI.fontRef);
UI.font = NULL;
}
UI.fontTileset = fontTileset;
assetManagerLoadAsset(fontTileset->image, &UI.font, &UI.fontRef);
}
void uiDispose(void) {
// Clean up UI resources here
if(UI.font) {
assetUnlock(UI.font, UI.fontRef);
UI.font = NULL;
}
}

22
src/ui/ui.h
View File

@@ -7,17 +7,26 @@
#pragma once
#include "dusk.h"
#include "asset/assetmanager.h"
#include "display/tileset/tileset.h"
#include "display/camera.h"
typedef struct {
int32_t nothing;
camera_t camera;
ref_t fontRef;
asset_t *font;
const tileset_t *fontTileset;
} ui_t;
extern ui_t UI;
/**
* Initializes the UI system, loading necessary resources.
*
* @return An errorret_t indicating success or failure.
*/
void uiInit(void);
errorret_t uiInit(void);
/**
* Updates the UI state, handling user interactions and animations.
@@ -29,6 +38,15 @@ void uiUpdate(void);
*/
void uiRender(void);
/**
* Sets the font tileset for UI text rendering.
*
* @param fontTileset Pointer to the tileset to use for UI fonts.
*
* @return An errorret_t indicating success or failure.
*/
errorret_t uiSetFont(const tileset_t *fontTileset);
/**
* Cleans up and frees all UI resources.
*/

2
src/ui/uiconsole.c
View File

@@ -26,7 +26,7 @@ void uiConsoleRender(
continue;
}
uiTextDraw(
x, y + (i * TILESET_MINOGRAM.tileHeight),
x, y + (i * tileset->tileHeight),
line, COLOR_WHITE,
tileset, texture
);

6
src/ui/uifps.c
View File

@@ -10,7 +10,8 @@
#include "console/console.h"
#include "util/string.h"
#include "ui/uitext.h"
#include "display/framebuffer.h"
#include "display/screen.h"
#include "display/spritebatch.h"
void uiFPSRender(const tileset_t *tileset, texture_t *texture) {
if(stringCompare(consoleVarGet("fps")->value, "0") == 0) {
@@ -36,7 +37,8 @@ void uiFPSRender(const tileset_t *tileset, texture_t *texture) {
int32_t w, h;
uiTextMeasure(buffer, tileset, &w, &h);
uiTextDraw(
frameBufferGetWidth(FRAMEBUFFER_BOUND) - w, 0,
SCREEN.width - w, 0,
buffer, color, tileset, texture
);
spriteBatchFlush();
}