Input multipiattaforma con OIS - 3a parte

Nella precedente parte abbiamo trattato la crezione dei dispositivi necessari per la lettura degli input, compresa la tastiera, ora vedremo come leggere lo stato di quest'ultima.

Nell'update dell'applicazione dovremo eseguire questo comando:

oisKeyboard->capture();

fatto ciò potremo controllare lo stato di ogni singolo tasto con:

oisKeyboard->isKeyDown(OIS::KC_F1)   // ritorna true se F1 è premuto

ovviamente potremo anche sfruttare un listener per ottenere l'input bufferizzato della tastiera, per fare ciò ci basterà derivare la classe OIS::KeyListener così:

class MyKeyListener : public OIS::KeyListener
    {
    public:
    bool keyPressed(const KeyEvent &arg)
        {
        printf("premuto tasto %i\n", arg.key);
        }
    bool keyReleased(const KeyEvent &arg)
        {
        printf("rilasciato tasto %i\n", arg.key);
        }
    };

dopo potremo impostare il nostro listener con il seguente comando:

oisKeyboard->setEventCallback(new MyKeyListener);

Read more...

Input multipiattaforma con OIS - 2a parte

Nella seconda parte di questo tutorial vedremo come creare i dispositivi necessari alla lettura dei vari input e come appunto ottenere queste informazioni. L'ultimo passaggio della parte precedente è stata la creazione dell'istanza dell'InputManager, ora con quest'ultimo potremo procedere alla crezione dei devices:

OIS::Keyboard *oisKeyboard = static_cast(oisInputManager->createInputObject(OIS::OISKeyboard, false));
OIS::Mouse *oisMouse = static_cast(oisInputManager->createInputObject(OIS::OISMouse, false));
OIS::JoyStick *oisJoystick = NULL;
try
{
    oisJoystick = static_cast  (oisInputManager->createInputObject(OIS::OISJoyStick, false));
}
catch(...)
{
    oisJoystick = NULL;
}

La creazione del device del joystick è stata inserita in un blocco try&catch perchè altimenti la libreria solleverebbe un eccezione nel caso in cui non vi fosse collegato un joystick alla macchina. In realtà noi diamo per scontato che tastiera e mouse lo siano... altrimenti sarebbe necessario inserire anche le due precedenti righe in altrettanti blocchi try&catch.

Il passo successivo è definire l'area di clipping iniziale delle coordinate del mouse, larghezza e altezza di solito saranno quelle relative alla finestra della nostra applicazione. Quest'operazione dovrà essere ripetuta anche in caso di resize della finestra.

if(oisMouse != NULL)
{
    const OIS::MouseState &ms = oisMouse->getMouseState();
    ms.width = width;
    ms.height = height;
}

Ora che abbiamo completato l'inizializzazione di OIS, vediamo come leggere i devices nel ciclo di update dell'applicazione, iniziamo dal mouse:

const OIS::MouseState &ms = this->oisMouse->getMouseState();

Nella variabile ms potremo leggere le coordinate del mouse assolute e relative rispettivamente con ms.X.abs e ms.X.rel, questo vale anche per Y e Z. Per leggere lo stato dei pulsanti invece useremo ms.buttons con un and con la costante del tasto che ci interessa verificare (es. ms.buttons & OIS::MB_Right), ecco una tabella riassuntiva:

OIS::MB_Left      // tasti sinistro, centrale e destro

OIS::MB_Middle

OIS::MB_Right

OIS::MB_Button3   // eventuali bottoni aggiuntivi da 3 a 7

[...]

OIS::MB_Button7

To be continued...

Read more...

Input multipiattaforma con OIS - 1a parte

Oggi parliamo di OIS una libreria per l'input multipiattaforma (più precisamente Linux, Window e MacOS anche se quest'ultimo solo parzialmente supportato), gestisce svariate periferiche (tastiera, mouse, joystick, wiimote, etc.) e dispositivi dotati di forcefeedback, è scritta in c++ ed è orientata ad oggetti.

Nota: negli esempi tratto la compilazione e/o utilizzo per Linux, ma non ci sono sostanziali differenze dall'utilizzo su Windows, in ogni caso nel pacchetto dei sorgenti di OIS è presente il file "readme.txt" con tutte le informazioni necessarie.

L'utilizzo neanche a dirlo è semplicissimo, iniziamo con lo scaricare i sorgenti da qui:

http://sourceforge.net/projects/wgois/files/

una volta scompattato l'archivio in una directory a scelta, eseguiremo la compilazione con:

./bootstrap
./configure
./make && make install

ovviamente, per eseguire il make install dovremo avere il privilegi di root.

Per utilizzare OIS nel nostro programma dovremo includere il suo header:

#include "OIS/OIS.h"

Creare una lista di parametri con le nostre preferenze da utilizzare per la creazione dell'inputManahger, e cosa molto importante dovremo passare ad OIS l'id di una finestra già aperta su cui agganciare l'input (nel caso di Window un HWND):

char windowIdStr[40];
sprintf(windowIdStr, "%u", windowId);

OIS::ParamList pl;
pl.insert(std::make_pair(std::string("WINDOW"), std::string(windowIdStr)));

#if defined OIS_WIN32_PLATFORM    
pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));
pl.insert(std::make_pair(std::string("w32_mouse"), std::string( hideMouse ? "DISCL_EXCLUSIVE" : "DISCL_NONEXCLUSIVE" )));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
#elif defined OIS_LINUX_PLATFORM
pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string( hideMouse ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
#endif
 

OIS::InputManager* oisInputManager = OIS::InputManager::createInputSystem( pl );

In sostanza i vari paramentri sono sia per la versione Win32 che per linux e servono per specificare se effettuare il grab della tastiera e del mouse e se nascondere il puntatore del mouse.


To be continued...

Read more...