Understanding Keyboard State

Advantages of Event-driven Input

What are the advantages of using event-driven input handling over polling?

Abstract art representing computer programming

Event-driven input handling and polling are two different approaches to managing user inputs in SDL.

Each has its own advantages, but event-driven input handling offers several benefits, particularly for certain types of applications.

Advantages of Event-driven Input Handling

Efficiency:

  • Event-driven input is more efficient because it only processes input events when they occur. This means the CPU is not wasting cycles checking for input when there is none.
  • Polling continuously checks the state of inputs, which can be inefficient if events occur infrequently.

Responsiveness:

  • With event-driven input, your application can respond immediately to user actions. This can result in a more responsive user experience, as the event loop will handle the event as soon as it is detected.
  • In contrast, polling might introduce a slight delay, especially if the polling frequency is low.

Simplicity:

  • Handling discrete actions (e.g., key presses, mouse clicks) is simpler with event-driven input. You can write clean, straightforward code that reacts to specific events.
  • Polling requires checking the state of inputs continuously, which can complicate the logic, especially when handling multiple inputs or state changes.

Resource Management:

  • Event-driven input can lead to better resource management. By processing events only when they occur, your application can remain idle, conserving CPU and power usage.
  • Continuous polling can keep the CPU busy, consuming more power and resources.

Example

Here’s a simple example of event-driven input handling in SDL:

#include <SDL.h>
#include <iostream>

int main(int argc, char* argv[]) {
  SDL_Init(SDL_INIT_VIDEO);

  SDL_Window* window = SDL_CreateWindow(
    "Event-driven Input",
    SDL_WINDOWPOS_CENTERED,
    SDL_WINDOWPOS_CENTERED,
    640, 480, SDL_WINDOW_SHOWN
  );

  SDL_Event event;
  bool running = true;

  while (running) {
    while (SDL_PollEvent(&event)) {
      if (event.type == SDL_QUIT) {
        running = false;
      } else if (event.type == SDL_KEYDOWN) {
        if (event.key.keysym.scancode
          == SDL_SCANCODE_SPACE) {
          std::cout << "Space key pressed\n";
        }
      }
    }
    // Rendering code here
  }

  SDL_DestroyWindow(window);
  SDL_Quit();
  return 0;
}
Space key pressed

Conclusion

Event-driven input handling is ideal for applications where inputs are sporadic or discrete actions. It offers better efficiency, responsiveness, simplicity, and resource management compared to polling.

However, for continuous input scenarios, such as holding down a key for movement, polling might be more appropriate. Understanding the strengths of each method will help you choose the right approach for your application.

This Question is from the Lesson:

Understanding Keyboard State

Learn how to detect and handle keyboard input in SDL2 using both event-driven and polling methods. This lesson covers obtaining and interpreting the keyboard state array.

Answers to questions are automatically generated and may not have been reviewed.

This Question is from the Lesson:

Understanding Keyboard State

Learn how to detect and handle keyboard input in SDL2 using both event-driven and polling methods. This lesson covers obtaining and interpreting the keyboard state array.

sdl2-promo.jpg
Part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

Free, unlimited access

This course includes:

  • 36 Lessons
  • 100+ Code Samples
  • 91% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved