projects / vg.git / blob
? search:


0122c92e5043f26ccbb9141fb1ad688f3dd366f4
[vg.git] / vg_input.h
1 /* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
2 #ifndef VG_INPUT_H
3 #define VG_INPUT_H
4
5 #include "vg/vg_loader.h"
6
7 #define VG_MAX_CONTROLLERS 4
8
9 static float controller_deadzone = 0.05f;
10 typedef u32 vg_input_op;
11 typedef vg_input_op *vg_input_program;
12
13 enum vg_input_type {
14 k_vg_input_type_button_u8,
15 k_vg_input_type_axis_f32,
16 k_vg_input_type_joy_v2f
17 };
18
19 enum vg_input_op {
20 /* data source */
21 vg_keyboard,
22 vg_mouse,
23 vg_joy_button,
24 vg_joy_axis,
25 vg_joy_ls,
26 vg_joy_rs,
27
28 /* modes */
29 vg_mode_mul,
30 vg_mode_sub,
31 vg_mode_add,
32 vg_mode_absmax,
33 vg_mode_max,
34
35 /* control */
36 vg_index,
37 vg_end,
38 vg_gui_visible,
39
40 /* math */
41 vg_normalize
42 };
43
44 struct{
45 const u8 *sdl_keys;
46 u32 sdl_mouse;
47
48 struct vg_controller{
49 SDL_GameController *handle; /* handle for controller. NULL if unused */
50 SDL_JoystickID instance_id; /* uid used in events */
51
52 float axises[ SDL_CONTROLLER_AXIS_MAX ];
53 u32 buttons[ SDL_CONTROLLER_BUTTON_MAX ];
54 }
55 controllers[4];
56
57 int active_controller_index; /* most recent controller (by button press)
58 will be -1 if no controllers active */
59
60 /* what the user is currently using. the keyboard and controller are still
61 * active simultaneously, but this reflects what the UI should show */
62 enum input_method{
63 k_input_method_kbm,
64 k_input_method_controller
65 }
66 display_input_method;
67 SDL_GameControllerType display_input_type;
68 }
69 static vg_input = { .active_controller_index = -2 };
70
71 static u8 vg_getkey( SDL_Keycode kc )
72 {
73 SDL_Scancode sc = SDL_GetScancodeFromKey( kc );
74 return vg_input.sdl_keys[sc];
75 }
76
77 /*
78 * takes SDL device index, and tries to open that on any free channel
79 */
80 static int vg_open_gamecontroller( Sint32 index )
81 {
82 struct vg_controller *controller = NULL;
83 int vg_id = 0;
84 const char *name = SDL_GameControllerNameForIndex( index );
85 SDL_JoystickID instance_id = SDL_JoystickGetDeviceInstanceID( index );
86
87 if( instance_id == -1 ){
88 vg_error( ". Invalid device index (vg_open_gamecontroller)\n" );
89 return -1;
90 }
91
92 for( int j=0; j<VG_MAX_CONTROLLERS; j++ ){
93 struct vg_controller *esta = &vg_input.controllers[j];
94
95 if( esta->handle ){
96 if( esta->instance_id == instance_id ){
97 vg_warn( " . SDL_JoystickID[%d] is already in open at index #%d\n",
98 esta->instance_id, j );
99 return -1;
100 }
101 }
102 else{
103 if( !controller ){
104 controller = &vg_input.controllers[j];
105 vg_id = j;
106 }
107 }
108 }
109
110 if( controller ){
111 controller->handle = SDL_GameControllerOpen( index );
112 controller->instance_id = instance_id;
113
114 if( controller->handle ){
115 vg_success(
116 " . opened SDL_JoystickID[%d] as controller '%s' at index #%d\n",
117 instance_id, name, vg_id );
118
119 for( u32 i=0; i< SDL_CONTROLLER_BUTTON_MAX; i++ )
120 controller->buttons[i] = 0;
121
122 for( u32 i=0; i< SDL_CONTROLLER_AXIS_MAX; i++ )
123 controller->axises[i] = 0.0f;
124
125 if( vg_input.active_controller_index == -2 ){
126 vg_input.active_controller_index = vg_id;
127 vg_input.display_input_method = k_input_method_controller;
128 vg_input.display_input_type =
129 SDL_GameControllerGetType( controller->handle );
130 }
131
132 return vg_id;
133 }
134 else{
135 vg_error( ". Failed to attach game controller '%s'. Reason: %s\n",
136 name, SDL_GetError() );
137 return -1;
138 }
139 }
140 else{
141 vg_error( ". Too many controllers open! ignoring '%s'\n", name );
142 return -1;
143 }
144 }
145
146 static void vg_input_device_event( SDL_Event *ev )
147 {
148 if( ev->type == SDL_CONTROLLERDEVICEADDED ){
149 int is_controller = SDL_IsGameController( ev->cdevice.which );
150 const char *name = SDL_JoystickNameForIndex( ev->cdevice.which );
151
152 Sint32 index = ev->cdevice.which;
153 SDL_JoystickID instance_id = SDL_JoystickGetDeviceInstanceID( index );
154 vg_info( "SDL_CONTROLLERDEVICEADDED | device index: %d, name: '%s'\n",
155 index, name );
156
157 if( is_controller ){
158 vg_open_gamecontroller( index );
159 }
160 }
161 else if( ev->type == SDL_CONTROLLERDEVICEREMOVED ){
162 vg_info( "SDL_CONTROLLERDEVICEREMOVED | instance_id: %d\n",
163 ev->cdevice.which );
164
165 for( int i=0; i<VG_MAX_CONTROLLERS; i++ ){
166 struct vg_controller *controller = &vg_input.controllers[i];
167
168 if( controller->handle ){
169 if( controller->instance_id == ev->cdevice.which ){
170 vg_info( " . closing controller at index #%d\n", i );
171 SDL_GameControllerClose( controller->handle );
172 controller->handle = NULL;
173 controller->instance_id = -1;
174
175 if( vg_input.active_controller_index == i ){
176 vg_input.active_controller_index = -1;
177 vg_input.display_input_method = k_input_method_kbm;
178 vg_info( "display_input: k_input_method_kbm\n" );
179 }
180 break;
181 }
182 }
183 }
184 }
185 }
186
187 static void vg_input_controller_event( SDL_Event *ev )
188 {
189 if( ev->type == SDL_CONTROLLERAXISMOTION ){
190 for( int i=0; i<VG_MAX_CONTROLLERS; i++ ){
191 struct vg_controller *esta = &vg_input.controllers[i];
192
193 if( ev->caxis.which == esta->instance_id ){
194 float value = (float)ev->caxis.value / 32767.0f;
195
196 if( ev->caxis.axis == SDL_CONTROLLER_AXIS_LEFTX ||
197 ev->caxis.axis == SDL_CONTROLLER_AXIS_LEFTY ||
198 ev->caxis.axis == SDL_CONTROLLER_AXIS_RIGHTX ||
199 ev->caxis.axis == SDL_CONTROLLER_AXIS_RIGHTY )
200 {
201 float deadz = vg_clampf( controller_deadzone, 0.0f, 0.999f ),
202 high = vg_maxf( 0.0f, fabsf(value) - deadz );
203
204 value = vg_signf(value) * (high / (1.0f-deadz));
205 }
206
207 esta->axises[ ev->caxis.axis ] = value;
208 break;
209 }
210 }
211 }
212 else if( ev->type == SDL_CONTROLLERBUTTONDOWN ){
213 struct vg_controller *active = NULL;
214
215 if( vg_input.active_controller_index >= 0 )
216 active = &vg_input.controllers[vg_input.active_controller_index];
217
218 if( !active || (ev->cbutton.which != active->instance_id) ){
219 active = NULL;
220 vg_input.active_controller_index = -1;
221 vg_input.display_input_method = k_input_method_kbm;
222
223 for( int i=0; i<VG_MAX_CONTROLLERS; i++ ){
224 if( vg_input.controllers[i].instance_id == ev->cbutton.which ){
225 active = &vg_input.controllers[i];
226 vg_input.active_controller_index = i;
227 vg_input.display_input_type =
228 SDL_GameControllerGetType(active->handle);
229 break;
230 }
231 }
232
233 if( active ){
234 vg_info( "Switching active controller index to #%d\n",
235 vg_input.active_controller_index );
236 }
237 else{
238 vg_error( "Input out of range (SDL_JoystickID#%d)\n",
239 ev->cbutton.which );
240 }
241 }
242
243 if( active ){
244 if( vg_input.display_input_method != k_input_method_controller ){
245 vg_input.display_input_method = k_input_method_controller;
246 vg_info( "display_input: k_input_method_controller\n" );
247 }
248 active->buttons[ ev->cbutton.button ] = 1;
249 }
250 }
251 else if( ev->type == SDL_CONTROLLERBUTTONUP ){
252 for( int i=0; i<VG_MAX_CONTROLLERS; i++ ){
253 struct vg_controller *esta = &vg_input.controllers[i];
254
255 if( ev->cbutton.which == esta->instance_id ){
256 esta->buttons[ ev->cbutton.button ] = 0;
257 break;
258 }
259 }
260 }
261 }
262
263 static void vg_process_inputs(void)
264 {
265 int count;
266 vg_input.sdl_keys = SDL_GetKeyboardState( &count );
267 vg_input.sdl_mouse = SDL_GetMouseState(NULL,NULL);
268
269 if( vg_input.display_input_method != k_input_method_kbm ){
270 /* check for giving keyboard priority */
271 for( int i=0; i<count; i++ ){
272 if( vg_input.sdl_keys[i] ){
273 vg_input.display_input_method = k_input_method_kbm;
274 vg_info( "display_input: k_input_method_kbm (keyboard %d)\n", i );
275 break;
276 }
277 }
278
279 /* check for giving mouse priority */
280 if( vg_input.sdl_mouse &
281 (SDL_BUTTON(SDL_BUTTON_LEFT)|SDL_BUTTON(SDL_BUTTON_RIGHT)|
282 SDL_BUTTON(SDL_BUTTON_MIDDLE)) )
283 {
284 vg_input.display_input_method = k_input_method_kbm;
285 vg_info( "display_input: k_input_method_kbm (mouse)\n" );
286 }
287 }
288 }
289
290 static void async_vg_input_init( void *payload, u32 size )
291 {
292 VG_VAR_F32( controller_deadzone, flags=VG_VAR_PERSISTENT );
293
294 vg_info( "Checking for controllers\n" );
295 SDL_GameControllerAddMappingsFromFile( "gamecontrollerdb.txt" );
296
297 int joy_count = SDL_NumJoysticks();
298 for( int i=0; i<joy_count; i++ ) {
299 const char *name = SDL_JoystickNameForIndex( i );
300 int is_controller = SDL_IsGameController(i);
301
302 vg_info( "%d: %s [controller: %d]\n", i, name, is_controller );
303
304 if( is_controller ){
305 vg_open_gamecontroller( i );
306 }
307 }
308 }
309
310 static void vg_input_init(void)
311 {
312 vg_async_call( async_vg_input_init, NULL, 0 );
313 }
314
315 static void vg_input_free(void)
316 {
317 for( int i=0; i<VG_MAX_CONTROLLERS; i++ ){
318 struct vg_controller *controller = &vg_input.controllers[i];
319
320 if( controller->handle ){
321 SDL_GameControllerClose( controller->handle );
322 controller->handle = NULL;
323 }
324 }
325 }
326
327 struct vg_controller *vg_active_controller(void){
328 if( vg_input.active_controller_index >= 0 )
329 return &vg_input.controllers[vg_input.active_controller_index];
330 else
331 return NULL;
332 }
333
334 static u8 vg_controller_button( SDL_GameControllerButton button ){
335 struct vg_controller *c = vg_active_controller();
336 if( c ) return c->buttons[ button ];
337 else return 0;
338 }
339
340 static f32 vg_controller_axis( SDL_GameControllerAxis axis ){
341 struct vg_controller *c = vg_active_controller();
342 if( c ) return c->axises[ axis ];
343 else return 0;
344 }
345
346 static void vg_input_apply_to_u8( vg_input_op mode, u8 data, u8 *inout_result ){
347 if ( mode == vg_mode_absmax ) *inout_result |= data;
348 else if( mode == vg_mode_mul ) *inout_result &= data;
349 else vg_fatal_error( "mode not supported for destination type (%d)", mode );
350 }
351
352 static void vg_input_apply_to_f32( vg_input_op mode, f32 data,
353 f32 *inout_result ){
354 if ( mode == vg_mode_absmax ){
355 if( fabsf(data) > fabsf(*inout_result) )
356 *inout_result = data;
357 }
358 else if( mode == vg_mode_max ) *inout_result = vg_maxf(*inout_result,data);
359 else if( mode == vg_mode_mul ) *inout_result *= (f32)data;
360 else if( mode == vg_mode_sub ) *inout_result -= (f32)data;
361 else if( mode == vg_mode_add ) *inout_result += (f32)data;
362 else vg_fatal_error( "mode not supported for destination type (%d)", mode );
363 }
364
365 /*
366 * Run an input program. out_result must point to memory with sufficient
367 * storage respective to the size set by type.
368 */
369 static void vg_exec_input_program( enum vg_input_type type, vg_input_op *ops,
370 void *out_result ){
371 u8 *out_button = NULL;
372 f32 *out_joy = NULL;
373
374 if( type == k_vg_input_type_button_u8 ){
375 out_button = out_result;
376 *out_button = 0;
377 }
378 else if( type == k_vg_input_type_axis_f32 ){
379 out_joy = out_result;
380 out_joy[0] = 0.0f;
381 }
382 else if( type == k_vg_input_type_joy_v2f ){
383 out_joy = out_result;
384 out_joy[0] = 0.0f;
385 out_joy[1] = 0.0f;
386 }
387
388 /* computer state */
389 vg_input_op mode = vg_mode_absmax;
390 u32 pc = 0, index = 0;
391
392 next_code:;
393 vg_input_op op = ops[ pc ++ ];
394
395 if( (op >= vg_mode_mul) && (op <= vg_mode_max) )
396 mode = op;
397 else if( (op == vg_keyboard) || (op == vg_mouse) || (op == vg_joy_button) ){
398 u8 state = 0;
399
400 if( op == vg_keyboard )
401 state = vg_getkey(ops[pc ++]);
402 else if( op == vg_mouse )
403 state = (vg_input.sdl_mouse & SDL_BUTTON(ops[pc ++]))?1:0;
404 else
405 state = vg_controller_button(ops[pc ++]);
406
407 if( type == k_vg_input_type_button_u8 )
408 vg_input_apply_to_u8( mode, state, out_button );
409 else
410 vg_input_apply_to_f32( mode, (f32)state, &out_joy[index] );
411 }
412 else if( op == vg_joy_axis ){
413 f32 state = vg_controller_axis( ops[pc ++] );
414 if( type == k_vg_input_type_button_u8 )
415 vg_input_apply_to_u8( mode, state>0.5f?1:0, out_button );
416 else
417 vg_input_apply_to_f32( mode, state, &out_joy[index] );
418 }
419 else if( (op == vg_joy_ls) || (op == vg_joy_rs) ){
420 if( type == k_vg_input_type_joy_v2f ){
421 vg_input_apply_to_f32( mode,
422 vg_controller_axis( op==vg_joy_ls? SDL_CONTROLLER_AXIS_LEFTX:
423 SDL_CONTROLLER_AXIS_RIGHTX),
424 &out_joy[0] );
425 vg_input_apply_to_f32( mode,
426 vg_controller_axis( op==vg_joy_ls? SDL_CONTROLLER_AXIS_LEFTY:
427 SDL_CONTROLLER_AXIS_RIGHTY),
428 &out_joy[1] );
429 }
430 }
431 else if( op == vg_index )
432 index = ops[pc ++];
433 else if( op == vg_end )
434 return;
435 else if( op == vg_normalize )
436 v2_normalize( out_joy );
437 else if( op == vg_gui_visible )
438 pc ++;
439 else
440 vg_fatal_error( "unknown op\n" );
441
442 goto next_code;
443 }
444
445 /*
446 * Get vendor specific button glyphs based on SDL button ID
447 */
448 static const char *controller_button_str( SDL_GameControllerButton button ){
449 static const char *controller_glyphs[ SDL_CONTROLLER_BUTTON_MAX ][2] = {
450 /* xbox/generic playstation */
451 [ SDL_CONTROLLER_BUTTON_A ] = { "\x1e\x85","\x1e\x82" },
452 [ SDL_CONTROLLER_BUTTON_B ] = { "\x1e\x86","\x1e\x81" },
453 [ SDL_CONTROLLER_BUTTON_X ] = { "\x1e\x83","\x1e\x7f" },
454 [ SDL_CONTROLLER_BUTTON_Y ] = { "\x1e\x84","\x1e\x80" },
455 [ SDL_CONTROLLER_BUTTON_LEFTSTICK ] = { "\x87", "\x87" },
456 [ SDL_CONTROLLER_BUTTON_RIGHTSTICK ] = { "\x8b", "\x8b" },
457 [ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] = { "\x91", "\x91" },
458 [ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ]= { "\x92", "\x92" },
459 [ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] = { "\x1e\x93","\x1e\x93" },
460 [ SDL_CONTROLLER_BUTTON_DPAD_UP ] = { "\x1e\x94","\x1e\x94" },
461 [ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ] = { "\x1e\x95","\x1e\x95" },
462 [ SDL_CONTROLLER_BUTTON_DPAD_DOWN ] = { "\x1e\x96","\x1e\x96" },
463 [ SDL_CONTROLLER_BUTTON_GUIDE ] = { "\x91", "\x91" },
464 };
465
466 if( vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS3 ||
467 vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS4 ||
468 vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS5 )
469 {
470 return controller_glyphs[ button ][ 1 ];
471 }
472 else if( vg_input.display_input_type ==
473 SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO ||
474 vg_input.display_input_type ==
475 SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT ||
476 vg_input.display_input_type ==
477 SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_PAIR ||
478 vg_input.display_input_type ==
479 SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT )
480 {
481 return NULL;
482 }
483 else
484 return controller_glyphs[ button ][ 0 ];
485 }
486
487 /*
488 * Cat keyboard key string. special_glyphs include SR glyphs
489 */
490 static void vg_keyboard_key_string( vg_str *str, u32 key, int special_glyphs ){
491 if( (key >= SDLK_a) && (key <= SDLK_z) ){
492 key = (key-SDLK_a)+(u32)'A';
493
494 if( special_glyphs ){
495 vg_strcatch( str, '\x1f' );
496 vg_strcatch( str, key );
497 vg_strcatch( str, ' ' );
498 }
499 else
500 vg_strcatch( str, key );
501 }
502 else if( (key == SDLK_LSHIFT) || (key == SDLK_RSHIFT) )
503 vg_strcat( str, special_glyphs? "\x9e": "shift" );
504 else if( (key == SDLK_LCTRL) || (key == SDLK_RCTRL) )
505 vg_strcat( str, special_glyphs? "\x9f": "ctrl" );
506 else if( (key == SDLK_LALT) || (key == SDLK_RALT) )
507 vg_strcat( str, special_glyphs? "\xa0": "alt" );
508 else if( key == SDLK_SPACE )
509 vg_strcat( str, special_glyphs? "\xa1": "space" );
510 else if( (key == SDLK_RETURN) || (key == SDLK_RETURN2) )
511 vg_strcat( str, special_glyphs? "\xa2": "return" );
512 else if( key == SDLK_ESCAPE )
513 vg_strcat( str, special_glyphs? "\xa3": "escape" );
514 else if( key == SDLK_RIGHT )
515 vg_strcat( str, special_glyphs? "\x1f\x95 ": "right" );
516 else if( key == SDLK_LEFT )
517 vg_strcat( str, special_glyphs? "\x1f\x93 ": "left" );
518 else if( key == SDLK_UP )
519 vg_strcat( str, special_glyphs? "\x1f\x94 ": "up" );
520 else if( key == SDLK_DOWN )
521 vg_strcat( str, special_glyphs? "\x1f\x96 ": "down" );
522 else {
523 vg_strcat( str, "keyboard key #" );
524 vg_strcati32( str, key );
525 }
526 }
527
528 /*
529 * Cat mouse button string. special_glyphs include SR glyphs
530 */
531 static void vg_mouse_button_string( vg_str *str, u32 button,
532 int special_glyphs ){
533 if ( button == SDL_BUTTON_LEFT )
534 vg_strcat( str, special_glyphs? "\x99": "left mouse" );
535 else if( button == SDL_BUTTON_RIGHT )
536 vg_strcat( str, special_glyphs? "\x9a": "right mouse" );
537 else if( button == SDL_BUTTON_MIDDLE )
538 vg_strcat( str, special_glyphs? "\x9c": "middle mouse" );
539 else{
540 vg_strcat( str, "mouse button #" );
541 vg_strcati32( str, button );
542 }
543 }
544
545 /*
546 * Cat string represeinting single axis
547 */
548 static void vg_joy_axis_string( vg_str *str,
549 SDL_GameControllerAxis axis, int special_glyphs ){
550 if( axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT )
551 vg_strcat( str, special_glyphs?"\x8f":"left trigger" );
552 else if( axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT )
553 vg_strcat( str, special_glyphs?"\x90":"right trigger" );
554 else if( axis == SDL_CONTROLLER_AXIS_LEFTX )
555 vg_strcat( str, special_glyphs?"\x88":"left stick horizontal" );
556 else if( axis == SDL_CONTROLLER_AXIS_LEFTY )
557 vg_strcat( str, special_glyphs?"\x89":"left stick vertical" );
558 else if( axis == SDL_CONTROLLER_AXIS_RIGHTX )
559 vg_strcat( str, special_glyphs?"\x8c":"right stick horizontal" );
560 else if( axis == SDL_CONTROLLER_AXIS_RIGHTY )
561 vg_strcat( str, special_glyphs?"\x8d":"right stick vertical" );
562 else{
563 vg_strcat( str, "axis " );
564 vg_strcati32( str, axis );
565 }
566 }
567
568 /*
569 * Cat string represeinting whole joystick
570 */
571 static void vg_joy_string( vg_str *str, vg_input_op op, int special_glyphs ){
572 if( op == vg_joy_ls )
573 vg_strcat( str, special_glyphs? "\x87": "left stick" );
574 else
575 vg_strcat( str, special_glyphs? "\x8b": "right stick" );
576 }
577
578 /*
579 * Convert an input program into a readable string
580 */
581 static void vg_input_string( vg_str *str, vg_input_op *ops, int glyphs ){
582 u32 pc = 0;
583 int applicable = 0, visible = 1;
584
585 next_code:;
586 vg_input_op op = ops[ pc ++ ];
587
588 if( (op == vg_keyboard) || (op == vg_mouse) ){
589 if( (vg_input.display_input_method == k_input_method_kbm) && visible ){
590 applicable = 1;
591
592 if( op == vg_keyboard )
593 vg_keyboard_key_string( str, ops[pc], glyphs );
594 else
595 vg_mouse_button_string( str, ops[pc], glyphs );
596 }
597 else applicable = 0;
598 pc ++;
599 }
600 else if( (op == vg_joy_button) || (op == vg_joy_axis) ){
601 if( (vg_input.display_input_method == k_input_method_controller)
602 && visible ){
603 applicable = 1;
604
605 if( op == vg_joy_button )
606 vg_strcat( str, controller_button_str(ops[pc]) );
607 else
608 vg_joy_axis_string( str, ops[pc], glyphs );
609 }
610 else applicable = 0;
611 pc ++;
612 }
613 else if( (op == vg_joy_ls) || (op == vg_joy_rs) ){
614 if( (vg_input.display_input_method == k_input_method_controller)
615 && visible ){
616 applicable = 1;
617 vg_joy_string( str, op, glyphs );
618 }
619 else applicable = 0;
620 }
621 else if( op == vg_mode_mul ){
622 if( applicable && visible )
623 vg_strcat( str, " + " );
624 }
625 else if( op == vg_index )
626 pc ++;
627 else if( op == vg_gui_visible )
628 visible = ops[pc++];
629 else if( op == vg_end )
630 return;
631
632 goto next_code;
633 }
634
635 #endif
Voyager Game Engine