A way to make the keyboard event queue responsive and not use up all the CPU power

I don't really know much about SDL or game programming, but here are some random ideas:

Reaction to state changes

Your code:

while (1)
{
    while (SDL_PollEvent(&keyevent))
    {
        switch(keyevent.type)
        {
            // code to set keyboard state
        }
    }

    // code to calculate movement according to keyboard state
    // then act on that movement
}

      

        
        
        
      

    

This means that no matter what happens on the keyboard, you are calculating and setting the data.

If installing data is expensive (hint: synced data) then it will cost you even more.

SDL_WaitEvent: state measurement

You need to wait for the event to happen, instead of writing that 100% uses one processor.

Here's a variation of the event loop I wrote for a test at home:

while(true)
{
    // message processing loop
    ::SDL_Event event ;

    ::SDL_WaitEvent(&event) ; // THIS IS WHAT IS MISSING IN YOUR CODE

    do
    {
        switch (event.type)
        {
            // etc.
        }
    }
    while(::SDL_PollEvent(&event)) ;

    // re-draw the internal buffer
    if(this->m_isRedrawingRequired || this->m_isRedrawingForcedRequired)
    {
        // redrawing code
    }

    this->m_isRedrawingRequired = false ;
    this->m_isRedrawingForcedRequired = false ;
}

      

        
        
        
      

    

Note. It was single threaded. I'll talk about streams later.

Note 2: the dot around the two "m_isRedrawing ..." boolean is a forced redrawing when one of these booleans is true and when the timer asks a question. Usually no redrawing.

The difference between my code and yours is that by no means are you letting the thread "wait".

Keyboard events

There is a problem, I think, with your keyboard event handling.

Your code:

        case SDL_KEYDOWN:
            switch(keyevent.key.keysym.sym)
            {
            case SDLK_LEFT:
                x1 = 1;
                x2 = 0;
                break;
            case SDLK_RIGHT:
                x1 = 0;
                x2 = 1;
                break;
            // etc.
            }
        case SDL_KEYUP:
            switch(keyevent.key.keysym.sym)
            {
            case SDLK_LEFT:
                x1 = x2 = 0;
                break;
            case SDLK_RIGHT:
                x1 = x2 = 0;
                break;
            // etc.
            }

      

        
        
        
      

    

Suppose you pressed LEFT and then RIGHT, then press LEFT. I would expect:

• press LEFT: the character stays on the left
• press RIGHT: the symbol stops (by pressing the LEFT and RIGHT buttons)
• unpress LEFT: character goes right because RIGHT is still pressed

In your case, you have:

• press LEFT: the character stays on the left
• press RIGHT: character goes to the right (since now LEFT is ignored, with x1 = 0)
• unpress LEFT: the character stops (because you unplugged both x1 and x2.) despite the RIGHT button being pressed

You are doing it wrong because:

• You react immediately to the event, instead of using a timer to react to the situation every nth millisecond
• you mix events together.

I'll find the link later, but you need to make an array of boolean states for the keys pressed. Something like:

// C++ specialized vector<bool> is silly, but...
std::vector<bool> m_aKeyIsPressed ;

      

        
        
        
      

    

You initialize it with the available keys:

m_aKeyIsPressed(SDLK_LAST, false)

      

        
        
        
      

    

Then, on the key up event:

void MyContext::onKeyUp(const SDL_KeyboardEvent & p_oEvent)
{
    this->m_aKeyIsPressed[p_oEvent.keysym.sym] = false ;
}

      

        
        
        
      

    

and by pressing a key:

void MyContext::onKeyDown(const SDL_KeyboardEvent & p_oEvent)
{
    this->m_aKeyIsPressed[p_oEvent.keysym.sym] = true ;
}

      

        
        
        
      

    

This way, when you check at regular intervals (and the important part when checking ), you know the exact momentary state of the keyboard and can react to it.

Topics

The topics are cool, but then you have to know exactly what you are dealing with.

For example, the event loop thread calls the following method:

MainSurvivor->SetMovementDirection

      

        
        
        
      

    

The resolution (render) thread calls the following method:

MainSurvivor->MyTurn(Iterator);

      

        
        
        
      

    

Seriously, are you sharing data between two different threads?

If you are (and I know you are), then you have either:

• If you have not synchronized access, there is a data consistency issue due to processor caching. Simply put, there is no guarantee that one dataset by one stream will be considered "modified" by another in a reasonable amount of time.
• if you have synchronized accesses (with mutex, atomic variable, etc.) then you have performance because you (for example) lock / unlock the mutex at least once in each thread per loop iteration.

Instead, I would like to push the change from one thread to another (e.g. via a message to a synchronized queue).

Streaming is a hard problem anyway, so you should familiarize yourself with the concept before mixing it with SDL and OpenGL. Herb Sutter Blog is a wonderful collection of articles on topics.

What you need to do:

• Try to write the thing in one thread using events, dispatched messages and timers.
• If you find performance issues, move the event or drawing flow to a different location, but continue to work with events, dispatched messages and timers to communicate

PS: What's wrong with your boolean data?

Obviously you are using C ++ (for example void GameWorld::Movement()

), so using 1 or 0 instead of true

or false

won't make your code clearer or faster.