2013-08-07 21:45:56 -07:00
/*
2015-01-01 15:04:46 -08:00
* Copyright 2011 - 2015 Branimir Karadzic . All rights reserved .
2013-08-07 21:45:56 -07:00
* License : http : //www.opensource.org/licenses/BSD-2-Clause
*/
2015-11-14 16:39:15 -08:00
# include <bx/bx.h>
2015-09-18 20:16:24 -07:00
# include <bgfx/bgfx.h>
2013-08-07 21:45:56 -07:00
# include <bx/string.h>
2014-05-03 15:18:28 -07:00
# include <bx/readerwriter.h>
2013-08-07 21:45:56 -07:00
2013-10-23 22:48:16 -07:00
# include <time.h>
2015-08-21 20:08:03 -07:00
# if BX_PLATFORM_EMSCRIPTEN
# include <emscripten.h>
# endif // BX_PLATFORM_EMSCRIPTEN
2013-08-07 21:45:56 -07:00
# include "entry_p.h"
# include "cmd.h"
# include "input.h"
2015-11-14 16:39:15 -08:00
# define RMT_ENABLED ENTRY_CONFIG_PROFILER
2015-11-16 10:42:56 -04:00
# include <remotery/lib/Remotery.h>
2015-11-12 22:26:50 -08:00
2014-06-01 12:01:50 -07:00
extern " C " int _main_ ( int _argc , char * * _argv ) ;
2013-08-07 21:45:56 -07:00
namespace entry
{
static uint32_t s_debug = BGFX_DEBUG_NONE ;
static uint32_t s_reset = BGFX_RESET_NONE ;
static bool s_exit = false ;
2015-11-12 22:26:50 -08:00
static Remotery * s_rmt = NULL ;
2014-05-03 15:18:28 -07:00
static bx : : FileReaderI * s_fileReader = NULL ;
static bx : : FileWriterI * s_fileWriter = NULL ;
2015-02-13 09:43:46 -08:00
2015-11-06 22:03:06 -08:00
extern bx : : AllocatorI * getDefaultAllocator ( ) ;
static bx : : AllocatorI * s_allocator = getDefaultAllocator ( ) ;
2015-02-13 09:43:46 -08:00
2015-11-13 21:11:19 -08:00
void * rmtMalloc ( void * /*_context*/ , rmtU32 _size )
{
return BX_ALLOC ( s_allocator , _size ) ;
}
void * rmtRealloc ( void * /*_context*/ , void * _ptr , rmtU32 _size )
{
return BX_REALLOC ( s_allocator , _ptr , _size ) ;
}
void rmtFree ( void * /*_context*/ , void * _ptr )
{
BX_FREE ( s_allocator , _ptr ) ;
}
2015-02-13 09:43:46 -08:00
# if ENTRY_CONFIG_IMPLEMENT_DEFAULT_ALLOCATOR
2015-11-06 22:03:06 -08:00
bx : : AllocatorI * getDefaultAllocator ( )
2015-02-13 09:43:46 -08:00
{
2015-04-04 19:10:35 -07:00
BX_PRAGMA_DIAGNOSTIC_PUSH ( ) ;
2015-03-29 22:40:35 -07:00
BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC ( 4459 ) ; // warning C4459: declaration of 's_allocator' hides global declaration
2015-04-04 19:10:35 -07:00
BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC ( " -Wshadow " ) ;
2015-02-13 09:43:46 -08:00
static bx : : CrtAllocator s_allocator ;
return & s_allocator ;
2015-04-04 19:10:35 -07:00
BX_PRAGMA_DIAGNOSTIC_POP ( ) ;
2015-02-13 09:43:46 -08:00
}
# endif // ENTRY_CONFIG_IMPLEMENT_DEFAULT_ALLOCATOR
2013-08-07 21:45:56 -07:00
2015-05-30 10:06:26 -07:00
static const char * s_keyName [ ] =
{
" None " ,
" Esc " ,
" Return " ,
" Tab " ,
" Space " ,
" Backspace " ,
" Up " ,
" Down " ,
" Left " ,
" Right " ,
" Insert " ,
" Delete " ,
" Home " ,
" End " ,
" PageUp " ,
" PageDown " ,
" Print " ,
" Plus " ,
" Minus " ,
" LeftBracket " ,
" RightBracket " ,
" Semicolon " ,
" Quote " ,
" Comma " ,
" Period " ,
" Slash " ,
" Backslash " ,
2015-05-30 13:11:18 -07:00
" Tilde " ,
2015-05-30 10:06:26 -07:00
" F1 " ,
" F2 " ,
" F3 " ,
" F4 " ,
" F5 " ,
" F6 " ,
" F7 " ,
" F8 " ,
" F9 " ,
" F10 " ,
" F11 " ,
" F12 " ,
" NumPad0 " ,
" NumPad1 " ,
" NumPad2 " ,
" NumPad3 " ,
" NumPad4 " ,
" NumPad5 " ,
" NumPad6 " ,
" NumPad7 " ,
" NumPad8 " ,
" NumPad9 " ,
" Key0 " ,
" Key1 " ,
" Key2 " ,
" Key3 " ,
" Key4 " ,
" Key5 " ,
" Key6 " ,
" Key7 " ,
" Key8 " ,
" Key9 " ,
" KeyA " ,
" KeyB " ,
" KeyC " ,
" KeyD " ,
" KeyE " ,
" KeyF " ,
" KeyG " ,
" KeyH " ,
" KeyI " ,
" KeyJ " ,
" KeyK " ,
" KeyL " ,
" KeyM " ,
" KeyN " ,
" KeyO " ,
" KeyP " ,
" KeyQ " ,
" KeyR " ,
" KeyS " ,
" KeyT " ,
" KeyU " ,
" KeyV " ,
" KeyW " ,
" KeyX " ,
" KeyY " ,
" KeyZ " ,
" GamepadA " ,
" GamepadB " ,
" GamepadX " ,
" GamepadY " ,
" GamepadThumbL " ,
" GamepadThumbR " ,
" GamepadShoulderL " ,
" GamepadShoulderR " ,
" GamepadUp " ,
" GamepadDown " ,
" GamepadLeft " ,
" GamepadRight " ,
" GamepadBack " ,
" GamepadStart " ,
" GamepadGuide " ,
} ;
BX_STATIC_ASSERT ( Key : : Count = = BX_COUNTOF ( s_keyName ) ) ;
const char * getName ( Key : : Enum _key )
{
BX_CHECK ( _key < Key : : Count , " Invalid key %d. " , _key ) ;
return s_keyName [ _key ] ;
}
2015-03-09 03:52:09 +01:00
char keyToAscii ( Key : : Enum _key , uint8_t _modifiers )
{
const bool isAscii = ( Key : : Key0 < = _key & & _key < = Key : : KeyZ )
| | ( Key : : Esc < = _key & & _key < = Key : : Minus ) ;
if ( ! isAscii )
{
return ' \0 ' ;
}
const bool isNumber = ( Key : : Key0 < = _key & & _key < = Key : : Key9 ) ;
if ( isNumber )
{
return ' 0 ' + ( _key - Key : : Key0 ) ;
}
const bool isChar = ( Key : : KeyA < = _key & & _key < = Key : : KeyZ ) ;
if ( isChar )
{
enum { ShiftMask = Modifier : : LeftShift | Modifier : : RightShift } ;
const bool shift = ! ! ( _modifiers & ShiftMask ) ;
return ( shift ? ' A ' : ' a ' ) + ( _key - Key : : KeyA ) ;
}
switch ( _key )
{
2015-03-11 22:45:34 -07:00
case Key : : Esc : return 0x1b ;
2015-03-11 23:30:41 -07:00
case Key : : Return : return ' \n ' ;
case Key : : Tab : return ' \t ' ;
case Key : : Space : return ' ' ;
2015-03-11 22:45:34 -07:00
case Key : : Backspace : return 0x08 ;
2015-03-11 23:30:41 -07:00
case Key : : Plus : return ' + ' ;
case Key : : Minus : return ' - ' ;
2015-03-11 22:45:34 -07:00
default : break ;
2015-03-09 03:52:09 +01:00
}
2015-03-11 22:45:34 -07:00
return ' \0 ' ;
2015-03-09 03:52:09 +01:00
}
2013-08-07 21:45:56 -07:00
bool setOrToggle ( uint32_t & _flags , const char * _name , uint32_t _bit , int _first , int _argc , char const * const * _argv )
{
if ( 0 = = strcmp ( _argv [ _first ] , _name ) )
{
int arg = _first + 1 ;
if ( _argc > arg )
{
_flags & = ~ _bit ;
_flags | = bx : : toBool ( _argv [ arg ] ) ? _bit : 0 ;
}
else
{
_flags ^ = _bit ;
}
return true ;
}
return false ;
}
int cmdMouseLock ( CmdContext * /*_context*/ , void * /*_userData*/ , int _argc , char const * const * _argv )
{
if ( _argc > 1 )
{
inputSetMouseLock ( _argc > 1 ? bx : : toBool ( _argv [ 1 ] ) : ! inputIsMouseLocked ( ) ) ;
return 0 ;
}
return 1 ;
}
int cmdGraphics ( CmdContext * /*_context*/ , void * /*_userData*/ , int _argc , char const * const * _argv )
{
if ( _argc > 1 )
{
2015-05-15 13:14:35 -07:00
if ( setOrToggle ( s_reset , " vsync " , BGFX_RESET_VSYNC , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " maxaniso " , BGFX_RESET_MAXANISOTROPY , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " hmd " , BGFX_RESET_HMD , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " hmddbg " , BGFX_RESET_HMD_DEBUG , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " hmdrecenter " , BGFX_RESET_HMD_RECENTER , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " msaa " , BGFX_RESET_MSAA_X16 , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " flush " , BGFX_RESET_FLUSH_AFTER_RENDER , 1 , _argc , _argv )
| | setOrToggle ( s_reset , " flip " , BGFX_RESET_FLIP_AFTER_RENDER , 1 , _argc , _argv )
2015-08-17 16:43:56 -07:00
| | setOrToggle ( s_reset , " hidpi " , BGFX_RESET_HIDPI , 1 , _argc , _argv )
2015-04-14 20:03:05 -07:00
)
2013-08-07 21:45:56 -07:00
{
return 0 ;
}
2013-08-08 22:18:19 -07:00
else if ( setOrToggle ( s_debug , " stats " , BGFX_DEBUG_STATS , 1 , _argc , _argv )
| | setOrToggle ( s_debug , " ifh " , BGFX_DEBUG_IFH , 1 , _argc , _argv )
| | setOrToggle ( s_debug , " text " , BGFX_DEBUG_TEXT , 1 , _argc , _argv )
| | setOrToggle ( s_debug , " wireframe " , BGFX_DEBUG_WIREFRAME , 1 , _argc , _argv ) )
2013-08-07 21:45:56 -07:00
{
bgfx : : setDebug ( s_debug ) ;
return 0 ;
}
2013-10-23 22:48:16 -07:00
else if ( 0 = = strcmp ( _argv [ 1 ] , " screenshot " ) )
{
if ( _argc > 2 )
{
bgfx : : saveScreenShot ( _argv [ 2 ] ) ;
}
else
{
time_t tt ;
time ( & tt ) ;
char filePath [ 256 ] ;
bx : : snprintf ( filePath , sizeof ( filePath ) , " temp/screenshot-%d " , tt ) ;
bgfx : : saveScreenShot ( filePath ) ;
}
return 0 ;
}
2015-05-31 15:57:52 -07:00
else if ( 0 = = strcmp ( _argv [ 1 ] , " fullscreen " ) )
{
WindowHandle window = { 0 } ;
toggleFullscreen ( window ) ;
return 0 ;
}
2013-08-07 21:45:56 -07:00
}
return 1 ;
}
int cmdExit ( CmdContext * /*_context*/ , void * /*_userData*/ , int /*_argc*/ , char const * const * /*_argv*/ )
{
s_exit = true ;
return 0 ;
}
2015-01-07 22:36:36 -08:00
static const InputBinding s_bindings [ ] =
2013-08-07 21:45:56 -07:00
{
2015-05-30 22:11:42 -07:00
{ entry : : Key : : KeyQ , entry : : Modifier : : LeftCtrl , 1 , NULL , " exit " } ,
2015-05-31 15:57:52 -07:00
{ entry : : Key : : KeyQ , entry : : Modifier : : RightCtrl , 1 , NULL , " exit " } ,
{ entry : : Key : : KeyF , entry : : Modifier : : LeftCtrl , 1 , NULL , " graphics fullscreen " } ,
{ entry : : Key : : KeyF , entry : : Modifier : : RightCtrl , 1 , NULL , " graphics fullscreen " } ,
2015-09-01 22:15:47 -07:00
{ entry : : Key : : Return , entry : : Modifier : : RightAlt , 1 , NULL , " graphics fullscreen " } ,
2015-05-30 22:11:42 -07:00
{ entry : : Key : : F1 , entry : : Modifier : : None , 1 , NULL , " graphics stats " } ,
{ entry : : Key : : GamepadStart , entry : : Modifier : : None , 1 , NULL , " graphics stats " } ,
{ entry : : Key : : F1 , entry : : Modifier : : LeftShift , 1 , NULL , " graphics stats 0 \n graphics text 0 " } ,
{ entry : : Key : : F3 , entry : : Modifier : : None , 1 , NULL , " graphics wireframe " } ,
{ entry : : Key : : F4 , entry : : Modifier : : None , 1 , NULL , " graphics hmd " } ,
{ entry : : Key : : F4 , entry : : Modifier : : LeftShift , 1 , NULL , " graphics hmdrecenter " } ,
{ entry : : Key : : F4 , entry : : Modifier : : LeftCtrl , 1 , NULL , " graphics hmddbg " } ,
{ entry : : Key : : F7 , entry : : Modifier : : None , 1 , NULL , " graphics vsync " } ,
{ entry : : Key : : F8 , entry : : Modifier : : None , 1 , NULL , " graphics msaa " } ,
{ entry : : Key : : F9 , entry : : Modifier : : None , 1 , NULL , " graphics flush " } ,
2015-08-17 16:43:56 -07:00
{ entry : : Key : : F10 , entry : : Modifier : : None , 1 , NULL , " graphics hidpi " } ,
2015-05-30 22:11:42 -07:00
{ entry : : Key : : Print , entry : : Modifier : : None , 1 , NULL , " graphics screenshot " } ,
2013-08-07 21:45:56 -07:00
INPUT_BINDING_END
} ;
2015-08-21 20:08:03 -07:00
# if BX_PLATFORM_EMSCRIPTEN
static AppI * s_app ;
static void updateApp ( )
{
s_app - > update ( ) ;
}
# endif // BX_PLATFORM_EMSCRIPTEN
int runApp ( AppI * _app , int _argc , char * * _argv )
{
_app - > init ( _argc , _argv ) ;
2015-10-20 22:45:35 -07:00
bgfx : : frame ( ) ;
2015-08-21 20:08:03 -07:00
2015-10-20 19:00:13 -07:00
WindowHandle defaultWindow = { 0 } ;
setWindowSize ( defaultWindow , ENTRY_DEFAULT_WIDTH , ENTRY_DEFAULT_HEIGHT ) ;
2015-08-21 20:08:03 -07:00
# if BX_PLATFORM_EMSCRIPTEN
s_app = _app ;
emscripten_set_main_loop ( & updateApp , - 1 , 1 ) ;
# else
while ( _app - > update ( ) ) ;
# endif // BX_PLATFORM_EMSCRIPTEN
return _app - > shutdown ( ) ;
}
2013-08-07 21:45:56 -07:00
int main ( int _argc , char * * _argv )
{
2013-12-11 04:37:51 +01:00
//DBG(BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME);
2013-12-24 21:30:28 -08:00
2015-11-12 22:26:50 -08:00
if ( BX_ENABLED ( ENTRY_CONFIG_PROFILER ) )
{
2015-11-13 21:11:19 -08:00
rmtSettings * settings = rmt_Settings ( ) ;
BX_WARN ( NULL ! = settings , " Remotery is not enabled. " ) ;
if ( NULL ! = settings )
2015-11-12 22:26:50 -08:00
{
2015-11-13 21:11:19 -08:00
settings - > malloc = rmtMalloc ;
settings - > realloc = rmtRealloc ;
settings - > free = rmtFree ;
rmtError err = rmt_CreateGlobalInstance ( & s_rmt ) ;
BX_WARN ( RMT_ERROR_NONE ! = err , " Remotery failed to create global instance. " ) ;
2015-11-14 17:09:58 -08:00
if ( RMT_ERROR_NONE = = err )
{
rmt_SetCurrentThreadName ( " Main " ) ;
}
else
2015-11-13 21:11:19 -08:00
{
s_rmt = NULL ;
}
2015-11-12 22:26:50 -08:00
}
}
2014-05-03 15:18:28 -07:00
# if BX_CONFIG_CRT_FILE_READER_WRITER
s_fileReader = new bx : : CrtFileReader ;
s_fileWriter = new bx : : CrtFileWriter ;
# endif // BX_CONFIG_CRT_FILE_READER_WRITER
2015-02-09 20:12:46 -08:00
cmdInit ( ) ;
2013-08-07 21:45:56 -07:00
cmdAdd ( " mouselock " , cmdMouseLock ) ;
cmdAdd ( " graphics " , cmdGraphics ) ;
cmdAdd ( " exit " , cmdExit ) ;
2015-02-09 20:12:46 -08:00
inputInit ( ) ;
2013-08-07 21:45:56 -07:00
inputAddBindings ( " bindings " , s_bindings ) ;
2014-09-18 22:32:33 -07:00
entry : : WindowHandle defaultWindow = { 0 } ;
2015-07-16 20:28:43 -07:00
entry : : setWindowTitle ( defaultWindow , bx : : baseName ( _argv [ 0 ] ) ) ;
2015-10-20 19:00:13 -07:00
setWindowSize ( defaultWindow , ENTRY_DEFAULT_WIDTH , ENTRY_DEFAULT_HEIGHT ) ;
2014-08-10 10:31:24 -07:00
2013-08-07 21:45:56 -07:00
int32_t result = : : _main_ ( _argc , _argv ) ;
2014-05-03 15:18:28 -07:00
2015-02-09 20:12:46 -08:00
inputRemoveBindings ( " bindings " ) ;
inputShutdown ( ) ;
cmdShutdown ( ) ;
2014-05-03 15:18:28 -07:00
# if BX_CONFIG_CRT_FILE_READER_WRITER
delete s_fileReader ;
s_fileReader = NULL ;
delete s_fileWriter ;
s_fileWriter = NULL ;
# endif // BX_CONFIG_CRT_FILE_READER_WRITER
2015-11-12 22:26:50 -08:00
if ( BX_ENABLED ( ENTRY_CONFIG_PROFILER )
& & NULL ! = s_rmt )
{
rmt_DestroyGlobalInstance ( s_rmt ) ;
}
2013-08-07 21:45:56 -07:00
return result ;
}
2014-09-22 19:34:10 -07:00
bool processEvents ( uint32_t & _width , uint32_t & _height , uint32_t & _debug , uint32_t & _reset , MouseState * _mouse )
2013-08-07 21:45:56 -07:00
{
s_debug = _debug ;
2013-08-14 21:08:46 -07:00
s_reset = _reset ;
2013-08-07 21:45:56 -07:00
2014-09-18 22:32:33 -07:00
WindowHandle handle = { UINT16_MAX } ;
2013-08-07 21:45:56 -07:00
bool mouseLock = inputIsMouseLocked ( ) ;
const Event * ev ;
do
{
struct SE { const Event * m_ev ; SE ( ) : m_ev ( poll ( ) ) { } ~ SE ( ) { if ( NULL ! = m_ev ) { release ( m_ev ) ; } } } scopeEvent ;
ev = scopeEvent . m_ev ;
if ( NULL ! = ev )
{
switch ( ev - > m_type )
{
2014-12-15 20:58:54 -08:00
case Event : : Axis :
{
const AxisEvent * axis = static_cast < const AxisEvent * > ( ev ) ;
inputSetGamepadAxis ( axis - > m_gamepad , axis - > m_axis , axis - > m_value ) ;
}
break ;
case Event : : Char :
{
const CharEvent * chev = static_cast < const CharEvent * > ( ev ) ;
inputChar ( chev - > m_len , chev - > m_char ) ;
}
break ;
2013-08-07 21:45:56 -07:00
case Event : : Exit :
return true ;
2014-12-17 21:07:40 -08:00
case Event : : Gamepad :
{
const GamepadEvent * gev = static_cast < const GamepadEvent * > ( ev ) ;
DBG ( " gamepad %d, %d " , gev - > m_gamepad . idx , gev - > m_connected ) ;
}
break ;
2013-08-07 21:45:56 -07:00
case Event : : Mouse :
{
const MouseEvent * mouse = static_cast < const MouseEvent * > ( ev ) ;
2014-09-18 22:32:33 -07:00
handle = mouse - > m_handle ;
2013-08-07 21:45:56 -07:00
if ( mouse - > m_move )
{
2014-08-05 21:13:50 -07:00
inputSetMousePos ( mouse - > m_mx , mouse - > m_my , mouse - > m_mz ) ;
2013-08-07 21:45:56 -07:00
}
else
{
inputSetMouseButtonState ( mouse - > m_button , mouse - > m_down ) ;
}
if ( NULL ! = _mouse
& & ! mouseLock )
{
if ( mouse - > m_move )
{
_mouse - > m_mx = mouse - > m_mx ;
_mouse - > m_my = mouse - > m_my ;
2014-08-05 21:13:50 -07:00
_mouse - > m_mz = mouse - > m_mz ;
2013-08-07 21:45:56 -07:00
}
else
{
_mouse - > m_buttons [ mouse - > m_button ] = mouse - > m_down ;
}
}
}
break ;
case Event : : Key :
{
const KeyEvent * key = static_cast < const KeyEvent * > ( ev ) ;
2014-09-18 22:32:33 -07:00
handle = key - > m_handle ;
2013-08-07 21:45:56 -07:00
inputSetKeyState ( key - > m_key , key - > m_modifiers , key - > m_down ) ;
}
break ;
case Event : : Size :
{
const SizeEvent * size = static_cast < const SizeEvent * > ( ev ) ;
2014-09-18 22:32:33 -07:00
handle = size - > m_handle ;
_width = size - > m_width ;
2013-08-07 21:45:56 -07:00
_height = size - > m_height ;
2014-09-18 22:32:33 -07:00
_reset = ! s_reset ; // force reset
2013-08-07 21:45:56 -07:00
}
break ;
2014-09-18 22:32:33 -07:00
case Event : : Window :
break ;
2015-10-20 19:00:13 -07:00
case Event : : Suspend :
break ;
2015-08-24 19:12:01 -07:00
2015-10-20 19:00:13 -07:00
default :
2013-08-07 21:45:56 -07:00
break ;
}
}
2013-10-23 22:48:16 -07:00
inputProcess ( ) ;
} while ( NULL ! = ev ) ;
2013-08-14 21:08:46 -07:00
2014-09-18 22:32:33 -07:00
if ( handle . idx = = 0
& & _reset ! = s_reset )
2013-08-07 21:45:56 -07:00
{
2015-02-11 19:42:20 -08:00
_reset = s_reset ;
bgfx : : reset ( _width , _height , _reset ) ;
2013-08-07 21:45:56 -07:00
inputSetMouseResolution ( _width , _height ) ;
}
_debug = s_debug ;
return s_exit ;
}
2014-09-22 19:34:10 -07:00
WindowState s_window [ ENTRY_CONFIG_MAX_WINDOWS ] ;
bool processWindowEvents ( WindowState & _state , uint32_t & _debug , uint32_t & _reset )
{
s_debug = _debug ;
s_reset = _reset ;
WindowHandle handle = { UINT16_MAX } ;
bool mouseLock = inputIsMouseLocked ( ) ;
const Event * ev ;
do
{
struct SE
{
SE ( WindowHandle _handle )
: m_ev ( poll ( _handle ) )
{
}
2015-01-07 22:36:36 -08:00
2014-09-22 19:34:10 -07:00
~ SE ( )
{
if ( NULL ! = m_ev )
{
release ( m_ev ) ;
}
}
const Event * m_ev ;
} scopeEvent ( handle ) ;
ev = scopeEvent . m_ev ;
if ( NULL ! = ev )
{
handle = ev - > m_handle ;
WindowState & win = s_window [ handle . idx ] ;
switch ( ev - > m_type )
{
2014-12-15 20:58:54 -08:00
case Event : : Axis :
{
const AxisEvent * axis = static_cast < const AxisEvent * > ( ev ) ;
inputSetGamepadAxis ( axis - > m_gamepad , axis - > m_axis , axis - > m_value ) ;
}
break ;
case Event : : Char :
{
const CharEvent * chev = static_cast < const CharEvent * > ( ev ) ;
win . m_handle = chev - > m_handle ;
inputChar ( chev - > m_len , chev - > m_char ) ;
}
break ;
2014-09-22 19:34:10 -07:00
case Event : : Exit :
return true ;
2014-12-17 21:07:40 -08:00
case Event : : Gamepad :
{
const GamepadEvent * gev = static_cast < const GamepadEvent * > ( ev ) ;
DBG ( " gamepad %d, %d " , gev - > m_gamepad . idx , gev - > m_connected ) ;
}
break ;
2014-09-22 19:34:10 -07:00
case Event : : Mouse :
{
const MouseEvent * mouse = static_cast < const MouseEvent * > ( ev ) ;
win . m_handle = mouse - > m_handle ;
if ( mouse - > m_move )
{
inputSetMousePos ( mouse - > m_mx , mouse - > m_my , mouse - > m_mz ) ;
}
else
{
inputSetMouseButtonState ( mouse - > m_button , mouse - > m_down ) ;
}
if ( ! mouseLock )
{
if ( mouse - > m_move )
{
win . m_mouse . m_mx = mouse - > m_mx ;
win . m_mouse . m_my = mouse - > m_my ;
win . m_mouse . m_mz = mouse - > m_mz ;
}
else
{
win . m_mouse . m_buttons [ mouse - > m_button ] = mouse - > m_down ;
}
}
}
break ;
case Event : : Key :
{
const KeyEvent * key = static_cast < const KeyEvent * > ( ev ) ;
win . m_handle = key - > m_handle ;
inputSetKeyState ( key - > m_key , key - > m_modifiers , key - > m_down ) ;
}
break ;
case Event : : Size :
{
const SizeEvent * size = static_cast < const SizeEvent * > ( ev ) ;
win . m_handle = size - > m_handle ;
win . m_width = size - > m_width ;
win . m_height = size - > m_height ;
_reset = win . m_handle . idx = = 0
? ! s_reset
: _reset
; // force reset
}
break ;
case Event : : Window :
{
const WindowEvent * window = static_cast < const WindowEvent * > ( ev ) ;
win . m_handle = window - > m_handle ;
win . m_nwh = window - > m_nwh ;
ev = NULL ;
}
break ;
2015-10-20 19:00:13 -07:00
case Event : : Suspend :
break ;
2014-09-22 19:34:10 -07:00
default :
break ;
}
}
inputProcess ( ) ;
} while ( NULL ! = ev ) ;
if ( isValid ( handle ) )
{
const WindowState & win = s_window [ handle . idx ] ;
_state = win ;
if ( handle . idx = = 0 )
{
inputSetMouseResolution ( win . m_width , win . m_height ) ;
}
}
if ( _reset ! = s_reset )
{
_reset = s_reset ;
bgfx : : reset ( s_window [ 0 ] . m_width , s_window [ 0 ] . m_height , _reset ) ;
inputSetMouseResolution ( s_window [ 0 ] . m_width , s_window [ 0 ] . m_height ) ;
}
_debug = s_debug ;
return s_exit ;
}
2014-05-03 15:18:28 -07:00
bx : : FileReaderI * getFileReader ( )
{
return s_fileReader ;
}
bx : : FileWriterI * getFileWriter ( )
{
return s_fileWriter ;
}
2015-11-06 22:03:06 -08:00
bx : : AllocatorI * getAllocator ( )
2015-01-07 22:36:36 -08:00
{
2015-02-13 09:43:46 -08:00
return s_allocator ;
2015-01-07 22:36:36 -08:00
}
2015-02-08 10:25:53 -08:00
void * TinyStlAllocator : : static_allocate ( size_t _bytes )
{
return BX_ALLOC ( getAllocator ( ) , _bytes ) ;
}
void TinyStlAllocator : : static_deallocate ( void * _ptr , size_t /*_bytes*/ )
{
if ( NULL ! = _ptr )
{
BX_FREE ( getAllocator ( ) , _ptr ) ;
}
}
2013-08-07 21:45:56 -07:00
} // namespace entry
2014-05-31 00:18:45 -07:00
extern " C " bool entry_process_events ( uint32_t * _width , uint32_t * _height , uint32_t * _debug , uint32_t * _reset )
{
return entry : : processEvents ( * _width , * _height , * _debug , * _reset , NULL ) ;
}