Linux game programming An introduction to the use of interval timers and asynchronous input notifications.

Slides:



Advertisements
Similar presentations
Linux Serial Programming for POSIX Operating Systems
Advertisements

1 Exceptions, Interrupts & Traps Operating System Hebrew University Spring 2007.
Terminal I/O POSIX termios Two terminal I/O modes Canonical and non-canonical Getting and setting terminal attributes Terminal window size: struct winsize.
I/O Multiplexing The role of the ‘poll()’ method in Linux device-driver operations.
I/O Multiplexing Road Map: 1. Motivation 2. Description of I/O multiplexing 3. Scenarios to use I/O multiplexing 4. I/O Models  Blocking I/O  Non-blocking.
The ‘system-call’ interface We see how an application program can invoke privileged kernel services.
Crafting a ‘demo’ program A ‘walk-through’ of the program development cycle for an example in assembly language.
A code-walkthrough Commentary on our ‘wfmodel.cpp’ demo-program – an initial ‘prototype’ for 3D wire-frame animations.
Terminal Control operating systems. Terminal Control may seem like an arcane subject, but … It illustrates the relationship between devices and files.
Figure 2.8 Compiler phases Compiling. Figure 2.9 Object module Linking.
1 School of Computing Science Simon Fraser University CMPT 300: Operating Systems I Dr. Mohamed Hefeeda.
Dynamic visualizations On ‘non-canonical’ keyboard-input and terminal escape-sequences for visualization effects.
A code-walkthrough Commentary on our ‘model3d.cpp’ demo-program – an initial ‘prototype’ for 3D wire-frame animations.
Home: Phones OFF Please Unix Kernel Parminder Singh Kang Home:
Slide 6-1 Copyright © 2004 Pearson Education, Inc. Operating Systems: A Modern Perspective, Chapter 6 Threads and Scheduling 6.
Basic Input/Output Operations
Michener’s Algorithm An efficient scheme for drawing circles (and filling circular disks) on a raster graphics display.
Signal Signal : - is a notification sent to a process to notify it of some event - interrupts whatever the process is doing and force it to handle a signal.
Vertical Retrace Interval An introduction to VGA techniques for smooth graphics animation.
Timers and Interrupts Shivendu Bhushan Summer Camp ‘13.
Based on slides created by Edward Angel
Exceptions, Interrupts & Traps
CCNA 2 v3.1 Module 2.
Linux game programming An introduction to the use of interval timers and asynchronous input notifications.
Getting Started with Linux: Novell’s Guide to CompTIA’s Linux+ (Course 3060) Section 2 Use the Linux Desktop.
SE320: Introduction to Computer Games Week 8: Game Programming Gazihan Alankus.
UNIX Signals Bach 7.2 Operating Systems Course The Hebrew University Spring 2010.
General System Architecture and I/O.  I/O devices and the CPU can execute concurrently.  Each device controller is in charge of a particular device.
Signals & Timers CS241 Discussion Section Spring 2009 Week 6.
Tanenbaum & Woodhull, Operating Systems: Design and Implementation, (c) 2006 Prentice-Hall, Inc. All rights reserved OPERATING SYSTEMS DESIGN.
System Calls 1.
FINAL MPX DELIVERABLE Due when you schedule your interview and presentation.
Signal-Driven I/O Concepts and steps for using signal-driven I/O
CHAPTER 2: COMPUTER-SYSTEM STRUCTURES Computer system operation Computer system operation I/O structure I/O structure Storage structure Storage structure.
1Reference “Introduction To Unix Signals Programming” in the reference material section Man page – sigprocmask, alarm “Understanding the Linux Kernel”
1Computer Graphics Input and Interaction Lecture 8 John Shearer Culture Lab – space 2
Computer Graphics I, Fall 2010 Input and Interaction.
Addison Wesley is an imprint of © 2010 Pearson Addison-Wesley. All rights reserved. Chapter 7 The Game Loop and Animation Starting Out with Games & Graphics.
Lecture 3 Process Concepts. What is a Process? A process is the dynamic execution context of an executing program. Several processes may run concurrently,
The tty Interface An introduction to “systems programming” in the Linux environment.
NT Kernel CS Spring Overview Interrupts and Exceptions: Trap Handler Interrupt Request Levels and IRT DPC’s, and APC’s System Service Dispatching.
Accessing I/O Devices Processor Memory BUS I/O Device 1 I/O Device 2.
Timers and Interrupts Anurag Dwivedi. Let Us Revise.
Interrupt driven I/O. MIPS RISC Exception Mechanism The processor operates in The processor operates in user mode user mode kernel mode kernel mode Access.
1 Input and Interaction. 2 Objectives Introduce the basic input devices ­Physical Devices ­Logical Devices ­Input Modes Event-driven input Introduce double.
TELE 402 Lecture 12: Signal-Driven I/O & Raw Socket 1 Overview Last Lecture –Advanced UDP sockets and threads –Source: Chapters 22&26 of Stevens’ book.
Copyright ©: Nahrstedt, Angrave, Abdelzaher, Caccamo1 Timers and Clocks II.
CE Operating Systems Lecture 2 Low level hardware support for operating systems.
Operating Systems 1 K. Salah Module 1.2: Fundamental Concepts Interrupts System Calls.
UNIX Signals * POSIX-Defined Signals * Signaling Processes * Signal Mask * sigaction * kill and sigaction * alarm * Interval Timers * POSIX.1b Timers *
University of New Mexico
Implementing ‘noecho’ Programming details regarding the Linux implementation for ‘struct termios’ objects.
CE Operating Systems Lecture 2 Low level hardware support for operating systems.
© Janice Regan, CMPT 300, May CMPT 300 Introduction to Operating Systems Operating Systems Processes and Threads.
Today’s topics Signals and how to control the program behavior in handling signals. Terminal I/O.
Interrupt driven I/O Computer Organization and Assembly Language: Module 12.
Operating Systems CMPSC 473 Signals, Introduction to mutual exclusion September 28, Lecture 9 Instructor: Bhuvan Urgaonkar.
S -1 Processes. S -2 wait and waitpid (11.2) Recall from a previous slide: pid_t wait( int *status ) wait() can: (a) block; (b) return with status; (c)
I/O Software CS 537 – Introduction to Operating Systems.
1 Lecture 19: Unix signals and Terminal management n what is a signal n signal handling u kernel u user n signal generation n signal example usage n terminal.
Interrupts and Exception Handling. Execution We are quite aware of the Fetch, Execute process of the control unit of the CPU –Fetch and instruction as.
Processes and threads.
CSC461 Lecture 8: Input Devices
Module 2: Computer-System Structures
Advanced UNIX programming
Module 2: Computer-System Structures
Module 2: Computer-System Structures
Module 2: Computer-System Structures
ECE 352 Digital System Fundamentals
On using the mouse A brief introduction to LIBGPM: the General Purpose Mouse programming interface.
Presentation transcript:

Linux game programming An introduction to the use of interval timers and asynchronous input notifications

Our prior animation demo We achieved the illusion of “smooth” and “flicker-free” animation, by synchronizing drawing-operations with Vertical Retrace But more is needed in a game that’s “fun” Some deficiencies in our ‘animate1’ demo: –Ball movements tied to Vertical Retrace –The viewer lacked any real-time control How can we overcome these limitations?

Decoupling ‘move’ from ‘draw’ Our program-loop had used logic like this: do { vsync();// delay until start of the next retrace hide_ball(); // “erase” the ball move_ball();// adjust its location show_ball();// “redraw” the ball --count;// decrement a counter } while ( count > 0 ); So ball movement is delayed by vertical retraces

Linux provides ‘interval timers’ #include struct itimervalitval, itold; itval.it_value.tv_sec = 2; itval.it_value.tv_usec = 0; itval.it_interval.tv_sec = 0; itval.it_interval.tv_usec = 10000; setitimer( ITIMER_REAL, &itval, &itold ); (See the ‘man’ page for additional details)

structs timeval and itimerval tv_sec tv_usec struct timeval tv_sec tv_usec tv_sec tv_usec it_interval it_value struct itimerval It_itimerval = next delay value, it_timeval = current delay value

SIGALRM When timer “expires” our application gets notified, by being sent a signal from Linux Normally an application gets terminated if the SIGALRM signal is delivered to it But we can alter that default behavior, by installing a ‘signal-handler’ that we design We can ‘move-the-ball’ when SIGALRM is received, regardless of Vertical Retrace

Our signal-handler void on_alarm( int signum ) { // modify these global variables ball_xcoordinate += xincrement; ball_ycoordinate += yincrement; } // The ‘signal()’ function “installs” our handler signal( SIGALRM, on_alarm);

Main program-loop “revised” We can now omit ball-movement in main loop: do { vsync();// delay until start of the next retrace hide_ball(); // “erase” the old ball oldx = newx; oldy = newy;// remember new position show_ball();// “redraw” the new ball --count;// decrement a counter } while ( count > 0 ); Ball-movement is managed by ‘signal-handler’

‘draw’ versus ‘move’ The code in this signal-handler takes care of all movements whenever it’s time for them to occur The code in this loop handles all the actual re-drawing in sync with the vertical retrace Signal-handler Program-loop The Operating System takes care of switching the CPU between these two separate threads-of-control

Giving the user control Linux supports “asynchronous” terminal i/o We can reprogram the terminal console so a SIGIO signal will be sent to our program whenever the user decides to press a key And we can install a ‘signal-handler’ of our own design that executes if SIGIO arrives This will allow a user to “control” our game

The ‘tty’ interface ‘tty’ is an acronyn for ‘TeleTYpe’ terminal Such devices have a keyboard and screen Behavior emulates technology from 1950s Usually a tty operates in ‘canonical’ mode: –Each user-keystroke is ‘echoed’ to screen –Some editing is allowed (e.g., backspace) –The keyboard-input is internally buffered –The -key signals an ‘end-of-line’ –Programs receive input one-line-at-a-time

‘tty’ customization Sometimes canonical mode isn’t suitable (an example: animated computer games) The terminal’s behavior can be modified! UNIX provides a convenient interface: –#include –struct termios tty; –int tcgetattr( int fd, struct termios *tty ); –int tcsetattr( int fd, int flag, struct termios *tty );

How does the ‘tty’ work? TeleTYpe display device HARDWARE SOFTWARE application tty_driver c_lflag input handling c_iflag c_cc output handling c_oflag terminal_driver c_cflag User space Kernel space struct tty { c_iflag; c_oflag; c_cflag; c_lflag; c_line; c_cc[ ]; };

The ‘c_lflag’ field This field is just an array of flag bits Individual bits have symbolic names Names conform to a POSIX standard Linux names match other UNIX’s names Though actual symbol values may differ Your C/C++ program should use: #include for portability to other UNIX environments

ICANON and ECHO Normally the ‘c_lflag’ field has these set They can be cleared using bitwise logic: tty.c_lflag &= ~ECHO;// inhibit echo tty.c_lflag &= ~ICANON;// no buffering

The ‘c_cc[ ]’ array ‘struct termios’ objects include an array The array-indices have symbolic names Symbol-names are standardized in UNIX Array entries are ‘tty’ operating parameters Two useful ones for our purposes are: tty.c_cc[ VMIN ] and tty.c_cc[ VTIME ]

How to setup ‘raw’ terminal-mode Step 1: Use ‘tcgetattr()’ to get a copy of the current tty’s ‘struct termios’ settings Step 2: Make a working copy of that object Step 3: Modify its flags and control-codes Step 4: Use ‘tcsetattr()’ to install changes Step 5: Perform desired ‘raw’ mode input Step 6: Use ‘tcsetattr()’ to restore the terminal to its original default settings

‘raw’ mode needs four changes tty.c_cc[ VMIN ] = 1; –so the ‘read()’ function will return as soon as at least one new input-character is available tty.c_cc[ VTIME ] = 0; –so there will be no time-delay after each new key pressed until the ‘read()’ function returns tty.c_lflag &= ~ECHO;// no echoing tty.c_lflag &= ~ICANON;// no buffering

Demo program: ‘rawtty.cpp’ This program may soon prove useful It shows the keyboard scancode values It demonstrates ‘noncanonical’ tty mode It clears the ISIG bit (in ‘c_lflags’ field) This prevents -C from being used to abort the program: the user must ‘quit’ by hitting the -key; so default terminal-settings will get reinstalled

‘Noncanonical’ terminal i/o We’ve now learned how to reprogram the terminal to allow “raw” keyboard input #include struct termiostty; tcgetattr( 0, &tty );// get tty settings tty.c_lflag &= ~( ICANON | ECHO | ISIG ); tty.c_cc[ VMIN ] = 1; tty.c_cc[ VTIME ] = 0; tcsetattr( 0, TCSAFLUSH, &tty );// install

Handling a key-press Here’s a ‘simple’ signal-handler that lets a user decide to terminate our program (by hitting the -key) instead of the program itself deciding to quit when a counter reaches zero void on_input( int signum ) { intinch = 0; read( 0, &inch, 4 ); if ( inch == ESCAPE_KEY ) done = 1; }

Enabling ‘asynchronous’ I/O Now we need to install our signal-handler, specify which program will receive SIGIO, then enable the delivery of these signals signal( SIGIO, on_input ); fcntl( 0, F_SETOWN, getpid() ); int flagval = fcntl( 0, F_GETFL, NULL ); flagval |= O_ASYNC;// turn on flag-bit fcntl( 0, F_SETFL, flagval );

‘animate2.cpp’ Handles User’s keystrokes (SIGIO) Handles Timer’s expirations (SIGALRM) on_input on_alarm Handles redrawing whenever Vertical Retrace Is active main_loop The Signal-Handlers Waiting and Drawing

Program-loop revised again done = 0; do{ oldx = xloc, oldy = yloc; // remember these draw_ball();// use current location vsync();// await next retrace hide_ball();// erase previous ball } while ( !done ); // ‘xloc’, ‘yloc’, and ‘done’ get changed by handlers

Enhancment: more user-control In ‘pong’ game the user moves a ‘paddle’ The paddle can only be moved left or right Lower wall of the playing-court is removed Ball will “escape” unless it hits the paddle Keyboard has left and right “arrow keys” Our input signal-handler could “move” the paddle whenever a user hits an arrow-key

In-class exercise #1 Before you remove the game-court’s lower wall, see if you can implement the paddle- movements (left or right) in response to a user’s hitting the left-arrow or right-arrow You will need to investigate the numerical code-sequence that Linux generates when a user hits one of these arrow-keys Our ‘rawtty.cpp’ application may be useful!

In-class exercise #2 For brevity, our ‘animate2’ demo-program removed the capability of users controlling the speed of the ball-movements (with an argument supplied on the command-line) Can you devise a way for users to exert “run-time” control over the ball’s speed by pressing keys while the program is running (for example, the ‘+’ key and the ‘-’ key)?