Changeset 93 for trunk


Ignore:
Timestamp:
06/03/13 00:44:38 (12 years ago)
Author:
epyon
Message:
  • io_event - event and key list expanded
  • window - is_event_pending, poll_event, swap_buffers added to interface
  • gl_window - implementations of the above, SDL_Event translation
  • render_test - no longer directly using any foreign libs
Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/detail/io_event_list.inc

    r67 r93  
    22NV_IO_EVENT( EV_MOUSE_BUTTON )
    33NV_IO_EVENT( EV_MOUSE_MOVE )
     4NV_IO_EVENT( EV_ACTIVE )
     5NV_IO_EVENT( EV_RESIZE )
    46NV_IO_EVENT( EV_SYSTEM )
     7NV_IO_EVENT( EV_QUIT )

  • trunk/nv/detail/key_list.inc

    r67 r93  
    1212NV_KEY( KEY_RIGHT   , 20 )
    1313NV_KEY( KEY_DOWN    , 21 )
     14NV_KEY( KEY_DELETE  , 22 )
     15NV_KEY( KEY_INSERT  , 23 )
     16NV_KEY( KEY_CENTER  , 24 )
    1417
    1518NV_KEY( KEY_ESCAPE  , 27 )
    1619
     20NV_KEY( KEY_SPACE   , 32 )
    1721
    18 NV_KEY( KEY_SPACE   , 32 )
     22NV_KEY( KEY_QUOTE   , 39 )
     23
     24NV_KEY( KEY_COMMA   , 44 )
     25NV_KEY( KEY_MINUS   , 45 )
     26NV_KEY( KEY_PERIOD  , 46 )
     27NV_KEY( KEY_SLASH   , 47 )
     28
     29NV_KEY( KEY_SCOLON  , 59 )
     30NV_KEY( KEY_EQUALS  , 61 )
     31
     32NV_KEY( KEY_LBRACKET, 91 )
     33NV_KEY( KEY_BSLASH  , 92 )
     34NV_KEY( KEY_RBRACKET, 93 )
     35
     36NV_KEY( KEY_BQUOTE  , 96 )
    1937
    2038NV_KEY( KEY_0       , 48 )
    … …  
    5573NV_KEY( KEY_Y       , 89 )
    5674NV_KEY( KEY_Z       , 90 )
     75
     76NV_KEY( KEY_F1  , 131 )
     77NV_KEY( KEY_F2  , 132 )
     78NV_KEY( KEY_F3  , 133 )
     79NV_KEY( KEY_F4  , 134 )
     80NV_KEY( KEY_F5  , 135 )
     81NV_KEY( KEY_F6  , 136 )
     82NV_KEY( KEY_F7  , 137 )
     83NV_KEY( KEY_F8  , 138 )
     84NV_KEY( KEY_F9  , 139 )
     85NV_KEY( KEY_F10 , 140 )
     86NV_KEY( KEY_F11 , 141 )
     87NV_KEY( KEY_F12 , 142 )

  • trunk/nv/gl/gl_window.hh

    r44 r93  
    2727                string get_title() const;
    2828                void set_title( const string& title );
     29                virtual bool is_event_pending();
     30                virtual bool poll_event( io_event& event );
    2931                virtual context* get_context() { return m_context; }
    30                 ~gl_window();
     32                virtual void swap_buffers();
     33                virtual ~gl_window();
    3134        private:
    3235                uint16      m_width;

  • trunk/nv/interface/window.hh

    r44 r93  
    1515#include <nv/common.hh>
    1616#include <nv/string.hh>
     17#include <nv/io_event.hh>
    1718
    1819namespace nv
    … …  
    2728                virtual void set_title( const string& title ) = 0;
    2829                virtual context* get_context() = 0;
     30                virtual bool is_event_pending() = 0;
     31                virtual bool poll_event( io_event& event ) = 0;
     32                virtual void swap_buffers() = 0;
     33                virtual ~window() = 0 {};
    2934        };
    3035

  • trunk/nv/io_event.hh

    r78 r93  
    8989        };
    9090
     91        struct resize_event
     92        {
     93                sint32 x;
     94                sint32 y;
     95        };
     96
     97        struct active_event
     98        {
     99                bool gain;
     100        };
     101
    91102        struct system_event
    92103        {
    … …  
    104115                        mouse_button_event mbutton;
    105116                        mouse_move_event   mmove;
     117                        resize_event       resize;
     118                        active_event       active;
    106119                        system_event       system;
    107120                };

  • trunk/src/gl/gl_window.cc

    r44 r93  
    1010
    1111using namespace nv;
     12
     13static bool sdl_key_event_to_io_event( const SDL_KeyboardEvent& ke, io_event& kevent )
     14{
     15        kevent.type        = EV_KEY;
     16        kevent.key.pressed = ( ke.state != SDL_RELEASED );
     17        kevent.key.ascii   = 0;
     18        kevent.key.code    = KEY_NONE;
     19
     20        // if result is a typable char place it into the structure
     21        if (ke.keysym.unicode >= 32 && ke.keysym.unicode < 128 )
     22        {
     23                kevent.key.ascii = (char)ke.keysym.unicode;
     24        }
     25
     26        // Get the Key value from the SDL Keyboard event
     27        int result = ke.keysym.sym;
     28
     29        // Check the control and shift states
     30        kevent.key.alt     = (ke.keysym.mod & KMOD_ALT ) != 0;
     31        kevent.key.control = (ke.keysym.mod & KMOD_CTRL ) != 0;
     32        kevent.key.shift   = (ke.keysym.mod & KMOD_SHIFT ) != 0;
     33
     34        // if result is a typable char from the directly transformable ranges
     35        if ( ( result >= KEY_A && result <= KEY_Z ) ||
     36                ( result >= KEY_0 && result <= KEY_9 ) ||
     37                result == ' ' )
     38        {
     39                kevent.key.code = static_cast<key_code>(result);
     40        }
     41
     42        // if result is a typable char from the a..z range
     43        if ( result >= KEY_A + 32 && result <= KEY_Z + 32 )
     44        {
     45                kevent.key.code = static_cast<key_code>(result - 32);
     46        }
     47
     48        if ( result >= SDLK_F1 && result <= SDLK_F12 )
     49        {
     50                kevent.key.code = static_cast<key_code>(result - SDLK_F1 + KEY_F1 );
     51        }
     52
     53        // other recognized codes
     54        switch ( result )
     55        {
     56        case SDLK_BACKSPACE    : kevent.key.code = KEY_BACK; break;
     57        case SDLK_TAB          : kevent.key.code = KEY_TAB; break;
     58        case SDLK_RETURN       : kevent.key.code = KEY_ENTER; break;
     59        case SDLK_PAGEUP       : kevent.key.code = KEY_PGUP; break;
     60        case SDLK_PAGEDOWN     : kevent.key.code = KEY_PGDOWN; break;
     61        case SDLK_END          : kevent.key.code = KEY_END; break;
     62        case SDLK_HOME         : kevent.key.code = KEY_HOME; break;
     63        case SDLK_LEFT         : kevent.key.code = KEY_LEFT; break;
     64        case SDLK_UP           : kevent.key.code = KEY_UP; break;
     65        case SDLK_RIGHT        : kevent.key.code = KEY_RIGHT; break;
     66        case SDLK_DOWN         : kevent.key.code = KEY_DOWN; break;
     67        case SDLK_DELETE       : kevent.key.code = KEY_DELETE; break;
     68        case SDLK_INSERT       : kevent.key.code = KEY_INSERT; break;
     69        case SDLK_KP5          : kevent.key.code = KEY_CENTER; break;
     70        case SDLK_ESCAPE       : kevent.key.code = KEY_ESCAPE; break;
     71        case SDLK_QUOTE        : kevent.key.code = KEY_QUOTE; break;
     72        case SDLK_COMMA        : kevent.key.code = KEY_COMMA; break;
     73        case SDLK_MINUS        : kevent.key.code = KEY_MINUS; break;
     74        case SDLK_PERIOD       : kevent.key.code = KEY_PERIOD; break;
     75        case SDLK_SLASH        : kevent.key.code = KEY_SLASH; break;
     76        case SDLK_SEMICOLON    : kevent.key.code = KEY_SCOLON; break;
     77        case SDLK_LEFTBRACKET  : kevent.key.code = KEY_LBRACKET; break;
     78        case SDLK_BACKSLASH    : kevent.key.code = KEY_BSLASH; break;
     79        case SDLK_RIGHTBRACKET : kevent.key.code = KEY_RBRACKET; break;
     80        case SDLK_BACKQUOTE    : kevent.key.code = KEY_BQUOTE; break;
     81        default : break;
     82        }
     83
     84        // If key was understood by nv, then it's valid, otherwise ignored
     85        return kevent.key.ascii != 0 || kevent.key.code != 0;
     86}
     87
     88static bool sdl_mouse_button_to_io_event( const SDL_MouseButtonEvent& mb, io_event& mevent )
     89{
     90        mevent.type            = EV_MOUSE_BUTTON;
     91        mevent.mbutton.button  = MOUSE_NONE;
     92        mevent.mbutton.pressed = (mb.state != SDL_RELEASED);
     93        mevent.mbutton.x       = mb.x;
     94        mevent.mbutton.y       = mb.y;
     95
     96        switch ( mb.button )
     97        {
     98        case SDL_BUTTON_LEFT      : mevent.mbutton.button = MOUSE_LEFT; break;
     99        case SDL_BUTTON_MIDDLE    : mevent.mbutton.button = MOUSE_MIDDLE; break;
     100        case SDL_BUTTON_RIGHT     : mevent.mbutton.button = MOUSE_RIGHT; break;
     101        case SDL_BUTTON_WHEELUP   : mevent.mbutton.button = MOUSE_WHEEL_UP; break;
     102        case SDL_BUTTON_WHEELDOWN : mevent.mbutton.button = MOUSE_WHEEL_DOWN; break;
     103        default : break;
     104        }
     105
     106        return mevent.mbutton.button != MOUSE_NONE;
     107}
     108
     109static bool sdl_mouse_motion_to_io_event( const SDL_MouseMotionEvent& mm, io_event& mevent )
     110{
     111        mevent.type          = EV_MOUSE_MOVE;
     112        mevent.mmove.pressed = (mm.state != SDL_RELEASED);
     113        mevent.mmove.x       = mm.x;
     114        mevent.mmove.y       = mm.y;
     115        return true;
     116}
     117
     118static bool sdl_event_to_io_event( const SDL_Event& e, io_event& ioevent )
     119{
     120        switch ( e.type )
     121        {
     122        case SDL_KEYDOWN         : return sdl_key_event_to_io_event( e.key, ioevent );
     123        case SDL_KEYUP           : return sdl_key_event_to_io_event( e.key, ioevent );
     124        case SDL_MOUSEMOTION     : return sdl_mouse_motion_to_io_event( e.motion, ioevent );
     125        case SDL_MOUSEBUTTONDOWN : return sdl_mouse_button_to_io_event( e.button, ioevent );
     126        case SDL_MOUSEBUTTONUP   : return sdl_mouse_button_to_io_event( e.button, ioevent );
     127        case SDL_ACTIVEEVENT     :
     128                ioevent.type = EV_ACTIVE;
     129                ioevent.active.gain = (e.active.gain != 0);
     130                return e.active.state == SDL_APPINPUTFOCUS;
     131        case SDL_VIDEORESIZE     :
     132                ioevent.type     = EV_RESIZE;
     133                ioevent.resize.x = e.resize.w;
     134                ioevent.resize.y = e.resize.h;
     135                return true;
     136        case SDL_SYSWMEVENT      : ioevent.type = EV_SYSTEM; return true;
     137        case SDL_QUIT            : ioevent.type = EV_QUIT;   return true;
     138        case SDL_NOEVENT         : return false;
     139        case SDL_VIDEOEXPOSE     : return false;
     140        case SDL_JOYAXISMOTION   : return false;
     141        case SDL_JOYBALLMOTION   : return false;
     142        case SDL_JOYHATMOTION    : return false;
     143        case SDL_JOYBUTTONDOWN   : return false;
     144        case SDL_JOYBUTTONUP     : return false;
     145        default : return false;
     146        }
     147}
     148
    12149
    13150gl_window::gl_window( uint16 width, uint16 height )
    … …  
    55192}
    56193
     194bool gl_window::is_event_pending()
     195{
     196        return SDL_PollEvent( nullptr ) != 0;
     197}
     198
     199bool gl_window::poll_event( io_event& event )
     200{
     201        SDL_Event sdl_event;
     202        if ( SDL_PollEvent( &sdl_event ) == 0 ) return false;
     203        return sdl_event_to_io_event( sdl_event, event );
     204}
     205
     206void gl_window::swap_buffers()
     207{
     208        SDL_GL_SwapBuffers();
     209}
     210
    57211gl_window::~gl_window()
    58212{

  • trunk/tests/render_test/rl.cc

    r90 r93  
    1 #include <nv/lib/sdl12.hh>
    21#include <nv/interface/vertex_buffer.hh>
    32#include <nv/gl/gl_device.hh>
    … …  
    205204                m_char_program->set_uniform( "tex", 0 );
    206205                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_char_program, m_char_va, 6 );
    207 
    208                 SDL_GL_SwapBuffers();
    209                 SDL_Event event;
    210                 while(SDL_PollEvent(&event))
     206                m_window->swap_buffers();
     207
     208                nv::io_event event;
     209                while(m_window->poll_event(event))
    211210                {     
    212211                        switch (event.type)
    213212                        {
    214                         case SDL_QUIT:
     213                        case nv::EV_QUIT:
    215214                                keypress = 1;
    216215                                break;
    217                         case SDL_KEYDOWN:
    218                                 switch (event.key.keysym.sym)
     216                        case nv::EV_KEY:
     217                                if (event.key.pressed)
    219218                                {
    220                                 case SDLK_ESCAPE: keypress = 1; break;
    221                                 case SDLK_LEFT: move.x = move.x - 1.0f; break;
    222                                 case SDLK_RIGHT: move.x = move.x + 1.0f; break;
    223                                 case SDLK_UP: move.z = move.z - 1.0f; break;
    224                                 case SDLK_DOWN: move.z = move.z + 1.0f; break;
     219                                        switch (event.key.code)
     220                                        {
     221                                        case nv::KEY_ESCAPE : keypress = 1; break;
     222                                        case nv::KEY_LEFT   : move.x = move.x - 1.0f; break;
     223                                        case nv::KEY_RIGHT  : move.x = move.x + 1.0f; break;
     224                                        case nv::KEY_UP     : move.z = move.z - 1.0f; break;
     225                                        case nv::KEY_DOWN   : move.z = move.z + 1.0f; break;
     226                                        }
    225227                                }
    226228                                break;
Note: See TracChangeset for help on using the changeset viewer.