From: hgn <hgodden00@gmail.com>
Date: Wed, 5 Apr 2023 01:30:20 +0000 (+0100)
Subject: adwadwa
X-Git-Url: https://harrygodden.com/git/?p=vg.git;a=commitdiff_plain;h=8110d74786fb065c0e69f1e171a69e519c3f8c74

adwadwa
---

diff --git a/vg.h b/vg.h
index eb858a3..64b6f6f 100644
--- a/vg.h
+++ b/vg.h
@@ -635,8 +635,7 @@ VG_STATIC void _vg_init_window( const char *window_name )
 {
    vg_info( "SDL_INIT\n" );
 
-   if( SDL_Init( SDL_INIT_VIDEO ) != 0  )
-   {
+   if( SDL_Init( SDL_INIT_VIDEO ) != 0  ){
       vg_error( "SDL_Init failed: %s\n", SDL_GetError() );
       exit(0);
    }
@@ -664,8 +663,7 @@ VG_STATIC void _vg_init_window( const char *window_name )
     */
    vg_info( "Getting display count\n" );
    int display_count = 0, display_index = 0, mode_index = 0;
-   if( (display_count = SDL_GetNumVideoDisplays()) < 1 )
-   {
+   if( (display_count = SDL_GetNumVideoDisplays()) < 1 ){
       vg_error( "SDL_GetNumVideoDisplays returned: %i\n", display_count );
       exit(0);
    }
@@ -820,22 +818,8 @@ VG_STATIC void vg_enter( int argc, char *argv[], const char *window_name )
    SDL_Quit();
 }
 
-/*
- * Immediately transfer away from calling thread into a safe loop, signal for 
- * others to shutdown, then free everything once the user closes the window.
- *
- * FIXME(bug): glfwWindowShouldClose() never returns 1 in windows via wine, ONLY
- *             when calling the program from outside its normal directory.
- */
-VG_STATIC void vg_fatal_exit_loop( const char *error )
+void vg_print_backtrace(void)
 {
-   /* 
-    *    https://www.gnu.org/software/libc/manual/html_node/Backtraces.html
-    *    thanks gnu <3
-    *
-    *    TODO: this on windows?
-    */
-
 #ifndef _WIN32
 
    void *array[20];
@@ -858,7 +842,25 @@ VG_STATIC void vg_fatal_exit_loop( const char *error )
    free( strings );
 
 #endif
+}
+
+/*
+ * Immediately transfer away from calling thread into a safe loop, signal for 
+ * others to shutdown, then free everything once the user closes the window.
+ *
+ * FIXME(bug): glfwWindowShouldClose() never returns 1 in windows via wine, ONLY
+ *             when calling the program from outside its normal directory.
+ */
+VG_STATIC void vg_fatal_exit_loop( const char *error )
+{
+   /* 
+    *    https://www.gnu.org/software/libc/manual/html_node/Backtraces.html
+    *    thanks gnu <3
+    *
+    *    TODO: this on windows?
+    */
 
+   vg_print_backtrace();
    vg_error( "Fatal error: %s\n", error );
 
    SDL_AtomicLock( &vg.sl_context );
diff --git a/vg_audio.h b/vg_audio.h
index 8f68f82..75a8c7e 100644
--- a/vg_audio.h
+++ b/vg_audio.h
@@ -106,8 +106,8 @@ static struct vg_audio_system{
    /* synchro */
    int               sync_locked;
 
-   SDL_mutex        *mux_checker,
-                    *mux_sync;
+   SDL_SpinLock     sl_checker,
+                    sl_sync;
 
    struct audio_lfo{
       u32 time, time_startframe;
@@ -193,19 +193,20 @@ static struct vg_audio_system{
    }
    channels[ AUDIO_CHANNELS ];
 
-   /* System queue, and access from thread 0 */
    int               debug_ui, debug_ui_3d;
 
-   v3f               listener_pos,
-                     listener_ears,
-                     listener_velocity;
+   v3f               internal_listener_pos,
+                     internal_listener_ears,
+                     internal_listener_velocity,
 
-   float             volume,
-                     volume_target,
-                     volume_target_internal,
-                     volume_console;
+                     external_listener_pos,
+                     external_listener_ears,
+                     external_lister_velocity;
+
+   float             internal_global_volume,
+                     external_global_volume;
 }
-vg_audio = { .volume_console = 1.0f };
+vg_audio = { .external_global_volume = 1.0f };
 
 #include "vg/vg_audio_dsp.h"
 
@@ -227,17 +228,17 @@ static struct vg_profile
 VG_STATIC int audio_lock_checker_load(void)
 {
    int value;
-   SDL_LockMutex( vg_audio.mux_checker );
+   SDL_AtomicLock( &vg_audio.sl_checker );
    value = vg_audio.sync_locked;
-   SDL_UnlockMutex( vg_audio.mux_checker );
+   SDL_AtomicUnlock( &vg_audio.sl_checker );
    return value;
 }
 
 VG_STATIC void audio_lock_checker_store( int value )
 {
-   SDL_LockMutex( vg_audio.mux_checker );
+   SDL_AtomicLock( &vg_audio.sl_checker );
    vg_audio.sync_locked = value;
-   SDL_UnlockMutex( vg_audio.mux_checker );
+   SDL_AtomicUnlock( &vg_audio.sl_checker );
 }
 
 VG_STATIC void audio_require_lock(void)
@@ -251,22 +252,19 @@ VG_STATIC void audio_require_lock(void)
 
 VG_STATIC void audio_lock(void)
 {
-   SDL_LockMutex( vg_audio.mux_sync );
+   SDL_AtomicLock( &vg_audio.sl_sync );
    audio_lock_checker_store(1);
 }
 
 VG_STATIC void audio_unlock(void)
 {
    audio_lock_checker_store(0);
-   SDL_UnlockMutex( vg_audio.mux_sync );
+   SDL_AtomicUnlock( &vg_audio.sl_sync );
 }
 
 VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int frame_count );
 VG_STATIC void vg_audio_init(void)
 {
-   vg_audio.mux_checker = SDL_CreateMutex();
-   vg_audio.mux_sync = SDL_CreateMutex();
-
    /* TODO: Move here? */
    vg_var_push( (struct vg_var){
       .name = "debug_audio",
@@ -278,7 +276,7 @@ VG_STATIC void vg_audio_init(void)
 
    vg_var_push( (struct vg_var){
       .name = "volume",
-      .data = &vg_audio.volume_console,
+      .data = &vg_audio.external_global_volume,
       .data_type = k_var_dtype_f32,
       .opt_f32 = { .min=0.0f, .max=2.0f, .clamp=1 },
       .persistent = 1
@@ -373,6 +371,12 @@ static void audio_channel_init( audio_channel *ch, audio_clip *clip, u32 flags )
    ch->editble_state_write_mask = 0x00;
 }
 
+static void audio_channel_group( audio_channel *ch, u32 group )
+{
+   ch->group = group;
+   ch->colour = ((group * 29986577) & 0x00ffffff) | 0xff000000;
+}
+
 static audio_channel *audio_get_first_idle_channel(void)
 {
    for( int i=0; i<AUDIO_CHANNELS; i++ ){
@@ -389,7 +393,7 @@ static audio_channel *audio_get_first_idle_channel(void)
 static audio_channel *audio_get_group_idle_channel( u32 group, u32 max_count )
 {
    u32 count = 0;
-   audio_channel *dest;
+   audio_channel *dest = NULL;
 
    for( int i=0; i<AUDIO_CHANNELS; i++ ){
       audio_channel *ch = &vg_audio.channels[i];
@@ -818,14 +822,14 @@ static void audio_channel_get_samples( audio_channel *ch,
 
 static void audio_channel_mix( audio_channel *ch, float *buffer )
 {
-   float framevol_l = 1.0f,
-         framevol_r = 1.0f;
+   float framevol_l = vg_audio.internal_global_volume,
+         framevol_r = vg_audio.internal_global_volume;
 
    float frame_samplerate = ch->_.sampling_rate;
 
    if( ch->flags & AUDIO_FLAG_SPACIAL_3D ){
       v3f delta;
-      v3_sub( ch->_.spacial_falloff, vg_audio.listener_pos, delta );
+      v3_sub( ch->_.spacial_falloff, vg_audio.internal_listener_pos, delta );
 
       float dist = v3_length( delta ),
             vol  = vg_maxf( 0.0f, 1.0f - ch->_.spacial_falloff[3]*dist );
@@ -835,18 +839,22 @@ static void audio_channel_mix( audio_channel *ch, float *buffer )
       }
       else{
          v3_muls( delta, 1.0f/dist, delta );
-         float pan = v3_dot( vg_audio.listener_ears, delta );
+         float pan = v3_dot( vg_audio.internal_listener_ears, delta );
          vol = powf( vol, 5.0f );
 
          framevol_l *= (vol * 0.5f) * (1.0f - pan);
          framevol_r *= (vol * 0.5f) * (1.0f + pan);
 
-         const float vs = 323.0f;
-         float doppler = (vs+v3_dot(delta,vg_audio.listener_velocity))/vs;
-               doppler = vg_clampf( doppler, 0.6f, 1.4f );
-               
-         if( fabsf(doppler-1.0f) > 0.01f )
-            frame_samplerate *= doppler;
+         if( !(ch->source->flags & AUDIO_FLAG_NO_DOPPLER) ){
+            const float vs = 323.0f;
+
+            float dv = v3_dot(delta,vg_audio.internal_listener_velocity);
+            float doppler = (vs+dv)/vs;
+                  doppler = vg_clampf( doppler, 0.6f, 1.4f );
+                  
+            if( fabsf(doppler-1.0f) > 0.01f )
+               frame_samplerate *= doppler;
+         }
       }
 
       if( !vg_validf( framevol_l ) ) vg_fatal_exit_loop( "NaN left channel" );
@@ -876,22 +884,9 @@ static void audio_channel_mix( audio_channel *ch, float *buffer )
    const float volume_target = ch->_.volume_target;
 
    for( u32 j=0; j<AUDIO_MIX_FRAME_SIZE; j++ ){
-      /*
-       * there is some REALLY weird behaviour with minss,
-       * i cannot begin to guess what the cause is, but the bahaviour when
-       * the second argument is not 1.0 would seemingly tripple or up to 
-       * eight times this routine.
-       *
-       * the times it would happen are when moving from empty space into areas
-       * with geometry. in the bvh for skate rift.
-       *
-       * it should be completely unrelated to this, but somehow -- it is
-       * effecting the speed of minss. and severely at that too.
-       **/
-
       volume_movement += 1.0f;
       float movement_t = volume_movement * inv_volume_rate;
-            movement_t = vg_minf( volume_movement, 1.0f );
+            movement_t = vg_minf( movement_t, 1.0f );
       volume           = vg_lerpf( volume_start, volume_target, movement_t );
 
       float vol_norm = volume * volume;
@@ -939,6 +934,13 @@ VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int byte_count )
     * Copy data and move edit flags to commit flags
     * ------------------------------------------------------------- */
    audio_lock();
+   
+   v3_copy( vg_audio.external_listener_pos, vg_audio.internal_listener_pos );
+   v3_copy( vg_audio.external_listener_ears, vg_audio.internal_listener_ears );
+   v3_copy( vg_audio.external_lister_velocity, 
+            vg_audio.internal_listener_velocity );
+   vg_audio.internal_global_volume = vg_audio.external_global_volume;
+
    for( int i=0; i<AUDIO_CHANNELS; i++ ){
       audio_channel *ch = &vg_audio.channels[i];
 
@@ -1390,8 +1392,8 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
             v2_add( wpos, (v2f){ 0.5f, 0.5f }, wpos );
             
             ui_rect wr;
-            wr[0] = wpos[0] * vg.window_x;
-            wr[1] = (1.0f-wpos[1]) * vg.window_y;
+            wr[0] = vg_clampf(wpos[0] * vg.window_x, -32000.0f,32000.0f);
+            wr[1] = vg_clampf((1.0f-wpos[1]) * vg.window_y,-32000.0f,32000.0f);
             wr[2] = 100;
             wr[3] = 17;
             
diff --git a/vg_audio_synth_bird.h b/vg_audio_synth_bird.h
index a439354..ff6ef50 100644
--- a/vg_audio_synth_bird.h
+++ b/vg_audio_synth_bird.h
@@ -204,8 +204,7 @@ static u32 synth_bird_get_length_in_samples( struct synth_bird *bird )
 {
    u32 total = 0;
 
-   for( int i=0; i<bird->settings.pattern_length; i ++ )
-   {
+   for( int i=0; i<bird->settings.pattern_length; i ++ ){
       struct synth_bird_signature *sig = &bird->settings.pattern[i];
       
       u32 l = sig->length * (float)BIRD_SAMPLE_RATE,
diff --git a/vg_io.h b/vg_io.h
index d962bc4..a97d20a 100644
--- a/vg_io.h
+++ b/vg_io.h
@@ -36,34 +36,27 @@ VG_STATIC void vg_file_print_invalid( FILE *fp )
 VG_STATIC void *vg_file_read( void *lin_alloc, const char *path, u32 *size )
 {
 	FILE *f = fopen( path, "rb" );
-	if( f )
-	{
+	if( f ){
       void *buffer = vg_linear_alloc( lin_alloc, 0 );
       u64 current = 0;
 
       /* read in chunks */
-      for( u32 i=0; 1; i++ )
-      {
+      for( u32 i=0; 1; i++ ){
          buffer = vg_linear_extend( lin_alloc, buffer, VG_FILE_IO_CHUNK_SIZE );
 
          u64 l = fread( buffer + current, 1, VG_FILE_IO_CHUNK_SIZE, f );
          current += l;
 
-         if( l != VG_FILE_IO_CHUNK_SIZE )
-         {
-            if( feof( f ) )
-            {
+         if( l != VG_FILE_IO_CHUNK_SIZE ){
+            if( feof( f ) ){
                break;
             }
-            else
-            {
-               if( ferror( f ) )
-               {
+            else{
+               if( ferror( f ) ){
                   fclose(f);
                   vg_fatal_exit_loop( "read error" );
                }
-               else
-               {
+               else{
                   fclose(f);
                   vg_fatal_exit_loop( "unknown error codition" );
                }
@@ -71,7 +64,7 @@ VG_STATIC void *vg_file_read( void *lin_alloc, const char *path, u32 *size )
          }
       }
 
-      buffer = vg_linear_resize( lin_alloc, buffer, current );
+      buffer = vg_linear_resize( lin_alloc, buffer, vg_align8(current) );
 		fclose( f );
 
       *size = (u32)current;
diff --git a/vg_loader.h b/vg_loader.h
index 87472b6..ffdd87a 100644
--- a/vg_loader.h
+++ b/vg_loader.h
@@ -183,8 +183,7 @@ VG_STATIC void _vg_render_log(void)
    vg_uictx.cursor[3] = fh;
 	ui_fill_x();
 
-   for( int i=0; i<lines_to_draw; i ++ )
-   {
+   for( int i=0; i<lines_to_draw; i ++ ){
       ptr --;
 
       if( ptr < 0 )
diff --git a/vg_log.h b/vg_log.h
index 5a6ab89..7c6ea43 100644
--- a/vg_log.h
+++ b/vg_log.h
@@ -38,10 +38,8 @@ void _vg_console_append_to_log( const char *str )
 
    char *dest = vg_log.buffer[ vg_log.buffer_line_current ++ ];
 
-   for( int i=0; i<vg_list_size( vg_log.buffer[0] ); i++ )
-   {
-      if( !str[i] || ( i == vg_list_size(vg_log.buffer[0])-1 ) )
-      {
+   for( int i=0; i<vg_list_size( vg_log.buffer[0] ); i++ ){
+      if( !str[i] || ( i == vg_list_size(vg_log.buffer[0])-1 ) ){
          dest[i] = '\0';
          break;
       }
@@ -63,8 +61,7 @@ VG_STATIC void _vg_log_write( FILE *file, const char *prefix,
 	char buffer[ 4096 ];
 	int i, j;
 	
-	for( i=0; i<vg_list_size( buffer ); i ++ )
-	{
+	for( i=0; i<vg_list_size( buffer ); i ++ ){
 		if( prefix[i] )
 			buffer[i] = prefix[i];
 		else 
diff --git a/vg_mem.h b/vg_mem.h
index 9a9b31b..fbebaf8 100644
--- a/vg_mem.h
+++ b/vg_mem.h
@@ -8,6 +8,8 @@
 #include <stdlib.h>
 #include <malloc.h>
 
+void vg_print_backtrace(void);
+
 #define VG_MAX_ALLOCATIONS 128
 #define VG_FUZZ_ALLOCATIONS
 
@@ -115,16 +117,19 @@ static vg_linear_allocator *vg_linear_header( void *data )
 __attribute__((warn_unused_result))
 VG_STATIC void *vg_linear_alloc( void *buffer, u32 size )
 {
-   if( size % 8 )
-   {
+   if( size % 8 ){
       vg_error( "alloc(%u) is not 8 byte aligned\n", size );
+      vg_print_backtrace();
       size = vg_align8( size );
    }
+   if( ((u64)buffer) % 8 ){
+      vg_error( "buffer: %p\n", buffer );
+      vg_fatal_exit_loop( "unaligned buffer" );
+   }
 
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
-   if( (alloc->cur + size) > alloc->size )
-   {
+   if( (alloc->cur + size) > alloc->size ){
       vg_error( "%u + %u > %u\n", alloc->cur, size, alloc->size );
       vg_fatal_exit_loop( "linear allocator overflow" );
    }
@@ -135,34 +140,46 @@ VG_STATIC void *vg_linear_alloc( void *buffer, u32 size )
 
    void *data;
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       data = malloc( size );
 
       vg_allocation_meta *meta = &alloc->alloc_table[ alloc->allocation_count ];
       meta->type = k_allocation_type_block;
       meta->data = data;
    }
-   else
-   {
+   else{
       data = buffer + alloc->cur;
    }
 
+   u8 *bytes = data;
+   for( u32 i=0; i<size; i++ ){
+      bytes[i] = 0xae;
+   }
+
    alloc->allocation_count ++;
    alloc->last_alloc = data;
    alloc->last_alloc_size = size;
    alloc->cur += size;
 
+   if( ((u64)data) % 8 ){
+      vg_fatal_exit_loop( "unaligned" );
+   }
+
    return data;
 }
 
-
 /* resize latest block of memory from linear */
 __attribute__((warn_unused_result))
 VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
 {
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
+   if( newsize % 8 ){
+      vg_error( "alloc(%u) is not 8 byte aligned\n", newsize );
+      vg_print_backtrace();
+      newsize = vg_align8( newsize );
+   }
+
    if( alloc->last_alloc != data )
       vg_fatal_exit_loop( "This block has been fixed!" );
 
@@ -173,8 +190,7 @@ VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
    alloc->cur += newsize;
    alloc->last_alloc_size = newsize;
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       data = realloc( data, newsize );
       if( !data )
          vg_fatal_exit_loop( "realloc failed" );
@@ -183,8 +199,7 @@ VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
       alloc->last_alloc = data;
       return data;
    }
-   else
-   {
+   else{
       return data;
    }
 }
@@ -197,8 +212,7 @@ VG_STATIC void vg_linear_del( void *buffer, void *data )
    if( alloc->last_alloc != data )
       vg_fatal_exit_loop( "This block has been fixed!" );
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       vg_allocation_meta *meta = &alloc->alloc_table[alloc->allocation_count-1];
       if( meta->type == k_allocation_type_linear )
          vg_fatal_exit_loop( "Cannot free a linear allocator in this conext" );
@@ -255,18 +269,14 @@ VG_STATIC void vg_linear_clear( void *buffer )
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
    /* libc mode we recursively free any allocations made */
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
-      for( u32 i=0; i<alloc->allocation_count; i++ )
-      {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
+      for( u32 i=0; i<alloc->allocation_count; i++ ){
          vg_allocation_meta *meta = &alloc->alloc_table[i];
          
-         if( meta->type == k_allocation_type_block )
-         {
+         if( meta->type == k_allocation_type_block ){
             free( meta->data );
          }
-         else
-         {
+         else{
             vg_linear_clear( meta->data );
             vg_linear_allocator *sub = vg_linear_header( meta->data );
 
@@ -292,8 +302,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
    u32 block_size = size + sizeof(vg_linear_allocator);
    
    /* Creating it inside an existing one */
-   if( lin_alloc )
-   {
+   if( lin_alloc ){
       vg_linear_allocator *alloc = vg_linear_header( lin_alloc );
 
       if( alloc->cur + block_size > alloc->size )
@@ -306,8 +315,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
          vg_fatal_exit_loop( "Cannot declare realtime allocator inside systems"
                              " allocator" );
 
-      if( vg_mem.use_libc_malloc )
-      {
+      if( vg_mem.use_libc_malloc ){
          vg_allocation_meta *meta = 
             &alloc->alloc_table[ alloc->allocation_count ];
          
@@ -319,8 +327,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
          meta->data = header+1;
          meta->type = k_allocation_type_linear;
       }
-      else
-      {
+      else{
          header = lin_alloc + alloc->cur;
       }
       
@@ -345,8 +352,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
    header->size = size;
    header->flags = flags;
 
-   if( vg_mem.use_libc_malloc && (flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (flags & VG_MEMORY_SYSTEM) ){
       u32 table_size = sizeof(vg_allocation_meta)*VG_MAX_ALLOCATIONS;
       header->alloc_table = malloc( table_size );
    }
diff --git a/vg_ui.h b/vg_ui.h
index dc0ccee..1e120e2 100644
--- a/vg_ui.h
+++ b/vg_ui.h
@@ -306,14 +306,11 @@ VG_STATIC void _vg_ui_init(void)
    u32 pixels = 0, total = 256*256, data = 0;
    u8 image[256*256];
    
-   while( pixels < total )
-   {
-      for( int b = 31; b >= 0; b-- )
-      {
-         image[ pixels ++ ] = (compressed[data] & (0x1 << b))? 0xff: 0x00;
+   while( pixels < total ){
+      for( int b = 31; b >= 0; b-- ){
+         image[ pixels ++ ] = (compressed[data] & (0x1u << b))? 0xffu: 0x00u;
          
-         if( pixels >= total )
-         {
+         if( pixels >= total ){
             total = 0;
             break;
          }
@@ -653,16 +650,13 @@ VG_STATIC void ui_text( ui_px pos[2],
 	text_cursor[2] = 8*scale;
 	text_cursor[3] = 14*scale;
 
-	while( (c = *(_c ++)) )
-	{
-		if( c == '\n' )
-		{
+	while( (c = *(_c ++)) ){
+		if( c == '\n' ){
 			text_cursor[1] += 14*scale;
 			text_cursor[0] = pos[0] + ui_text_line_offset( _c, scale, align );
 			continue;
 		}
-		else if( c >= 33 )
-		{
+		else if( c >= 33 ){
 			u8 glyph_base[2];
 			u8 glyph_index = c;
 			glyph_base[0] = glyph_index & 0xf;
@@ -679,20 +673,15 @@ VG_STATIC void ui_text( ui_px pos[2],
                glyph_base[1]+8
             });
 		}
-		else if( c == '\x1B' )
-		{
+		else if( c == '\x1B' ){
 			_c ++;
 			u16 colour_id = 0;
-			for( int i = 0; i < 3; i ++ )
-			{
-				if( _c[i] )
-				{
-					if( _c[i] == 'm' )
-					{
+			for( int i = 0; i < 3; i ++ ){
+				if( _c[i] ){
+					if( _c[i] == 'm' ){
 						_c = _c + i + 1;
 						
-						switch( colour_id )
-						{
+						switch( colour_id ){
 							case '0': current_colour = 0x00ffffff; break;
 							case '3'|'1'<<8: current_colour = 0x00201fee; break;
 							case '3'|'2'<<8: current_colour = 0x0037e420; break;
@@ -708,8 +697,7 @@ VG_STATIC void ui_text( ui_px pos[2],
 					
 					colour_id |= _c[i] << (i*8);
 				} 
-				else
-				{
+				else{
 					_c = _c +i;
 					break;
 				}
@@ -717,8 +705,7 @@ VG_STATIC void ui_text( ui_px pos[2],
 
          continue;
 		}
-      else if( c == '\t' )
-      {
+      else if( c == '\t' ){
          text_cursor[0] += UI_GLYPH_SPACING_X*scale*4;
          continue;
       }