X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=vg_audio.h;h=39f494ffa0b843e501c28aaab94db4cfa7dd443e;hb=76d234b7dc5e6500e8a54009b367e7620f11ef97;hp=8f68f82c3e4f193379023284baa24983e81b0c0e;hpb=468a2c11d6c83e0e71e6ac87844e52cc4d49ccbc;p=vg.git

diff --git a/vg_audio.h b/vg_audio.h
index 8f68f82..39f494f 100644
--- a/vg_audio.h
+++ b/vg_audio.h
@@ -10,15 +10,11 @@
 #include "vg/vg_platform.h"
 #include "vg/vg_io.h"
 #include "vg/vg_m.h"
-#include "vg/vg_ui.h"
 #include "vg/vg_console.h"
 #include "vg/vg_store.h"
 #include "vg/vg_profiler.h"
 #include "vg/vg_audio_synth_bird.h"
 
-#include <sys/time.h>
-#include <math.h>
-
 #ifdef __GNUC__
   #ifndef __clang__
     #pragma GCC push_options
@@ -51,13 +47,6 @@
 #define AUDIO_FLAG_NO_DOPPLER 0x2
 #define AUDIO_FLAG_SPACIAL_3D 0x4
 #define AUDIO_FLAG_AUTO_START 0x8
-
-/* Vorbis will ALWAYS use the maximum amount of channels it can */
-//#define AUDIO_FLAG_MONO       0x100 NOTE: This is the default, so its not used
-//#define AUDIO_FLAG_STEREO     0x200
-//#define AUDIO_FLAG_VORBIS     0x400
-//#define AUDIO_FLAG_BIRD_SYNTH 0x800
-
 #define AUDIO_FLAG_FORMAT     0x1E00
 
 enum audio_format
@@ -90,13 +79,21 @@ typedef struct audio_channel audio_channel;
 typedef struct audio_lfo audio_lfo;
 
 struct audio_clip{
-   const char *path;
+   union {              /* TODO oof.. */
+      u64 _p64_;
+      const char *path;
+   };
+
    u32 flags;
    u32 size;
-   void *data;
+
+   union{ 
+      u64 _p64;
+      void *data;
+   };
 };
 
-static struct vg_audio_system{
+struct vg_audio_system{
    SDL_AudioDeviceID sdl_output_device;
 
    void             *audio_pool, 
@@ -106,8 +103,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;
@@ -132,7 +129,8 @@ static struct vg_audio_system{
 
    struct audio_channel{
       int allocated;
-      u32 group;
+      u16 group;
+      u8  world_id;
 
       char name[32];       /* only editable while allocated == 0 */
       audio_clip *source;  /* ... */
@@ -193,19 +191,20 @@ static struct vg_audio_system{
    }
    channels[ AUDIO_CHANNELS ];
 
-   /* System queue, and access from thread 0 */
-   int               debug_ui, debug_ui_3d;
+   int               debug_ui, debug_ui_3d, debug_dsp;
+
+   v3f               internal_listener_pos,
+                     internal_listener_ears,
+                     internal_listener_velocity,
 
-   v3f               listener_pos,
-                     listener_ears,
-                     listener_velocity;
+                     external_listener_pos,
+                     external_listener_ears,
+                     external_lister_velocity;
 
-   float             volume,
-                     volume_target,
-                     volume_target_internal,
-                     volume_console;
+   float             internal_global_volume,
+                     external_global_volume;
 }
-vg_audio = { .volume_console = 1.0f };
+static vg_audio = { .external_global_volume = 1.0f };
 
 #include "vg/vg_audio_dsp.h"
 
@@ -224,23 +223,23 @@ static struct vg_profile
  * These functions are called from the main thread and used to prevent bad 
  * access. TODO: They should be no-ops in release builds.
  */
-VG_STATIC int audio_lock_checker_load(void)
+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 )
+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)
+static void audio_require_lock(void)
 {
    if( audio_lock_checker_load() )
       return;
@@ -249,43 +248,30 @@ VG_STATIC void audio_require_lock(void)
    abort();
 }
 
-VG_STATIC void audio_lock(void)
+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)
+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)
+static void audio_mixer_callback( void *user, u8 *stream, int frame_count );
+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",
-      .data = &vg_audio.debug_ui,
-      .data_type = k_var_dtype_i32,
-      .opt_i32 = { .min=0, .max=1, .clamp=1 },
-      .persistent = 1
-   });
-
-   vg_var_push( (struct vg_var){
-      .name = "volume",
-      .data = &vg_audio.volume_console,
-      .data_type = k_var_dtype_f32,
-      .opt_f32 = { .min=0.0f, .max=2.0f, .clamp=1 },
-      .persistent = 1
-   });
+   vg_console_reg_var( "debug_audio", &vg_audio.debug_ui, 
+                        k_var_dtype_i32, VG_VAR_CHEAT );
+   vg_console_reg_var( "debug_dsp", &vg_audio.debug_dsp,
+                        k_var_dtype_i32, VG_VAR_CHEAT );
+   vg_console_reg_var( "volume", &vg_audio.external_global_volume,
+                        k_var_dtype_f32, VG_VAR_PERSISTENT );
 
    /* allocate memory */
-
    /* 32mb fixed */
    vg_audio.audio_pool = 
       vg_create_linear_allocator( vg_mem.rtmemory, 1024*1024*32, 
@@ -315,18 +301,16 @@ VG_STATIC void vg_audio_init(void)
       SDL_PauseAudioDevice( vg_audio.sdl_output_device, 0 );
    }
    else{
-      vg_fatal_exit_loop( 
+      vg_fatal_error( 
          "SDL_OpenAudioDevice failed. Your default audio device must support:\n"
          "  Frequency: 44100 hz\n"
          "  Buffer size: 512\n"
          "  Channels: 2\n"
          "  Format: s16 or f32\n" );
    }
-
-   vg_success( "Ready\n" );
 }
 
-VG_STATIC void vg_audio_free(void)
+static void vg_audio_free(void)
 {
    vg_dsp_free();
    SDL_CloseAudioDevice( vg_audio.sdl_output_device );
@@ -348,6 +332,7 @@ VG_STATIC void vg_audio_free(void)
 static void audio_channel_init( audio_channel *ch, audio_clip *clip, u32 flags )
 {
    ch->group = 0;
+   ch->world_id = 0;
    ch->source = clip;
    ch->flags = flags;
    ch->colour = 0x00333333;
@@ -355,7 +340,7 @@ static void audio_channel_init( audio_channel *ch, audio_clip *clip, u32 flags )
    if( (ch->source->flags & AUDIO_FLAG_FORMAT) == k_audio_format_bird )
       strcpy( ch->name, "[array]" );
    else
-      strncpy( ch->name, clip->path, 31 );
+      vg_strncpy( clip->path, ch->name, 32, k_strncpy_always_add_null );
 
    ch->allocated = 1;
 
@@ -373,6 +358,17 @@ 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, u16 group )
+{
+   ch->group = group;
+   ch->colour = (((u32)group * 29986577) & 0x00ffffff) | 0xff000000;
+}
+
+static void audio_channel_world( audio_channel *ch, u8 world_id )
+{
+   ch->world_id = world_id;
+}
+
 static audio_channel *audio_get_first_idle_channel(void)
 {
    for( int i=0; i<AUDIO_CHANNELS; i++ ){
@@ -386,10 +382,10 @@ static audio_channel *audio_get_first_idle_channel(void)
    return NULL;
 }
 
-static audio_channel *audio_get_group_idle_channel( u32 group, u32 max_count )
+static audio_channel *audio_get_group_idle_channel( u16 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];
@@ -412,7 +408,7 @@ static audio_channel *audio_get_group_idle_channel( u32 group, u32 max_count )
    return NULL;
 }
 
-static audio_channel *audio_get_group_first_active_channel( u32 group )
+static audio_channel *audio_get_group_first_active_channel( u16 group )
 {
    for( int i=0; i<AUDIO_CHANNELS; i++ ){
       audio_channel *ch = &vg_audio.channels[i];
@@ -627,7 +623,7 @@ static int audio_channel_load_source( audio_channel *ch )
    return 1;
 }
 
-VG_STATIC void audio_decode_uncompressed_mono( i16 *src, u32 count, float *dst )
+static void audio_decode_uncompressed_mono( i16 *src, u32 count, float *dst )
 {
    for( u32 i=0; i<count; i++ ){
       dst[ i*2 + 0 ] = ((float)src[i]) * (1.0f/32767.0f);
@@ -638,7 +634,7 @@ VG_STATIC void audio_decode_uncompressed_mono( i16 *src, u32 count, float *dst )
 /* 
  * adapted from stb_vorbis.h, since the original does not handle mono->stereo
  */
-VG_STATIC int 
+static int 
 stb_vorbis_get_samples_float_interleaved_stereo( stb_vorbis *f, float *buffer, 
                                                  int len )
 {
@@ -672,7 +668,7 @@ stb_vorbis_get_samples_float_interleaved_stereo( stb_vorbis *f, float *buffer,
 /* 
  * ........ more wrecked code sorry!
  */
-VG_STATIC int 
+static int 
 stb_vorbis_get_samples_i16_downmixed( stb_vorbis *f, i16 *buffer, int len )
 {
    int n = 0,
@@ -818,14 +814,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,24 +831,43 @@ 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" );
-      if( !vg_validf( framevol_r ) ) vg_fatal_exit_loop( "NaN right channel" );
-      if( !vg_validf( frame_samplerate ) ) 
-         vg_fatal_exit_loop( "NaN sample rate" );
+      if( !vg_validf( framevol_l ) || 
+          !vg_validf( framevol_r ) ||
+          !vg_validf( frame_samplerate ) ){
+         vg_fatal_error( "Invalid sampling conditions.\n"
+                         "This crash is to protect your ears.\n"
+                         "  channel: %p (%s)\n"
+                         "  sample_rate: %f\n"
+                         "  volume: L%f R%f\n"
+                         "  listener: %.2f %.2f %.2f [%.2f %.2f %.2f]\n",
+                         ch, ch->name, frame_samplerate, 
+                         framevol_l, framevol_r,
+                         vg_audio.internal_listener_pos[0],
+                         vg_audio.internal_listener_pos[1],
+                         vg_audio.internal_listener_pos[2],
+                         vg_audio.internal_listener_ears[0],
+                         vg_audio.internal_listener_ears[1],
+                         vg_audio.internal_listener_ears[2]
+                         );
+      }
    }
 
    u32 buffer_length = AUDIO_MIX_FRAME_SIZE;
@@ -876,22 +891,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;
@@ -933,12 +935,19 @@ static void audio_channel_mix( audio_channel *ch, float *buffer )
    vg_profile_end( &_vg_prof_audio_mix );
 }
 
-VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int byte_count )
+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];
 
@@ -1137,14 +1146,14 @@ VG_STATIC void audio_mixer_callback( void *user, u8 *stream, int byte_count )
 
    vg_audio.samples_last = frame_count;
 
-   if( vg_audio.debug_ui ){
+   if( vg_audio.debug_dsp ){
       vg_dsp_update_texture();
    }
 
    audio_unlock();
 }
 
-VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
+static void audio_clip_load( audio_clip *clip, void *lin_alloc )
 {
    if( lin_alloc == NULL )
       lin_alloc = vg_audio.audio_pool;
@@ -1161,7 +1170,7 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
 
    if( format == k_audio_format_vorbis ){
       if( !clip->path ){
-         vg_fatal_exit_loop( "No path specified, embeded vorbis unsupported" );
+         vg_fatal_error( "No path specified, embeded vorbis unsupported" );
       }
 
       audio_lock();
@@ -1169,17 +1178,17 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
       audio_unlock();
 
       if( !clip->data )
-         vg_fatal_exit_loop( "Audio failed to load" );
+         vg_fatal_error( "Audio failed to load" );
 
       float mb = (float)(clip->size) / (1024.0f*1024.0f);
       vg_info( "Loaded audio clip '%s' (%.1fmb)\n", clip->path, mb );
    }
    else if( format == k_audio_format_stereo ){
-      vg_fatal_exit_loop( "Unsupported format (Stereo uncompressed)" );
+      vg_fatal_error( "Unsupported format (Stereo uncompressed)" );
    }
    else if( format == k_audio_format_bird ){
       if( !clip->data ){
-         vg_fatal_exit_loop( "No data, external birdsynth unsupported" );
+         vg_fatal_error( "No data, external birdsynth unsupported" );
       }
 
       u32 total_size  = clip->size + sizeof(struct synth_bird);
@@ -1187,7 +1196,7 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
           total_size  = vg_align8( total_size );
 
       if( total_size > AUDIO_DECODE_SIZE )
-         vg_fatal_exit_loop( "Bird coding too long\n" );
+         vg_fatal_error( "Bird coding too long\n" );
 
       struct synth_bird *bird = vg_linear_alloc( lin_alloc, total_size );
       memcpy( &bird->settings, clip->data, clip->size );
@@ -1199,7 +1208,7 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
    }
    else{
       if( !clip->path ){
-         vg_fatal_exit_loop( "No path specified, embeded mono unsupported" );
+         vg_fatal_error( "No path specified, embeded mono unsupported" );
       }
 
       vg_linear_clear( vg_mem.scratch );
@@ -1219,7 +1228,7 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
       if( !decoder ){
          vg_error( "stb_vorbis_open_memory failed on '%s' (%d)\n", 
                      clip->path, err );
-         vg_fatal_exit_loop( "Vorbis decode error" );
+         vg_fatal_error( "Vorbis decode error" );
       }
 
       /* only mono is supported in uncompressed */
@@ -1235,34 +1244,36 @@ VG_STATIC void audio_clip_load( audio_clip *clip, void *lin_alloc )
                               decoder, clip->data, length_samples );
 
       if( read_samples != length_samples )
-         vg_fatal_exit_loop( "Decode error" );
+         vg_fatal_error( "Decode error" );
 
+#if 0
       float mb = (float)(data_size) / (1024.0f*1024.0f);
       vg_info( "Loaded audio clip '%s' (%.1fmb) %u samples\n", clip->path, mb,
                length_samples );
+#endif
    }
 }
 
-VG_STATIC void audio_clip_loadn( audio_clip *arr, int count, void *lin_alloc )
+static void audio_clip_loadn( audio_clip *arr, int count, void *lin_alloc )
 {
    for( int i=0; i<count; i++ )
       audio_clip_load( &arr[i], lin_alloc );
 }
 
-VG_STATIC void audio_require_clip_loaded( audio_clip *clip )
+static void audio_require_clip_loaded( audio_clip *clip )
 {
    if( clip->data && clip->size )
       return;
 
    audio_unlock();
-   vg_fatal_exit_loop( "Must load audio clip before playing! \n" );
+   vg_fatal_error( "Must load audio clip before playing! \n" );
 }
 
 /* 
  * Debugging
  */
 
-VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
+static void audio_debug_ui( m4x4f mtx_pv )
 {
    if( !vg_audio.debug_ui )
       return;
@@ -1290,23 +1301,17 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
    char perf[128];
 	
    /* Draw UI */
-   vg_uictx.cursor[0] = 512 + 8;
-   vg_uictx.cursor[1] = VG_PROFILE_SAMPLE_COUNT*2+8+24+12+12;
-   vg_uictx.cursor[2] = 150;
-   vg_uictx.cursor[3] = 12;
-
-   ui_rect view_thing = { 4, vg.window_y-512-4, 512, 512 };
-   ui_push_image( view_thing, vg_dsp.view_texture );
-   
-   float mb1      = 1024.0f*1024.0f,
-         usage    = vg_linear_get_cur( vg_audio.audio_pool )      / mb1,
-         total    = vg_linear_get_capacity( vg_audio.audio_pool ) / mb1,
-         percent  = (usage/total) * 100.0f;
-
-   snprintf( perf, 127, "Mem: %.1f/%.1fmb (%.1f%%)\n", usage, total, percent );
-
-   ui_text( vg_uictx.cursor, perf, 1, 0 );
-   vg_uictx.cursor[1] += 20;
+   ui_rect window = {
+      0,
+      0,
+      800,
+      AUDIO_CHANNELS * 18
+   };
+
+   if( vg_audio.debug_dsp ){
+      ui_rect view_thing = { 4, vg.window_y-512-4, 512, 512 };
+      ui_image( view_thing, vg_dsp.view_texture );
+   }
 
    ui_rect overlap_buffer[ AUDIO_CHANNELS ];
    u32 overlap_length = 0;
@@ -1315,16 +1320,11 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
 	for( int i=0; i<AUDIO_CHANNELS; i ++ ){
       audio_channel *ch = &vg_audio.channels[i];
 
-		vg_uictx.cursor[2] = 400;
-		vg_uictx.cursor[3] = 18;
-		
-		ui_new_node();
+      ui_rect row;
+      ui_split( window, k_ui_axis_h, 18, 1, row, window );
 
       if( !ch->allocated ){
-         ui_fill_rect( vg_uictx.cursor, 0x50333333 );
-
-         ui_end_down();
-         vg_uictx.cursor[1] += 1;
+         ui_fill( row, 0x50333333 );
          continue;
       }
 
@@ -1359,8 +1359,9 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
 
       u32 format_index = (ch->source->flags & AUDIO_FLAG_FORMAT)>>9;
 
-      snprintf( perf, 127, "%02d %c%c%cD %s [%s] %4.2fv'%s'", 
+      snprintf( perf, 127, "%02d[%#04x.%#06x]%c%c%cD %s [%s] %4.2fv'%s'", 
                i,
+               ch->world_id, ch->group,
                (ch->editable_state.relinquished)? 'r': '_',
                0?                                 'r': '_',
                0?                                 '3': '2',
@@ -1369,14 +1370,8 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
                ch->editable_state.volume,
                ch->name );
 
-      ui_fill_rect( vg_uictx.cursor, 0xa0000000 | ch->colour );
-
-      vg_uictx.cursor[0] += 2;
-      vg_uictx.cursor[1] += 2;
-      ui_text( vg_uictx.cursor, perf, 1, 0 );
-
-		ui_end_down();
-		vg_uictx.cursor[1] += 1;
+      ui_fill( row, 0xa0000000 | ch->colour );
+      ui_text( row, perf, 1, k_ui_align_middle_left, 0 );
       
       if( AUDIO_FLAG_SPACIAL_3D ){
          v4f wpos;
@@ -1390,9 +1385,9 @@ 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[2] = 100;
+            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] = 1000;
             wr[3] = 17;
             
             for( int j=0; j<12; j++ ){
@@ -1413,9 +1408,8 @@ VG_STATIC void audio_debug_ui( m4x4f mtx_pv )
                   wr[1] += 18;
             }
 
-            ui_text( wr, perf, 1, 0 );
-
-            ui_rect_copy( wr, overlap_buffer[ overlap_length ++ ] );
+            ui_text( wr, perf, 1, k_ui_align_middle_left, 0 );
+            rect_copy( wr, overlap_buffer[ overlap_length ++ ] );
          }
       }
 	}