Basic movement is choppy and slow with switch and stuff like that. Anyone know how to get the smooth movement like walking around in fps games? Searched DIC and google but running out of ideas for good keywords.

Make a table of key states (ie. which keys are up and which keys are down). Have your keyboard listener update the table when keys are pressed. You should check the table periodically to perform game logic (ex. "move left if A is pressed").

Edit: Here is my implementation of it (GLUT).

This post has been edited by Tom9729: 21 Jun, 2009 - 06:24 PM

what language are you programming in?

C++, bj. nice name

The idea is to create a table in memory that handles key presses rather than sending asynchronous presses one at a time to the api, right? Does the program scan the whole function the table is in every frame to see which key isn't in state of 1 or something similar? What is this concept called?

You should be able to make some constants or an enumeration from the key codes.

ex.

const int KEY_UPPER_A = 21;
const int KEY_UPPER_B = 22;
....

Then you could have a function like this that is called every time you render/draw.

void keyboardHandler(int *keyState)
{
    // If upper case 'a' is down...
    if (keyState[KEY_UPPER_A])
    {
        // Do stuff.
    }

    // If upper case 'b' is down...
    if (keyState[KEY_UPPER_B])
    {
        // Do other stuff.
    }
}

Edit: It would be helpful to know whether or not you are using GLUT. I'm not sure how other APIs (SDL, GLX, WGL, etc) handle keyboard input.

This post has been edited by Tom9729: 22 Jun, 2009 - 05:49 AM

Yes can you give us more info on how you are implementing OpenGL?

Take a look at the Q3 Source and see how they're handling it, they do it pretty quick indeed

Yeah it's just plain glut.h and nothing else. No winAPI or anything. Runs from console and portable.

If you create an enumeration or constants like above, and make A = 21, then how does the keyboard listener know that A is being pressed? Because A is 65 in ascii.

For that function,
Would the keyboard listener in main look like

I think I'm starting to get it.

This post has been edited by Kanvus: 22 Jun, 2009 - 01:13 PM

Sort of, you wouldn't want to call your keyboard handler with glutKeyboardFunc(..) though.

Here is a more complete example.

int keyState[119]; // 119 keys, 0 = up, 1 = down
...
const int KEY_UPPER_A = 21;
const int KEY_UPPER_B = 22;
...
void keyDown(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 65:
            keyState[KEY_UPPER_A] = 1;
            break;
        case 66:
            keyState[KEY_UPPER_B] = 1;
            break;
...
}

void keyUp(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 65:
            keyState[KEY_UPPER_A] = 0;
            break;
        case 66:
            keyState[KEY_UPPER_B] = 0;
            break;
...
}

void keyInit()
{
    glutKeyboardFunc(keyDown);
    glutKeyboardUpFunc(keyUp);
}

// Call me from within your game/render/logic loop.
void keyHandler()
{
    if (keyState[KEY_UPPER_A])
    {
        // Do something.
    }

    if (keyState(KEY_UPPER_B)
    {
        // Do something else.
    }
}

They keyUp/keyDown functions are callbacks, you register them with GLUT (ie. the code in keyInit(..)) and it calls them for your whenever a key is pressed or released.

You want to keep the code that updates the table (ie. which keys are currently pressed down) separate from the code that performs actions based upon which keys are pressed down.

On a side note, GLUT considers keys like the arrow keys to be "special" and you need to use the glutSpecialFunc(..)/glutSpecialUpFunc(..) functions to listen for them.

OOOOH

wow cool. i feel smart (lol)

thanks so much tom

EDIT: the result is so beautiful and smooth i wanna cry T-T

This post has been edited by Kanvus: 22 Jun, 2009 - 08:32 PM