vg/vg.h

   1 // Copyright (C) 2021 Harry Godden (hgn) - All Rights Reserved
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <dirent.h>
   6 #include <stdint.h>
   7 #include <string.h>
   8 #include <stdarg.h>
   9
  10 #include "gl/glad/glad.h"
  11 #include "gl/glfw3.h"
  12
  13 #define STB_DS_IMPLEMENTATION
  14 #define STB_IMAGE_IMPLEMENTATION
  15 #include "stb/stb_ds.h"
  16 #include "stb/stb_image.h"
  17
  18 #include "vg/vg_platform.h"
  19
  20 void vg_register_exit( void( *funcptr )(void), const char *name );
  21 void vg_exiterr( const char *strErr );
  22
  23 m3x3f vg_pv;
  24
  25 #include "vg/vg_m.h"
  26 #include "vg/vg_io.h"
  27
  28 #ifndef VG_TOOLS
  29
  30 #include "vg/vg_audio.h"
  31 #include "vg/vg_shader.h"
  32 #include "vg/vg_lines.h"
  33 #include "vg/vg_tex.h"
  34
  35 #include "steam/steamworks_thin.h"
  36
  37 static inline float vg_get_axis( const char *axis ) __attribute__((unused));
  38 static inline int vg_get_button( const char *button ) __attribute__((unused));
  39 static inline int vg_get_button_down( const char *button ) __attribute__((unused));
  40 static inline int vg_get_button_up( const char *button ) __attribute__((unused));
  41
  42 // Globals
  43 GLFWwindow* vg_window;
  44 int vg_window_x = 1280;
  45 int vg_window_y = 720;
  46
  47 v2f vg_mouse;
  48 v3f vg_mouse_ws;
  49
  50 float   vg_time;
  51 float   vg_time_last;
  52 float   vg_time_delta;
  53
  54 // Input
  55 // ===========================================================================================================
  56 GLFWgamepadstate vg_gamepad;
  57 int                     vg_gamepad_ready = 0;
  58 const char *vg_gamepad_name = NULL;
  59 int                     vg_gamepad_id;
  60
  61 enum EInputMode
  62 {
  63         k_EInputMode_pc,
  64         k_EInputMode_gamepad
  65 }
  66 vg_input_mode;
  67
  68 static struct axis_binding
  69 {
  70         const char *name;
  71         union
  72         {
  73                 int positive;
  74                 int bind;
  75         };
  76         int negative;
  77
  78         float value;
  79 }
  80 vg_axis_binds[];
  81
  82 static struct button_binding
  83 {
  84         const char *name;
  85         int bind;
  86
  87         int value; int prev;
  88 }
  89 vg_button_binds[];
  90
  91 #include "vg/config.h"
  92
  93 #pragma GCC diagnostic push
  94 #pragma GCC diagnostic ignored "-Wreturn-type"
  95
  96 static inline float vg_get_axis( const char *axis )
  97 {
  98         for( int i = 0; i < vg_list_size( vg_axis_binds ); i ++ )
  99         {
 100                 if( !strcmp( axis, vg_axis_binds[i].name ) )
 101                 {
 102                         return vg_axis_binds[i].value;
 103                 }
 104         }
 105 }
 106
 107 static inline struct button_binding *vg_get_button_ptr( const char *button )
 108 {
 109         for( int i = 0; i < vg_list_size( vg_button_binds ); i ++ )
 110         {
 111                 if( !strcmp( button, vg_button_binds[i].name ) )
 112                 {
 113                         return vg_button_binds + i;
 114                 }
 115         }
 116 }
 117 #pragma GCC diagnostic pop
 118
 119 static inline int vg_get_button( const char *button )
 120 {
 121         return vg_get_button_ptr( button )->value;
 122 }
 123
 124 static inline int vg_get_button_down( const char *button )
 125 {
 126         struct button_binding *bind = vg_get_button_ptr( button );
 127         return bind->value & (bind->value ^ bind->prev);
 128 }
 129
 130 static inline int vg_get_button_up( const char *button )
 131 {
 132         struct button_binding *bind = vg_get_button_ptr( button );
 133         return bind->prev & (bind->value ^ bind->prev);
 134 }
 135
 136 static inline int key_is_keyboard( int const id )
 137 {
 138         vg_static_assert( GLFW_MOUSE_BUTTON_LAST < GLFW_KEY_SPACE, "GLFW: Mouse has too many buttons" );
 139         return id > GLFW_MOUSE_BUTTON_LAST;
 140 }
 141
 142 // Mouse AND Keyboard get button press
 143 int get_button_cross_device( int const id )
 144 {
 145         if( key_is_keyboard( id ) )
 146         {
 147                 return glfwGetKey( vg_window, id );
 148         }
 149         else
 150         {
 151                 return glfwGetMouseButton( vg_window, id ) == GLFW_PRESS;
 152         }
 153 }
 154
 155 void vg_update_inputs(void)
 156 {
 157         // Update button inputs
 158         for( int i = 0; i < vg_list_size( vg_button_binds ); i ++ )
 159         {
 160                 struct button_binding *binding = vg_button_binds + i;
 161                 binding->prev = binding->value;
 162
 163                 if( vg_input_mode == k_EInputMode_pc )
 164                 {
 165                         binding->value = get_button_cross_device( binding->bind );
 166                 }
 167                 else
 168                 {
 169                         binding->value = vg_gamepad.buttons[ binding->bind ];
 170                 }
 171         }
 172
 173         // Update axis inputs
 174         for( int i = 0; i < vg_list_size( vg_axis_binds ); i ++ )
 175         {
 176                 struct axis_binding *binding = vg_axis_binds + i;
 177
 178                 if( vg_input_mode == k_EInputMode_pc )
 179                 {
 180                         binding->value  = get_button_cross_device( binding->positive );
 181                         binding->value -= get_button_cross_device( binding->negative );
 182                 }
 183                 else
 184                 {
 185                         binding->value = vg_gamepad.axes[ binding->bind ];
 186                 }
 187         }
 188 }
 189
 190 // Engine main
 191 // ===========================================================================================================
 192
 193 #ifndef VG_RELEASE
 194 void vg_checkgl( const char *src_info )
 195 {
 196         GLenum err;
 197         while( (err = glGetError()) != GL_NO_ERROR )
 198         {
 199                 vg_error( "(%s) OpenGL Error: #%d\n", src_info, err );
 200         }
 201 }
 202
 203  #define VG_STRINGIT( X ) #X
 204  #define VG_CHECK_GL() vg_checkgl( __FILE__ ":L" VG_STRINGIT(__LINE__) )
 205 #else
 206  #define VG_CHECK_GL()
 207 #endif
 208
 209
 210 #define VG_GAMELOOP
 211
 212 void( *vg_on_exit[16] )(void);
 213 u32 vg_exit_count = 0;
 214
 215 // Add a shutdown step
 216 void vg_register_exit( void( *funcptr )(void), const char *name )
 217 {
 218         vg_info( "exit registered: (%u)'%s'\n", vg_exit_count, name );
 219         vg_on_exit[ vg_exit_count ++ ] = funcptr;
 220 }
 221
 222 void vg_exit(void)
 223 {
 224         for( int i = vg_exit_count-1; i >= 0; i -- )
 225         {
 226                 vg_info( "engine_exit[%d]()\n", i );
 227                 vg_on_exit[i]();
 228         }
 229
 230         vg_info( "done\n" );
 231 }
 232
 233 // Forcefully exit program after error
 234 void vg_exiterr( const char *strErr )
 235 {
 236         vg_error( "Engine Fatal: %s\n", strErr );
 237         vg_exit();
 238         exit(0);
 239 }
 240
 241 // Callbacks
 242 // ---------
 243
 244 void vg_mouse_callback( GLFWwindow* ptrW, double xpos, double ypos )
 245 {
 246         vg_mouse[0] = xpos;
 247         vg_mouse[1] = ypos;
 248 }
 249
 250 void vg_scroll_callback( GLFWwindow* ptrW, double xoffset, double yoffset )
 251 {
 252
 253 }
 254
 255 void vg_framebuffer_resize_callback( GLFWwindow *ptrW, int w, int h )
 256 {
 257         vg_window_x = w;
 258         vg_window_y = h;
 259 }
 260
 261 static void vg_register(void) VG_GAMELOOP;
 262 static void vg_start(void) VG_GAMELOOP;
 263 static void vg_update(void) VG_GAMELOOP;
 264 static void vg_render(void) VG_GAMELOOP;
 265 static void vg_ui(void) VG_GAMELOOP;
 266 static void vg_free(void) VG_GAMELOOP;
 267
 268 static void vg_init( int argc, char *argv[], const char *window_name )
 269 {
 270 #ifdef VG_STEAM
 271         // Initialize steamworks
 272         if( !sw_init( 1218140U ) )
 273         {
 274                 vg_exiterr( "Steamworks failed to initialize" );
 275         }
 276         else
 277         {
 278                 vg_register_exit( &sw_SteamAPI_Shutdown, "SteamAPI" );
 279         }
 280 #endif
 281
 282         // Context creation
 283         // ==========================================================================================================================
 284         glfwInit();
 285         glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 );
 286         glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 3 );
 287         glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
 288         glfwWindowHint( GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE );
 289
 290         glfwWindowHint( GLFW_SAMPLES, 4 );
 291
 292         GLFWmonitor *monitor_primary = glfwGetPrimaryMonitor();
 293
 294         const GLFWvidmode *mode = glfwGetVideoMode( monitor_primary );
 295         glfwWindowHint( GLFW_RED_BITS, mode->redBits );
 296         glfwWindowHint( GLFW_GREEN_BITS, mode->greenBits );
 297         glfwWindowHint( GLFW_BLUE_BITS, mode->blueBits );
 298         glfwWindowHint( GLFW_REFRESH_RATE, mode->refreshRate );
 299
 300         if( !(vg_window = glfwCreateWindow( vg_window_x, vg_window_y, window_name, NULL, NULL)) )
 301         {
 302                 vg_exiterr( "GLFW Failed to initialize" );
 303         }
 304         else
 305         {
 306                 vg_register_exit( &glfwTerminate, "glfwTerminate" );
 307         }
 308
 309         glfwMakeContextCurrent( vg_window );
 310         glfwSwapInterval( 1 );
 311
 312         // Set callbacks
 313         glfwSetFramebufferSizeCallback( vg_window, vg_framebuffer_resize_callback );
 314
 315         glfwSetCursorPosCallback( vg_window, vg_mouse_callback );
 316         glfwSetScrollCallback( vg_window, vg_scroll_callback );
 317
 318         //glfwSetCharCallback( vg_window, console_proc_wchar );
 319         //glfwSetKeyCallback( vg_window, console_proc_key );
 320         //glfwSetInputMode(vg_window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
 321
 322         if( !gladLoadGLLoader((GLADloadproc)glfwGetProcAddress) )
 323         {
 324                 vg_exiterr( "Glad failed to initialize" );
 325         }
 326
 327         const unsigned char* glver = glGetString( GL_VERSION );
 328         vg_success( "Load setup complete, OpenGL version: %s\n", glver );
 329
 330         for( int id = 0; id <= GLFW_JOYSTICK_LAST; id ++ )
 331         {
 332                 if( glfwJoystickIsGamepad( id ) )
 333                 {
 334                         vg_gamepad_name = glfwGetGamepadName( id );
 335                         vg_success( "Gamepad with mapping registered: %s\n", vg_gamepad_name );
 336
 337                         vg_gamepad_ready = 1;
 338                         vg_gamepad_id = id;
 339
 340                         break;
 341                 }
 342         }
 343
 344         vg_audio_init();
 345         vg_register_exit( &vg_audio_free, "vg_audio_free" );
 346         vg_lines_init();
 347         vg_register_exit( &vg_lines_free, "vg_lines_free" );
 348
 349         vg_register();
 350         vg_register_exit( &vg_free, "vg_free" );
 351
 352         if( vg_shaders_compile() )
 353         {
 354                 vg_start();
 355
 356                 // Main gameloop
 357                 while( !glfwWindowShouldClose( vg_window ) )
 358                 {
 359                         glfwPollEvents();
 360
 361                         #ifdef VG_STEAM
 362                         sw_RunSteamEventLoop();
 363                         #endif
 364
 365                         vg_time_last = vg_time;
 366                         vg_time = glfwGetTime();
 367                         vg_time_delta = vg_min( vg_time - vg_time_last, 0.1f );
 368
 369                         vg_update_inputs();
 370                         vg_update();
 371                         vg_render();
 372
 373                         vg_lines_drawall();
 374
 375                         vg_ui();
 376
 377                         glfwSwapBuffers( vg_window );
 378
 379                         VG_CHECK_GL();
 380                 }
 381         }
 382
 383         vg_exit();
 384 }
 385
 386 // Screen projections
 387 // ============================================================================================
 388
 389 void vg_projection_update(void)
 390 {
 391         // Do transform local->world
 392         vg_mouse_ws[0] = vg_mouse[0];
 393         vg_mouse_ws[1] = vg_mouse[1];
 394         vg_mouse_ws[2] = 1.0f;
 395
 396         vg_mouse_ws[0] =   (2.0f * vg_mouse_ws[0]) / ((float)vg_window_x) - 1.0f;
 397         vg_mouse_ws[1] = -((2.0f * vg_mouse_ws[1]) / ((float)vg_window_y) - 1.0f);
 398
 399         m3x3f inverse;
 400         m3x3_inv( vg_pv, inverse );
 401         m3x3_mulv( inverse, vg_mouse_ws, vg_mouse_ws );
 402 }
 403
 404 #endif
 405
 406 u32 NvOptimusEnablement = 0x00000001;
 407 int AmdPowerXpressRequestHighPerformance = 1;