renamed a few more members and changed some switch statements

[physics.git] / src / input / inputManager.cpp

/*
 *  Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "inputManager.h"

#include <bear/debug.h>
using namespace bear;

#include <SDL/SDL.h>

#include "config/keys.h"


/// ***** Private Variables *****

enum State
{
    isR,
    wasP,
    isP,
    wasR
};

static const int keySize = 323;
static State keyState[keySize];

/// ***** Initializers/Cleaners *****

void input::init()
{
    // default all keys to released
    for(int i=0; i< keySize; i++)
    {
        keyState[i] = isR;
    }
}
void input::clean()
{

}

/// ***** Public Methods *****

const Uint32 eventMask = -1; // ALL events

void input::update()
{
    SDL_Event event;

    for(int i=0; i < keySize; i++)
    {
        State newKeyState;

        switch(keyState[i])
        {
          case isR:   newKeyState = isR;    break;
          case wasR:  newKeyState = isR;    break;
          case isP:   newKeyState = isP;    break;
          case wasP:  newKeyState = isP;    break;
          default:    DASSERT(false);       return;
        }

        keyState[i] = newKeyState;
    }

    while(0 < SDL_PeepEvents(&event, 1, SDL_GETEVENT, eventMask))
    {
        switch(event.type)
        {
            case SDL_KEYUP:
                keyState[event.key.keysym.sym] = wasR;
                break;
            case SDL_KEYDOWN:
                keyState[event.key.keysym.sym] = wasP;
                break;
            case SDL_QUIT:
                // HACK: simulate an SDL_QUIT event as an ESC key press
                keyState[key::end] = wasR;
                break;
            default:
                break; // somthing I don't care about
        }
    }
}

Vector2 input::mousePosition()
{
    int x,y;
    SDL_GetMouseState(&x, &y);

    return Vector2(x,y);
}

bool input::mouseLeft()
{
    Uint8 state = SDL_GetMouseState(NULL, NULL);

    return state & SDL_BUTTON(1);
}
bool input::mouseRight()
{
    Uint8 state = SDL_GetMouseState(NULL, NULL);

    return state & SDL_BUTTON(3);
}

bool input::isPressed(const SDLKey& key)
{
    return keyState[key] == isP || keyState[key] == wasP;
}
bool input::isReleased(const SDLKey& key)
{
    return keyState[key] == isR || keyState[key] == wasR;
}

bool input::wasPressed(const SDLKey& key)
{
    return keyState[key] == wasP;
}
bool input::wasReleased(const SDLKey& key)
{
    return keyState[key] == wasR;
}