vg_console.h

   1 /* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
   2
   3 #ifndef VG_CONSOLE_H
   4 #define VG_CONSOLE_H
   5
   6 #ifndef VG_GAME
   7   #define VG_GAME
   8 #endif
   9
  10 #include "vg/vg_ui.h"
  11 #include "vg/vg_log.h"
  12
  13 typedef struct vg_convar vg_convar;
  14 typedef struct vg_cmd vg_cmd;
  15
  16 struct vg_console
  17 {
  18         struct vg_convar
  19         {
  20                 void *data;
  21       void (*update)(void);
  22                 const char *name;
  23
  24                 enum vg_convar_dtype
  25                 {
  26                         k_convar_dtype_i32,
  27                         k_convar_dtype_u32,
  28                         k_convar_dtype_f32
  29                 }
  30                 data_type;
  31
  32                 union
  33                 {
  34                         struct
  35                         {
  36                                 int min, max, clamp;
  37                         }
  38          opt_i32;
  39
  40          struct
  41          {
  42             float min, max;
  43             int clamp;
  44          }
  45          opt_f32;
  46                 };
  47
  48                 int persistent; /* Should this var be stored to cfg/auto.conf? */
  49         }
  50         convars[ 32 ];
  51
  52         struct vg_cmd
  53         {
  54                 int (*function)( int argc, char const *argv[] );
  55                 const char *name;
  56         }
  57         functions[ 32 ];
  58
  59    u32 convar_count, function_count;
  60
  61         char input[96];
  62         int cursor_user, cursor_pos, string_length;
  63
  64         char history[32][96];
  65         int history_last, history_pos, history_count;
  66
  67         int enabled;
  68 }
  69 vg_console;
  70
  71 VG_STATIC void  vg_convar_push( struct vg_convar cv );
  72 VG_STATIC void  vg_function_push( struct vg_cmd cmd );
  73
  74 VG_STATIC void _vg_console_draw( void );
  75 void           _vg_console_println( const char *str );
  76 VG_STATIC int  _vg_console_list( int argc, char const *argv[] );
  77 VG_STATIC void _vg_console_init(void);
  78 VG_STATIC void _vg_console_write_persistent(void);
  79 VG_STATIC void _vg_console_free(void);
  80 VG_STATIC void  vg_execute_console_input( const char *cmd );
  81
  82 /*
  83  * Console interface
  84  */
  85 VG_STATIC void console_make_selection( int* start, int* end );
  86 VG_STATIC void console_move_cursor( int* cursor0, int* cursor1,
  87                                     int dir, int snap_together );
  88 VG_STATIC int console_makeroom( int datastart, int length );
  89 VG_STATIC int console_delete_char( int direction );
  90 VG_STATIC void console_to_clipboard(void);
  91 VG_STATIC void console_clipboard_paste(void);
  92 VG_STATIC void console_put_char( char c );
  93 VG_STATIC void console_history_get( char* buf, int entry_num );
  94 VG_STATIC int _vg_console_enabled(void);
  95 VG_STATIC void console_proc_key( SDL_Keysym ev );
  96
  97 /*
  98  * Implementation
  99  */
 100 VG_STATIC int _vg_console_enabled(void)
 101 {
 102         return vg_console.enabled;
 103 }
 104
 105 VG_STATIC void vg_convar_push( vg_convar cv )
 106 {
 107    if( vg_console.convar_count > vg_list_size(vg_console.convars) )
 108       vg_fatal_exit_loop( "Too many convars registered" );
 109
 110    vg_info( "Console variable '%s' registered\n", cv.name );
 111    vg_console.convars[ vg_console.convar_count ++ ] = cv;
 112 }
 113
 114 VG_STATIC void vg_function_push( struct vg_cmd cmd )
 115 {
 116    if( vg_console.function_count > vg_list_size(vg_console.functions) )
 117       vg_fatal_exit_loop( "Too many functions registered" );
 118
 119    vg_console.functions[ vg_console.function_count ++ ] = cmd;
 120 }
 121
 122 VG_STATIC void _vg_console_draw( void )
 123 {
 124         if( !vg_console.enabled )
 125                 return;
 126
 127    SDL_AtomicLock( &log_print_sl );
 128
 129         int ptr = vg_log.buffer_line_current;
 130    int const fh = 14,
 131              log_lines = 32;
 132    int console_lines = VG_MIN( log_lines, vg_log.buffer_line_count );
 133
 134         vg_uictx.cursor[0] = 0;
 135         vg_uictx.cursor[1] = 0;
 136         vg_uictx.cursor[3] = log_lines*fh;
 137         ui_fill_x();
 138
 139         ui_new_node();
 140         {
 141                 ui_fill_rect( vg_uictx.cursor, 0x77333333 );
 142
 143                 vg_uictx.cursor[3] = fh;
 144                 ui_align_bottom();
 145
 146                 for( int i=0; i<console_lines; i ++ )
 147                 {
 148                         ptr --;
 149
 150                         if( ptr < 0 )
 151                                 ptr = vg_list_size( vg_log.buffer )-1;
 152
 153                         ui_text( vg_uictx.cursor, vg_log.buffer[ptr], 1, 0 );
 154                         vg_uictx.cursor[1] -= fh;
 155                 }
 156
 157         }
 158         ui_end_down();
 159
 160         vg_uictx.cursor[1] += 2;
 161         vg_uictx.cursor[3] = fh;
 162
 163         ui_new_node();
 164         {
 165                 ui_fill_rect( vg_uictx.cursor, 0x77333333 );
 166                 ui_text( vg_uictx.cursor, vg_console.input, 1, 0 );
 167
 168                 int start = VG_MIN( vg_console.cursor_pos, vg_console.cursor_user ),
 169                          end   = VG_MAX( vg_console.cursor_pos, vg_console.cursor_user );
 170
 171                 vg_uictx.cursor[0] = start * UI_GLYPH_SPACING_X;
 172                 vg_uictx.cursor[2] = (start == end? 0.5f: (float)(end-start))
 173                                              * (float)UI_GLYPH_SPACING_X;
 174
 175                 ui_fill_rect( vg_uictx.cursor, 0x66ffffff );
 176         }
 177         ui_end_down();
 178    SDL_AtomicUnlock( &log_print_sl );
 179 }
 180
 181 VG_STATIC int _vg_console_list( int argc, char const *argv[] )
 182 {
 183         for( int i=0; i<vg_console.function_count; i ++ )
 184         {
 185                 struct vg_cmd *cmd = &vg_console.functions[ i ];
 186                 vg_info( "* %s\n", cmd->name );
 187         }
 188
 189         for( int i=0; i<vg_console.convar_count; i ++ )
 190         {
 191                 struct vg_convar *cv = &vg_console.convars[ i ];
 192                 vg_info( "%s\n", cv->name );
 193         }
 194
 195         return 0;
 196 }
 197
 198 int _test_break( int argc, const char *argv[] )
 199 {
 200    vg_fatal_exit_loop( "Test crash from main, after loading (console)" );
 201    return 0;
 202 }
 203
 204 VG_STATIC void _vg_console_init(void)
 205 {
 206         vg_function_push( (struct vg_cmd)
 207    {
 208                 .name = "list",
 209                 .function = _vg_console_list
 210         });
 211
 212    vg_function_push( (struct vg_cmd)
 213    {
 214       .name = "crash",
 215       .function = _test_break
 216    });
 217 }
 218
 219 VG_STATIC void vg_console_load_autos(void)
 220 {
 221         /* Read and exec persistent commands */
 222         FILE *fp = fopen( "cfg/auto.conf", "r" );
 223         if( fp )
 224         {
 225                 char line[256];
 226
 227                 while( fgets( line, sizeof( line ), fp ) )
 228                 {
 229                         line[ strcspn( line, "\r\n#" ) ] = 0x00;
 230
 231                         if( line[0] != 0x00 )
 232                         {
 233                                 vg_execute_console_input( line );
 234                         }
 235                 }
 236
 237                 fclose( fp );
 238         }
 239 }
 240
 241 VG_STATIC void _vg_console_write_persistent(void)
 242 {
 243         FILE *fp = fopen( "cfg/auto.conf", "w" );
 244
 245         for( int i=0; i<vg_console.convar_count; i ++ )
 246         {
 247                 struct vg_convar *cv = &vg_console.convars[i];
 248
 249                 if( cv->persistent )
 250                 {
 251                         switch( cv->data_type )
 252                         {
 253                                 case k_convar_dtype_i32:
 254                                         fprintf( fp, "%s %d\n", cv->name, *(i32 *)(cv->data) );
 255                                 break;
 256                                 case k_convar_dtype_u32:
 257                                         fprintf( fp, "%s %u\n", cv->name, *(u32 *)(cv->data) );
 258                                 break;
 259                                 case k_convar_dtype_f32:
 260                                         fprintf( fp, "%s %.5f\n", cv->name, *(float *)(cv->data ) );
 261                                 break;
 262                         }
 263                 }
 264         }
 265
 266         fclose( fp );
 267 }
 268
 269 VG_STATIC void _vg_console_free(void)
 270 {
 271         _vg_console_write_persistent();
 272 }
 273
 274 VG_STATIC void vg_execute_console_input( const char *cmd )
 275 {
 276         char temp[512];
 277         char const *args[9];
 278         int arg_count = 0;
 279
 280         int in_token = 0;
 281
 282         /* Split string into tokens */
 283         for( int i = 0; i < vg_list_size( temp ); i ++ )
 284         {
 285                 if( cmd[i] )
 286                 {
 287                         if( cmd[i] == ' ' || cmd[i] == '\t' )
 288                         {
 289                                 temp[i] = '\0';
 290                                 in_token = 0;
 291
 292                                 if( arg_count == vg_list_size( args ) )
 293                                         break;
 294                         }
 295                         else
 296                         {
 297                                 temp[i] = cmd[i];
 298
 299                                 if( !in_token )
 300                                 {
 301                                         args[ arg_count ++ ] = temp + i;
 302                                         in_token = 1;
 303                                 }
 304                         }
 305                 }
 306                 else
 307                 {
 308                         temp[i] = '\0';
 309                         break;
 310                 }
 311         }
 312
 313         if( arg_count == 0 )
 314                 return;
 315
 316         int data_int;
 317    float data_float;
 318
 319         for( int i=0; i<vg_console.convar_count; i ++ )
 320         {
 321                 struct vg_convar *cv = &vg_console.convars[ i ];
 322                 if( !strcmp( cv->name, args[0] ) )
 323                 {
 324                         /* Cvar Matched, try get value */
 325                         if( arg_count >= 2 )
 326                         {
 327                                 switch( cv->data_type )
 328                                 {
 329                                         case k_convar_dtype_u32:
 330                                         case k_convar_dtype_i32:
 331
 332                                                 data_int = atoi( args[1] );
 333
 334                                                 *((int *)cv->data) = cv->opt_i32.clamp?
 335                    VG_MIN( VG_MAX(data_int, cv->opt_i32.min), cv->opt_i32.max ):
 336                    data_int;
 337
 338                                         break;
 339                                         case k_convar_dtype_f32:
 340                   data_float = atof( args[1] );
 341                   *((float *)cv->data) = cv->opt_f32.clamp?
 342                      vg_minf( vg_maxf( data_float, cv->opt_f32.min),
 343                               cv->opt_f32.max ):
 344                      data_float;
 345                break;
 346                                 }
 347
 348             if( cv->update )
 349                cv->update();
 350                         }
 351                         else
 352                         {
 353                                 switch( cv->data_type )
 354                                 {
 355                                         case k_convar_dtype_i32:
 356                   vg_info( "= %d\n", *((int *)cv->data) );
 357                break;
 358                                         case k_convar_dtype_u32:
 359                   vg_info( "= %u\n", *((u32 *)cv->data) );
 360                break;
 361                                         case k_convar_dtype_f32:
 362                   vg_info( "= %.4f\n", *((float *)cv->data) );
 363                break;
 364                                 }
 365                         }
 366
 367                         return;
 368                 }
 369         }
 370
 371    /*
 372     * Find and excecute command
 373     */
 374         for( int i=0; i<vg_console.function_count; i ++ )
 375         {
 376                 struct vg_cmd *cmd = &vg_console.functions[ i ];
 377                 if( !strcmp( cmd->name, args[0] ) )
 378                 {
 379                         cmd->function( arg_count-1, args+1 );
 380                         return;
 381                 }
 382         }
 383
 384         vg_error( "No command/var named '%s'. Use 'list' to view all\n", args[0] );
 385 }
 386
 387 /*
 388  * Console Interface
 389  */
 390 VG_STATIC void console_make_selection( int* start, int* end )
 391 {
 392         *start = VG_MIN( vg_console.cursor_pos, vg_console.cursor_user );
 393         *end   = VG_MAX( vg_console.cursor_pos, vg_console.cursor_user );
 394 }
 395
 396 VG_STATIC void console_move_cursor( int* cursor0, int* cursor1,
 397       int dir, int snap_together )
 398 {
 399         *cursor0 = VG_MAX( 0, vg_console.cursor_user + dir );
 400         *cursor0 =
 401       VG_MIN(
 402          VG_MIN( vg_list_size( vg_console.input ), strlen( vg_console.input )),
 403       *cursor0 );
 404
 405         if( snap_together )
 406                 *cursor1 = *cursor0;
 407 }
 408
 409 VG_STATIC int console_makeroom( int datastart, int length )
 410 {
 411         int move_to = VG_MIN( datastart+length, vg_list_size( vg_console.input ) );
 412         int move_amount = strlen( vg_console.input )-datastart;
 413         int move_end =
 414       VG_MIN( move_to+move_amount, vg_list_size( vg_console.input ) );
 415         move_amount = move_end-move_to;
 416
 417         if( move_amount )
 418                 memmove( &vg_console.input[ move_to ],
 419                &vg_console.input[ datastart ],
 420                move_end-move_to );
 421
 422         vg_console.input[ move_end ] = '\0';
 423
 424         return VG_MIN( length, vg_list_size( vg_console.input )-datastart );
 425 }
 426
 427 VG_STATIC int console_delete_char( int direction )
 428 {
 429         int start, end;
 430         console_make_selection( &start, &end );
 431
 432         /* There is no selection */
 433         if( !(end-start) )
 434         {
 435                 if( direction == 1 ) end = VG_MIN( end+1, strlen( vg_console.input ) );
 436                 else if( direction == -1 ) start = VG_MAX( start-1, 0 );
 437         }
 438
 439         /* Still no selction, no need to do anything */
 440         if( !(end-start) )
 441                 return start;
 442
 443         /* Copy the end->terminator to start */
 444         int remaining_length = strlen( vg_console.input )+1-end;
 445         memmove( &vg_console.input[ start ],
 446             &vg_console.input[ end ],
 447             remaining_length );
 448         return start;
 449 }
 450
 451 VG_STATIC void console_to_clipboard(void)
 452 {
 453         int start, end;
 454         console_make_selection( &start, &end );
 455         char buffer[512];
 456
 457         if( end-start )
 458         {
 459                 memcpy( buffer, &vg_console.input[ start ], end-start );
 460                 buffer[ end-start ] = 0x00;
 461       SDL_SetClipboardText( buffer );
 462         }
 463 }
 464
 465 VG_STATIC void console_clipboard_paste(void)
 466 {
 467    if( !SDL_HasClipboardText() )
 468       return;
 469
 470    char *text = SDL_GetClipboardText();
 471
 472    if( !text )
 473       return;
 474
 475    int datastart = console_delete_char( 0 );
 476         int length = strlen( text );
 477         int cpylength = console_makeroom( datastart, length );
 478
 479         memcpy( vg_console.input + datastart, text, cpylength);
 480         console_move_cursor( &vg_console.cursor_user,
 481                         &vg_console.cursor_pos, cpylength, 1 );
 482
 483    SDL_free( text );
 484 }
 485
 486 VG_STATIC void console_put_char( char c )
 487 {
 488         if( !vg_console.enabled )
 489                 return;
 490
 491         vg_console.cursor_user = console_delete_char(0);
 492
 493         if( console_makeroom( vg_console.cursor_user, 1 ) )
 494                 vg_console.input[ vg_console.cursor_user ] = c;
 495
 496         console_move_cursor( &vg_console.cursor_user, &vg_console.cursor_pos, 1, 1 );
 497 }
 498
 499 VG_STATIC void console_history_get( char* buf, int entry_num )
 500 {
 501         if( !vg_console.history_count )
 502                 return;
 503
 504    int offset = VG_MIN( entry_num, vg_console.history_count -1 ),
 505        pick = (vg_console.history_last - offset) %
 506                vg_list_size( vg_console.history );
 507         strcpy( buf, vg_console.history[ pick ] );
 508 }
 509
 510 /* Receed secondary cursor */
 511 VG_STATIC void _console_left_select(void)
 512 {
 513    console_move_cursor( &vg_console.cursor_user, NULL, -1, 0 );
 514 }
 515
 516 /* Match and receed both cursors */
 517 VG_STATIC void _console_left(void)
 518 {
 519    int cursor_diff = vg_console.cursor_pos - vg_console.cursor_user? 0: 1;
 520
 521    console_move_cursor( &vg_console.cursor_user,
 522                         &vg_console.cursor_pos, -cursor_diff, 1 );
 523 }
 524
 525 VG_STATIC void _console_right_select(void)
 526 {
 527    console_move_cursor( &vg_console.cursor_user, NULL, 1, 0 );
 528 }
 529
 530 VG_STATIC void _console_right(void)
 531 {
 532    int cursor_diff = vg_console.cursor_pos - vg_console.cursor_user? 0: 1;
 533
 534    console_move_cursor( &vg_console.cursor_user,
 535                         &vg_console.cursor_pos, +cursor_diff, 1 );
 536 }
 537
 538 VG_STATIC void _console_down(void)
 539 {
 540    vg_console.history_pos = VG_MAX( 0, vg_console.history_pos-1 );
 541    console_history_get( vg_console.input, vg_console.history_pos );
 542
 543    console_move_cursor( &vg_console.cursor_user,
 544                         &vg_console.cursor_pos,
 545                         vg_list_size( vg_console.input ), 1 );
 546 }
 547
 548 VG_STATIC void _console_up(void)
 549 {
 550    vg_console.history_pos = VG_MAX
 551    (
 552       0,
 553       VG_MIN
 554       (
 555          vg_console.history_pos+1,
 556          VG_MIN
 557          (
 558             vg_list_size( vg_console.history ),
 559             vg_console.history_count - 1
 560          )
 561       )
 562    );
 563
 564    console_history_get( vg_console.input, vg_console.history_pos );
 565    console_move_cursor( &vg_console.cursor_user,
 566                         &vg_console.cursor_pos,
 567                         vg_list_size( vg_console.input ), 1);
 568 }
 569
 570 VG_STATIC void _console_backspace(void)
 571 {
 572    vg_console.cursor_user = console_delete_char( -1 );
 573    vg_console.cursor_pos = vg_console.cursor_user;
 574 }
 575
 576 VG_STATIC void _console_delete(void)
 577 {
 578    vg_console.cursor_user = console_delete_char( 1 );
 579    vg_console.cursor_pos = vg_console.cursor_user;
 580 }
 581
 582 VG_STATIC void _console_home_select(void)
 583 {
 584    console_move_cursor( &vg_console.cursor_user, NULL, -10000, 0 );
 585 }
 586
 587 VG_STATIC void _console_home(void)
 588 {
 589    console_move_cursor( &vg_console.cursor_user,
 590                         &vg_console.cursor_pos, -10000, 1 );
 591 }
 592
 593 VG_STATIC void _console_end_select(void)
 594 {
 595    console_move_cursor( &vg_console.cursor_user, NULL, 10000, 0 );
 596 }
 597
 598 VG_STATIC void _console_end(void)
 599 {
 600    console_move_cursor( &vg_console.cursor_user,
 601                         &vg_console.cursor_pos,
 602                         vg_list_size( vg_console.input ), 1 );
 603 }
 604
 605 VG_STATIC void _console_select_all(void)
 606 {
 607    console_move_cursor( &vg_console.cursor_user, NULL, 10000, 0);
 608    console_move_cursor( &vg_console.cursor_pos, NULL, -10000, 0);
 609 }
 610
 611 VG_STATIC void _console_cut(void)
 612 {
 613    console_to_clipboard();
 614    vg_console.cursor_user = console_delete_char(0);
 615    vg_console.cursor_pos = vg_console.cursor_user;
 616 }
 617
 618 VG_STATIC void _console_enter(void)
 619 {
 620    if( !strlen( vg_console.input ) )
 621       return;
 622
 623    vg_info( "%s\n", vg_console.input );
 624
 625    if( strcmp( vg_console.input,
 626             vg_console.history[ vg_console.history_last ]) )
 627    {
 628       vg_console.history_last = ( vg_console.history_last + 1) %
 629                                  vg_list_size(vg_console.history );
 630       vg_console.history_count =
 631          VG_MIN( vg_list_size( vg_console.history ),
 632                vg_console.history_count + 1 );
 633       strcpy( vg_console.history[ vg_console.history_last ],
 634               vg_console.input );
 635    }
 636
 637    vg_console.history_pos = -1;
 638    vg_execute_console_input( vg_console.input );
 639    console_move_cursor( &vg_console.cursor_user,
 640                         &vg_console.cursor_pos, -10000, 1 );
 641    vg_console.input[0] = '\0';
 642 }
 643
 644 VG_STATIC void console_proc_key( SDL_Keysym ev )
 645 {
 646    /* Open / close console */
 647    if( ev.sym == SDLK_BACKQUOTE )
 648    {
 649       vg_console.enabled = !vg_console.enabled;
 650
 651       if( vg_console.enabled )
 652          SDL_StartTextInput();
 653       else
 654          SDL_StopTextInput();
 655    }
 656
 657    if( !vg_console.enabled ) return;
 658
 659    struct console_mapping
 660    {
 661       u16 mod;
 662       SDL_Keycode key;
 663
 664       void (*handler)(void);
 665    }
 666    mapping[] =
 667    {
 668       { 0,              SDLK_LEFT,       _console_left              },
 669       { KMOD_SHIFT,     SDLK_LEFT,       _console_left_select       },
 670       { 0,              SDLK_RIGHT,      _console_right             },
 671       { KMOD_SHIFT,     SDLK_RIGHT,      _console_right_select      },
 672       { 0,              SDLK_DOWN,       _console_down              },
 673       { 0,              SDLK_UP,         _console_up                },
 674       { 0,              SDLK_BACKSPACE,  _console_backspace         },
 675       { 0,              SDLK_DELETE,     _console_delete            },
 676       { 0,              SDLK_HOME,       _console_home              },
 677       { KMOD_SHIFT,     SDLK_HOME,       _console_home_select       },
 678       { 0,              SDLK_END,        _console_end               },
 679       { KMOD_SHIFT,     SDLK_END,        _console_end_select        },
 680       { KMOD_CTRL,      SDLK_a,          _console_select_all        },
 681       { KMOD_CTRL,      SDLK_c,          console_to_clipboard       },
 682       { KMOD_CTRL,      SDLK_x,          _console_cut               },
 683       { KMOD_CTRL,      SDLK_v,          console_clipboard_paste    },
 684       { 0,              SDLK_RETURN,     _console_enter             }
 685    };
 686
 687    for( int i=0; i<vg_list_size( mapping ); i++ )
 688    {
 689       struct console_mapping *mk = &mapping[i];
 690
 691       if( mk->key == ev.sym )
 692       {
 693          if( mk->mod == 0 )
 694          {
 695             if( ev.mod == 0 )
 696             {
 697                mk->handler();
 698                return;
 699             }
 700          }
 701          else if( (ev.mod & mk->mod) == mk->mod )
 702          {
 703             mk->handler();
 704             return;
 705          }
 706       }
 707    }
 708 }
 709
 710 VG_STATIC void console_proc_utf8( const char *text )
 711 {
 712    const char *ptr = text;
 713
 714    while( *ptr )
 715    {
 716       if( *ptr != '`' )
 717          console_put_char( *ptr );
 718       ptr ++;
 719    }
 720 }
 721
 722 #endif /* VG_CONSOLE_H */