int rsys_destroy(struct rsys* rsys)
{
if(rsys->magic != OCN_MAGIC)
return OCN_FAIL;
rsys_worker_req_quit(rsys);
rsys_render_req_quit(rsys);
//ocn_thread_join(&rsys->render_thread);
//ocn_thread_join(&rsys->worker_thread);
/* render requests */
ocn_spin_destroy(&rsys->render_reqs_lock);
rsys_req_t* req;
while(queue_pull(&rsys->render_reqs, (void*)&req) != OCN_FAIL)
ocn_free(req);
/* worker requests */
ocn_spin_destroy(&rsys->worker_reqs_lock);
while(queue_pull(&rsys->render_reqs, (void*)&req) != OCN_FAIL)
ocn_free(req);
/* ro_assets */
ocn_spin_destroy(&rsys->ro_assets_lock);
for(uint64_t u = 0lu; u < OCN_MAX_ASSETS; u++)
if(rsys->ro_assets[u].flags != 0lu)
ro_asset_dest(&rsys->ro_assets[u].ro_asset);
/* ro_entities */
ocn_spin_destroy(&rsys->ro_entities_lock);
for(uint64_t u = 0lu; u < OCN_MAX_ENTITIES; u++)
if(rsys->ro_entities[u].flags != 0lu)
ro_entity_dest(&rsys->ro_entities[u].ro_entity);
rsys->magic = 0;
return OCN_OK;
}
void* rsys_worker(void* ptr)
{
struct rsys* rsys = ptr;
int running = 1;
int nsec = 0;
while(running)
{
/* Pull one item from worker-request queue */
/* after that check if there is at least one
more item in it. If no, set msec to IDLE_TIME,
else set msec to 0. */
/* do what request want and push it to render_queue */
/* wait */
rsys_req_t* req = NULL;
ocn_spin_lock(&rsys->worker_reqs_lock);
queue_pull(&rsys->worker_reqs, (void*)&req);
ocn_spin_unlock(&rsys->worker_reqs_lock);
if(req != NULL)
{
switch(req->type)
{
case RSYS_REQ_TYPE_QUIT:
running = 0;
break;
default:
break;
}
ocn_free(req);
nsec = 0;
}
else
{
nsec = RSYS_IDLE_TIME;
}
ocn_wait(nsec);
}
}
int main(int argc, char *argv[]) {
printf("Preparing vars to load...\n");
void *var1 = (void*)malloc(sizeof(int));
*((int*)var1) = 20;
void *var2 = (void*)malloc(sizeof(int));
*((int*)var2) = 44;
void *var3 = (void*)malloc(sizeof(int));
*((int*)var3) = 44;
void *var4 = (void*)malloc(sizeof(int));
*((int*)var4) = 44;
void *var5 = (void*)malloc(sizeof(int));
*((int*)var5) = 44;
void *var6 = (void*)malloc(sizeof(int));
*((int*)var6) = 44;
void *var7 = (void*)malloc(sizeof(int));
*((int*)var7) = 12;
printf("Done.\n");
/* List Test */
printf("Beginning list test...\n");
List *myList = (List*)malloc(sizeof(List));
myList = create_list();
list_push_front(myList, var1);
list_push_front(myList, var2);
list_push_front(myList, var3);
list_push_front(myList, var4);
list_push_front(myList, var5);
list_push_front(myList, var6);
list_push_front(myList, var7);
for(int i = 0; i < 7; i++) {
int *var = ((int*)list_pop_front(myList));
printf("Var: %d\n", *var);
}
printf("List test done.\n");
/* Vector Test */
printf("Beginning vector test...\n");
Vector *myVector;
myVector = vector_create();
vector_append(myVector, var1);
vector_append(myVector, var2);
vector_append(myVector, var3);
vector_append(myVector, var4);
vector_append(myVector, var5);
vector_append(myVector, var6);
vector_append(myVector, var7);
for(int i = 0; i < 7; i++) {
int *var = ((int*)vector_get(myVector, i));
printf("Var: %d\n", *var);
}
printf("Vector test done.\n");
/* Queue Test */
printf("Beginning queue test...\n");
Queue *myQueue = (Queue*)malloc(sizeof(Queue*));
queue_init(myQueue, 10);
queue_push(myQueue, var1);
queue_push(myQueue, var2);
queue_push(myQueue, var3);
queue_push(myQueue, var4);
queue_push(myQueue, var5);
queue_push(myQueue, var6);
queue_push(myQueue, var7);
for(int i = 0; i < 7; i++) {
int *var = ((int*)queue_pull(myQueue));
printf("Var: %d\n", *var);
}
printf("Queue test done.\n");
/* Stack Test */
printf("Beginning stack test...\n");
Stack *myStack = (Stack*)malloc(sizeof(Stack));
Arr_Stack *myArrStack = (Arr_Stack*)malloc(sizeof(Arr_Stack));
printf("Stack test done.\n");
arr_stack_init(myArrStack, 10);
arr_stack_push(myArrStack, var1);
arr_stack_push(myArrStack, var2);
arr_stack_push(myArrStack, var3);
arr_stack_push(myArrStack, var4);
arr_stack_push(myArrStack, var5);
arr_stack_push(myArrStack, var6);
arr_stack_push(myArrStack, var7);
for(int i = 0; i < 7; i++) {
int *var = ((int*)arr_stack_pull(myArrStack));
printf("Var: %d\n", *var);
}
list_destroy(myList);
vector_destroy(myVector);
queue_destroy(myQueue);
arr_stack_destroy(myArrStack);
return 0;
}
void* rsys_render(void* ptr)
{
/*
I didn't want to use any locks in here, but
it's impossible without. So ... one lock is
needed for the queue, and one for the flags
of the renderer.
*/
struct rsys* rsys = ptr;
/* make ctt1 the context for this thread */
if(rsys->table.ctt1_make != NULL)
rsys->table.ctt1_make();
int running = 1;
while(running)
{
frame_begin(&rsys->frame);
/* ### FRAME BEGIN ### */
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glClearColor(rsys->bg_red, rsys->bg_green, rsys->bg_blue, 1.0f); /* read from rsys instead of this */
//glUseProgram(rsys->vsh);
//glUseProgram(rsys->fsh);
/* pull one request from queue per frame */
rsys_req_t* req = NULL;
ocn_spin_lock(&rsys->render_reqs_lock);
queue_pull(&rsys->render_reqs, (void*)&req);
ocn_spin_unlock(&rsys->render_reqs_lock);
/*
Requests with token equal to 0 are NOT! treated special.
The request struct uses a flag field now ...
*/
if(req != NULL)
{
if(FLAG_GET(req->flags, RSYS_REQ_RENDERER))
{
switch(req->type)
{
case RSYS_REQ_TYPE_QUIT:
running = 0;
break;
case RSYS_REQ_TYPE_BG:
break;
case RSYS_REQ_TYPE_ADD:
/* add to render list */
break;
default:
break;
}
}
}
LIST_FOREACH_BEGIN(&rsys->ros)
ro_entity_t* ro = LIST_ENTRY_DATA;
if(req != NULL)
{
if(!FLAG_GET(req->flags, RSYS_REQ_RENDERER))
{
if(ro->token == req->token)
{
switch(req->type)
{
case RSYS_REQ_TYPE_DEL:
break;
case RSYS_REQ_TYPE_MAP:
break;
case RSYS_REQ_TYPE_UNMAP:
break;
default:
break;
}
}
}
}
/* call render function */
/*
switch(ro->type)
{
case RO_TYPE_STATIC_MESH:
ro_static_mesh_render(&ro->static_mesh);
break;
default:
break;
}
*/
LIST_FOREACH_END
// bad idea... but for now we leave this like this
// we could make a second queue for cleaning up requests
free(req);
if(rsys->table.win_swap != NULL)
rsys->table.win_swap();
/* call frame callback */
//if(ocn.funcs.frame_callback != NULL)
// ocn.funcs.frame_callback(0);
/* ### FRAME END ### */
frame_wait(&rsys->frame);
frame_end (&rsys->frame);
frame_calc(&rsys->frame);
}
return NULL;
}
