sadpmpk
/
HATPC
1
0
Fork 0
Code Issues 11 Pull Requests Projects 4 Releases Wiki Activity

Implement test scene 

Internal Changelog:
- Update BBox component to use Vector2
- Add new CTransform component
- Implement level scene movement system and render system
- Implement scene test procedure
scene_man
En Yi 2022-12-05 12:20:00 +08:00
parent 6c03078db9
commit b392e462b7
7 changed files with 109 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -7,8 +7,6 @@ set(CMAKE_C_STANDARD 99)
set(RAYLIB_DIR $ENV{HOME}/Documents/Coding/raylib/out/)
add_subdirectory(sc)
add_executable(${PROJECT_NAME}
main.c

17
components.h
View File

@ -1,20 +1,25 @@
#ifndef __COMPONENTS_H
#define __COMPONENTS_H
#include "raylib.h"
// TODO: Look at sc to use macros to auto generate functions
#define N_COMPONENTS 1
#define N_COMPONENTS 2
enum ComponentEnum
{
CBBOX_COMP_T,
CTRANSFORM_COMP_T,
};
typedef enum ComponentEnum ComponentEnum_t;
typedef struct _CBBox_t
{
int x;
int y;
int width;
int height;
Vector2 size;
}CBBox_t;
typedef struct _CTransform_t
{
Vector2 position;
Vector2 velocity;
Vector2 accel;
}CTransform_t;
#endif // __COMPONENTS_H

8
entManager_test.c
View File

@ -13,10 +13,10 @@ int main(void)
puts("Creating two entities");
Entity_t *p_ent = add_entity(&manager, PLAYER_ENT_TAG);
CBBox_t * p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
p_bbox->x = 15;
p_bbox->size.x = 15;
p_ent = add_entity(&manager, ENEMY_ENT_TAG);
p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
p_bbox->x = 40;
p_bbox->size.y = 40;
update_entity_manager(&manager);
puts("Print and remove the entities");
@ -24,7 +24,7 @@ int main(void)
sc_map_foreach(&manager.entities, idx, p_ent)
{
p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
printf("BBOX x: %d\n", p_bbox->x);
printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
remove_entity(&manager, idx);
}
puts("");
@ -34,7 +34,7 @@ int main(void)
sc_map_foreach(&manager.entities, idx, p_ent)
{
p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
printf("BBOX x: %d\n", p_bbox->x);
printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
remove_entity(&manager, idx);
}
puts("");

1
lsan_supp.txt 100644
View File

@ -0,0 +1 @@
leak:X11

41
mempool.c
View File

@ -2,6 +2,8 @@
#include "sc/queue/sc_queue.h"
#include "sc/map/sc_map.h"
// BIG TODO: REWORK THE MEMPOOL FOR COMPONENT AS IT IS NOT SCALABLE
// Use hashmap as a Set
// Use list will be used to check if an object exist
// The alternative method to check the free list if idx is not there
@ -22,18 +24,32 @@ static struct BBoxMemPool
struct sc_queue_uint free_list;
}bbox_mem_pool;
static struct CTransformMemPool
{
CBBox_t ctransform_buffer[MAX_COMP_POOL_SIZE];
struct sc_map_64 use_list;
struct sc_queue_uint free_list;
}ctransform_mem_pool;
static bool pool_inited = false;
void init_memory_pools(void)
{
if (!pool_inited)
{
memset(bbox_mem_pool.bbox_buffer, 0, sizeof(bbox_mem_pool.bbox_buffer));
memset(ctransform_mem_pool.ctransform_buffer, 0, sizeof(ctransform_mem_pool.ctransform_buffer));
memset(entity_mem_pool.entity_buffer, 0, sizeof(entity_mem_pool.entity_buffer));
sc_queue_init(&bbox_mem_pool.free_list);
for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
{
sc_queue_add_last(&(bbox_mem_pool.free_list), i);
}
sc_queue_init(&ctransform_mem_pool.free_list);
for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
{
sc_queue_add_last(&(ctransform_mem_pool.free_list), i);
}
sc_queue_init(&entity_mem_pool.free_list);
for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
{
@ -41,7 +57,9 @@ void init_memory_pools(void)
sc_map_init_64(&entity_mem_pool.entity_buffer[i].components, 16 ,0);
sc_queue_add_last(&(entity_mem_pool.free_list), i);
}
sc_map_init_64(&bbox_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
sc_map_init_64(&ctransform_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
sc_map_init_64(&entity_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
pool_inited = true;
}
@ -52,9 +70,13 @@ void free_memory_pools(void)
if (pool_inited)
{
sc_map_term_64(&bbox_mem_pool.use_list);
sc_map_term_64(&ctransform_mem_pool.use_list);
sc_map_term_64(&entity_mem_pool.use_list);
sc_queue_term(&bbox_mem_pool.free_list);
sc_queue_term(&ctransform_mem_pool.free_list);
sc_queue_term(&entity_mem_pool.free_list);
for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
{
sc_map_term_64(&entity_mem_pool.entity_buffer[i].components);
@ -104,6 +126,13 @@ void* new_component_from_mempool(ComponentEnum_t comp_type, unsigned long *idx)
comp = bbox_mem_pool.bbox_buffer + *idx;
memset(comp, 0, sizeof(CBBox_t));
break;
case CTRANSFORM_COMP_T:
if(sc_queue_empty(&ctransform_mem_pool.free_list)) break;
*idx = sc_queue_del_first(&ctransform_mem_pool.free_list);
sc_map_put_64(&ctransform_mem_pool.use_list, *idx, *idx);
comp = ctransform_mem_pool.ctransform_buffer + *idx;
memset(comp, 0, sizeof(CTransform_t));
break;
default:
break;
}
@ -120,6 +149,11 @@ void* get_component_wtih_id(ComponentEnum_t comp_type, unsigned long idx)
if (!sc_map_found(&bbox_mem_pool.use_list)) break;
comp = bbox_mem_pool.bbox_buffer + idx;
break;
case CTRANSFORM_COMP_T:
sc_map_get_64(&ctransform_mem_pool.use_list, idx);
if (!sc_map_found(&ctransform_mem_pool.use_list)) break;
comp = ctransform_mem_pool.ctransform_buffer + idx;
break;
default:
break;
}
@ -138,6 +172,13 @@ void free_component_to_mempool(ComponentEnum_t comp_type, unsigned long idx)
sc_queue_add_first(&bbox_mem_pool.free_list, idx);
}
break;
case CTRANSFORM_COMP_T:
sc_map_del_64(&ctransform_mem_pool.use_list, idx);
if (sc_map_found(&ctransform_mem_pool.use_list))
{
sc_queue_add_first(&ctransform_mem_pool.free_list, idx);
}
break;
default:
break;
}

25
scene_impl.c
View File

@ -1,14 +1,37 @@
#include "scene_impl.h"
#include "raylib.h"
#include "raymath.h"
#include <stdio.h>
static void level_scene_render_func(Scene_t* scene)
{
Entity_t *p_ent;
sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
{
CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, RED);
}
return;
}
static void movement_update_system(Scene_t* scene)
{
return;
puts("Updating movement");
float delta_time = GetFrameTime();
CTransform_t * p_ctransform;
sc_map_foreach_value(&scene->ent_manager.component_map[CTRANSFORM_COMP_T], p_ctransform)
{
p_ctransform->velocity = Vector2Add(
p_ctransform->velocity,
Vector2Scale(p_ctransform->accel, delta_time)
);
p_ctransform->position = Vector2Add(
p_ctransform->position,
Vector2Scale(p_ctransform->velocity, delta_time)
);
}
}
void init_level_scene(LevelScene_t *scene)
{

29
scene_test.c
View File

@ -1,11 +1,38 @@
#include "mempool.h"
#include "scene_impl.h"
#include <stdio.h>
#include <unistd.h>
int main(void)
{
InitWindow(320, 240, "raylib");
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
init_memory_pools();
LevelScene_t scene;
init_level_scene(&scene);
update_scene(&scene.scene);
Entity_t *p_ent = add_entity(&scene.scene.ent_manager, PLAYER_ENT_TAG);
CBBox_t *p_bbox = add_component(&scene.scene.ent_manager, p_ent, CBBOX_COMP_T);
p_bbox->size.x = 30;
p_bbox->size.y = 30;
CTransform_t * p_ctran = (CTransform_t *)add_component(&scene.scene.ent_manager, p_ent, CTRANSFORM_COMP_T);
p_ctran->accel.x = 20;
p_ctran->accel.y = 10;
update_entity_manager(&scene.scene.ent_manager);
for (size_t step = 0; step < 120; step++)
{
puts("======");
printf("Step %lu\n", step);
update_scene(&scene.scene);
printf("Position: %f,%f\n", p_ctran->position.x, p_ctran->position.y);
printf("Velocity: %f,%f\n", p_ctran->velocity.x, p_ctran->velocity.y);
printf("Accel: %f,%f\n", p_ctran->accel.x, p_ctran->accel.y);
// This is needed to advance time delta
BeginDrawing();
// TODO: Call the current scene Render function
render_scene(&scene.scene);
ClearBackground(RAYWHITE);
EndDrawing();
}
CloseWindow();
free_level_scene(&scene);
}