Hello everyone!
I'm trying to decide on wether to use polling, pulling or pushing for keyboard input. I tried searching but did not find any good answer containing all three these in a comparison, and I've reached a point where I need to decide for a bigger project. I'm well aware that there's rarely one best solution, but I'm curious as to wether there is any preferred method amongst other game developers.
As far as definitions go (my opinions, of course), polling means that each individual module checks it's own keybinds towards the underlying API (in my case, Windows).
Pros:
- Easy to implement
- Keybindings are easy to manage inside the class
- Multiple keybinds for same button
Cons:
- Lots and lots of API calls to check key states
- Will become more difficult to change if performance becomes an issue
- Will need N polls per frame, N -> number of binding
Pulling is essentially the same, but instead of each individual module polling, we would do one big API-poll in a KeybindManager and then each module polls that one - pulling a keystate variable instead of polling the API.
Pros:
- It's sort-of Observer-patttern
- Keybindings are easily visible inside the class
- Can easily be refactored into either of the others by being a middle ground.
- Multiple keybinds for same button
Cons:
- Still need to do lots and lots of checks
- Still needs 1 API-poll + N pulls per frame
Pushing is the same as pulling, but as the name suggest it tells each class when a button changes state instead of each class checking its buttons.
Pros:
- It's a correct Observer-pattern
- An effecient implementation will only notify changes, reducing CPU-cycles needed
Cons:
- It requires an interface/mediator/semaphore-style variable
- If we want to reduce notifications, we increase complexity in KeyboardManager
- Multiple keybinding leads to drastically increased complexity.
If I've done either of the styles injustice in my pros/cons, or if you disagree with the descriptions, please say so. In a code scenario, simplified they'd be like this:
Polling
//Vehicle.cpp
void Vehicle::UpdatePoll(int time){
if(GetKeyState(VK_RETURN){ //Do something ? }
}Pulling
//Vehicle.cpp
void Vehicle::UpdatePull(int time){
if (kbManager->IsKey(VK_RETURN){ ... }
}
//Keyboardmanager.cpp
void KBManager::Update(){
localKeyStates = GetKeyStates();
}
UINT KBManager::IsKey(UINT virtualKey){
return localKeyStates[virtualKey];
}Pushing
//Vehicle.cpp inherits KeyObserver
Vehicle::Vehicle(){
kbManager->Register(VK_RETURN, this);
}
void Vehicle::UpdateKeyState(UINT keyVal, bool state){
if (keyVal == VK_RETURN) this->keyReturn = state;
}
void Vehicle::Update(int time){
if(this->keyReturn) { ... }
}
//Keyboardmanager.cpp
void KBManager::Register(UINT virtualKey, KeyObserver& obj){
this->BindingList[virtualKey] = obj;
}
void KBManager::Update(int time){
this->localKeyStates = GetKeyStates();
for_each (UINT key : BindingList.Keys){
Notify(key);
}
}
void KBManager::Notify(UINT key){
if (IsChanged(localKeyStates[key])){
BindingList[key]->Update(key, localKeyStates[key]);
}
}
