spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef INPUT_HPP_INCLUDED
#define INPUT_HPP_INCLUDED

#include <map>
#include <string>
#include <queue>

#include <SDL/SDL.h>

// ein paar andere Sachen - die auftretenden Bezeichner sollten aber hoffentlich selbsterklärend sein :) 
#include <core/geometry.hpp>
#include <core/unicode.hpp>
#include <core/filesystem.hpp>
#include <core/exception.hpp>

namespace core {

    /// ID-Typ für Tasten
    typedef unsigned short KeyID;
    /// ID-Typ für Maustasten
    typedef unsigned short ButtonID;

    /// Zustand einer Taste
    enum KeyState {
        RELEASED = 0,
        PRESSED  = 1,
        HELD     = 2
    };

    namespace keyboard {
        extern KeyID FIRST;
        extern KeyID BACKSPACE;
        extern KeyID TAB;
        extern KeyID CLEAR;
        extern KeyID RETURN;
        extern KeyID PAUSE;
/*
  ... ich kürze das an der Stelle mal ab
*/
        extern KeyID POWER;
        extern KeyID EURO;
        extern KeyID UNDO;
        extern KeyID LAST;
    }

    namespace mouse {
        extern ButtonID FIRST;
        extern ButtonID LEFT;
        extern ButtonID MIDDLE;
        extern ButtonID RIGHT;
        extern ButtonID WHEELUP;
        extern ButtonID WHEELDOWN;
        extern ButtonID LAST;
    }

    /// Zusammenfassung von Maus, Tastatur und Gamepad
    class Input {
        private:
            /// Zuletzt gedrückte Tasten
            static std::queue<KeyID> lastKeys;
            /// Zuletzt gedrückte Maustasten
            static std::queue<ButtonID> lastButtons;
            /// Beschreibt, ob Eingabebehandlung initialisiert wurde
            static bool ready;
            /// Beschreibt, ob die Maus eingefangen wurde
            static bool grab;
            /// Beschreibt, ob die Maus zentriert ist
            static bool drag;
            /// Sensibilität der Maus
            static float sensitivity;
        public:
            /// Initialisiert Eingabebehandlung
            static void init();
            /// Beendet Eingabebehandlung
            static void quit();
            /// Aktualisiert die Eingabebehandlung
            static void update();
            /// Erfasst gedrückte Tasten
            static std::map<KeyID, KeyState> keyboard;
            /// Erfasst gedrückte Maustasten
            static std::map<ButtonID, KeyState> button;
            /// Position des Mauszeigers
            static Vector pos;
            /// Relative Änderung des Mauszeigers
            static Vector diff;
            /// Eingegebenes Zeichen als Unicode-String
            static std::string text;
            /*
            /// Liefert, wie lange eine Taste gehalten wird
            static unsigned short getKeyboardHeld(KeyID const & id);
            /// Liefert, wie lange eine Maustste gehalten wird
            static unsigned short getButtonHeld(ButtonID const & id);
            */
            /// Beschreibt, ob SDL_QUIT ausgelöst wurde
            static bool window_close;
    };

}

#endif // INPUT_HPP_INCLUDED

C-/C++-Quelltext

#include <core/input.hpp>

#include <stdexcept>

namespace core {

    namespace keyboard {
        KeyID FIRST         = SDLK_FIRST;
        KeyID BACKSPACE     = SDLK_BACKSPACE;
        KeyID TAB           = SDLK_TAB;
        KeyID CLEAR         = SDLK_CLEAR;
/*
   ... auch hier kürze ich mal ab
*/
        KeyID EURO          = SDLK_EURO;
        KeyID UNDO          = SDLK_UNDO;
        KeyID LAST          = SDLK_LAST;
    }

    namespace mouse {
        ButtonID FIRST     = SDL_BUTTON_LEFT;
        ButtonID LEFT      = SDL_BUTTON_LEFT;
        ButtonID MIDDLE    = SDL_BUTTON_MIDDLE;
        ButtonID RIGHT     = SDL_BUTTON_RIGHT;
        ButtonID WHEELUP   = SDL_BUTTON_WHEELUP;
        ButtonID WHEELDOWN = SDL_BUTTON_WHEELDOWN;
        ButtonID LAST      = SDL_BUTTON_WHEELDOWN;
    }

    bool Input::ready = false;
    std::queue<KeyID> Input::lastKeys;
    std::queue<ButtonID> Input::lastButtons;
    std::map<KeyID, KeyState> Input::keyboard;
    std::map<ButtonID, KeyState> Input::button;
    Vector Input::pos;
    Vector Input::diff;
    std::string Input::text;
    bool Input::grab = false;
    bool Input::drag = false;
    float Input::sensitivity = 1.0;
    bool Input::window_close = false;

    void Input::init() {
        if (Input::ready == true) {
            std::clog << "Input system is already initialized" << std::endl;
            return;
        }
        SDL_EnableUNICODE(true);
        Input::ready = true;
    }

    void Input::quit() {
        if (Input::ready == false) {
            std::clog << "Input system was not initialized" << std::endl;
            return;
        }
        SDL_EnableUNICODE(false);
        Input::ready = false;
    }

    void Input::update() {
        Vector tmp;
        Input::window_close = false;
        Input::text.clear();

        // Tastendruck in -halten umwandeln
        while (!Input::lastKeys.empty()) {
            KeyID buffer = Input::lastKeys.front();
            Input::lastKeys.pop();
            Input::keyboard[buffer] = HELD;
        }
        // Maustastendruck in -halten umwandeln
        while (!Input::lastButtons.empty()) {
            ButtonID buffer = Input::lastButtons.front();
            Input::lastButtons.pop();
            Input::button[buffer] = HELD;
        }

        if (Input::ready == false) {
            throw RuntimeError("Input must be initialized before handling input");
        }
        if (Input::grab) {
            if (SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE) {
                SDL_ShowCursor(SDL_DISABLE);
                SDL_WM_GrabInput(SDL_GRAB_ON);
            }
        } else {
            if (SDL_ShowCursor(SDL_QUERY) == SDL_DISABLE) {
                SDL_ShowCursor(SDL_ENABLE);
                SDL_WM_GrabInput(SDL_GRAB_OFF);
            }
        }

        SDL_Event event;
        short keycode;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_KEYDOWN:
                    Input::keyboard[event.key.keysym.sym] = PRESSED;
                    Input::lastKeys.push(event.key.keysym.sym);
                    keycode = event.key.keysym.unicode;
                    // Read and Convert Printable Input
                    if ((keycode > 0x800) | (keycode > 0x80) | (keycode > 32 && keycode != 127)) {
                        Input::text.push_back(keycode);
                    }
                    break;
                case SDL_KEYUP:
                    Input::keyboard[event.key.keysym.sym] = RELEASED;
                    break;
                case SDL_MOUSEBUTTONDOWN:
                    Input::button[event.button.button] = PRESSED;
                    Input::lastButtons.push(event.button.button);
                    break;
                case SDL_MOUSEBUTTONUP:
                    Input::button[event.button.button] = RELEASED;
                    break;
                case SDL_MOUSEMOTION:
                    tmp         = Vector(event.motion.x, event.motion.y);
                    Input::diff = Input::pos - tmp;
                    Input::pos  = tmp;
                    break;
                case SDL_QUIT:
                    Input::window_close = true;
                    break;
            }
        }

        if (Input::drag) {
            SDL_WarpMouse(Input::pos.x, Input::pos.y);
        }
    }

}

C-/C++-Quelltext

    bool Widget::mouseOver() {
        return this->collideRect(Input::pos);
    }

    bool Widget::leftClick() {
        if (this->mouseOver()) {
            return Input::button[mouse::LEFT] == PRESSED;
        }
        return false;
    }

    bool Widget::leftHeld() {
        if (this->mouseOver()) {
            return Input::button[mouse::LEFT] == HELD;
        }
        return false;
    }

    bool Widget::wheelUp() {
        if (this->mouseOver()) {
            return Input::button[mouse::WHEELUP] != RELEASED;
        }
        return false;
    }

    bool Widget::wheelDown() {
        if (this->mouseOver()) {
            return Input::button[mouse::WHEELDOWN] != RELEASED;
        }
        return false;
    }

C-/C++-Quelltext

    void Button::logic() {
        Widget::logic();

        if (this->state == DISABLED) {
            return;
        }
        this->clicked = false;

        bool mouseOver = this->mouseOver();
        bool leftClick = this->leftClick();
        bool leftHeld  = this->leftHeld();
        if (leftClick || leftHeld) {
            // Handle Press
            if (mouseOver && this->state != DOWN) {
                this->state = DOWN;
            }
            // Handle Release
            if (!mouseOver && this->state == DOWN) {
                this->state = DEFAULT;
            }
        }
        if (!leftHeld && !leftClick) {
            // Handle Focus
            if (mouseOver && this->state == DEFAULT) {
                this->state = HOVER;
            }
            // Handle Unfocus
            if (!mouseOver && this->state == HOVER) {
                this->state = DEFAULT;
            }
            // Handle Release
            if (this->state == DOWN) {
                this->state = DEFAULT;
            }
        }
        leftClick = Input::button[mouse::LEFT] == PRESSED;
        bool leftFree = Input::button[mouse::LEFT] == RELEASED;
        if (leftClick && mouseOver) {
            this->held = true;
            // Eat Click
            Input::button[mouse::LEFT] = HELD;
        } else if (leftFree && this->held) {
            this->held = false;
            this->clicked = mouseOver;
        }
    }