#define VG_GAME
#include "vg/vg.h"
-VG_STATIC void vg_assert_thread( enum vg_thread_purpose required );
+static void vg_assert_thread( enum vg_thread_purpose required );
typedef struct vg_async_item vg_async_item;
}
static vg_async;
-VG_STATIC enum vg_thread_purpose vg_thread_purpose(void);
-VG_STATIC enum engine_status _vg_engine_status(void);
+static enum vg_thread_purpose vg_thread_purpose(void);
+static enum engine_status _vg_engine_status(void);
/*
* Allocate an asynchronous call with a bit of memory
*/
-VG_STATIC vg_async_item *vg_async_alloc( u32 size )
+static vg_async_item *vg_async_alloc( u32 size )
{
/* ditch out here if engine crashed. this serves as the 'quit checking' */
if( _vg_engine_status() == k_engine_status_crashed ){
/*
* Wait until the current stack of async calls is completely flushed out
*/
-VG_STATIC void vg_async_stall(void)
+static void vg_async_stall(void)
{
vg_assert_thread(k_thread_purpose_loader);
vg_info( "async_stall: %d\n", SDL_SemValue( vg_async.sem_wait_for_flush ) );
/*
* Mark the call as being filled and ready to go
*/
-VG_STATIC void vg_async_dispatch( vg_async_item *item,
+static void vg_async_dispatch( vg_async_item *item,
void (*runner)( void *payload, u32 size ) )
{
vg_assert_thread(k_thread_purpose_loader);
/*
* Make a simple async call without allocating extra.
*/
-VG_STATIC void vg_async_call( void (*runner)( void *payload, u32 size ),
+static void vg_async_call( void (*runner)( void *payload, u32 size ),
void *payload, u32 size )
{
vg_assert_thread(k_thread_purpose_loader);
/*
* Run as much of the async buffer as possible
*/
-VG_STATIC void vg_run_async_checked(void)
+static void vg_run_async_checked(void)
{
SDL_AtomicLock( &vg_async.sl_index );
SDL_AtomicUnlock( &vg_async.sl_index );
}
-VG_STATIC void vg_async_init(void)
+static void vg_async_init(void)
{
vg_async.sem_wait_for_flush = SDL_CreateSemaphore(0);
vg_async.buffer = vg_create_linear_allocator( NULL, 50*1024*1024,