Xcode/TemplatesForXcode/SDL Custom Cocoa Application/MyController.m - third_party/sdl - Git at Google

 //
 //  MyController.m
 //  SDL Custom Cocoa App
 //
 //  Created by Darrell Walisser on Fri Jul 18 2003.
 //  Copyright (c) 2003 __MyCompanyName__. All rights reserved.
 //

 #import "MyController.h"
 #import "SDL.h"

 id gController;

 @implementation MyController

 - (id)init
 {
     self = [ super init ];
     if (self) {

         _nSprites = 10;
         _max_speed = 4;
         _doFlip = 0;
         _mem = NULL;
         _screen = NULL;
         _sprite_rects = NULL;
         _positions = NULL;
         _velocities = NULL;
         _sprites_visible = 1;
         _sprite_w = 0;
         _sprite_h = 0;
         _mouse_x = 0;
         _mouse_y = 0;
     }

     return self;
 }

 - (void)setupCocoaWindow
 {
     // If you want the close button to send SDL_Quit,
     // you can attach the SDL_QuartzWindowDelegate to the window
     [ _window setDelegate:
         [ [ [ SDL_QuartzWindowDelegate alloc ] init ] autorelease ] ];

     // Make the window visible and the frontmost window
     [ _window makeKeyAndOrderFront:nil ];

     // Make the window accept passive motion events (when the button is released)
     [ _window setAcceptsMouseMovedEvents:YES ];
 }

 - (void)setCocoaEnvironmentVariables
 {
     // Export cocoa objects to environment
     // SDL will use these when you call SDL_SetVideoMode

     // 	The window must be visible when you call SDL_SetVideoMode,
     // 	and the view must lie completely within the window.
     //
     //  The width and height passed to SDL_SetVideoMode should match
     //  the width/height of the view (the window can be any size)
     //
     // 	For resizing to work, you must set the appropriate
     // 	attributes on the window and view. Then the SDL_RESIZABLE
     //  flag will be set automatically
     //
     //  SDL will retain a reference to the window, and
     //  will release it when unsetting the video mode
     //
     //  The view is not retained (the window object manages this).
     //
     char buffer[256];
     printf ("NSWindow=%p\n", _window);
     sprintf (buffer, "%d", (int)_window);
     setenv ("SDL_NSWindowPointer", buffer, 1);

     printf ("NSQuickDrawView=%p\n", _view);
     sprintf (buffer, "%d", (int)_view);
     setenv ("SDL_NSQuickDrawViewPointer", buffer, 1);

     // Also tell SDL to pass keyboard events to Cocoa
     // In this case, Cocoa will get the event before SDL_PollEvent returns it
     // Note that mouse events (button, motion) will always be passed, regardless of this setting
     setenv ("SDL_ENABLEAPPEVENTS", "1", 1);
 }

 - (void)printFlags:(Uint32)flags withName:(const char*)name
 {
     printf ("%s", name);

     if (flags & SDL_SWSURFACE)
         printf (" - SDL_SWSURFACE");
     if (flags & SDL_HWSURFACE)
         printf (" - SDL_HWSURFACE");
     if (flags & SDL_ASYNCBLIT)
         printf (" - SDL_ASYNCBLIT");
     if (flags & SDL_ANYFORMAT)
         printf (" - SDL_ANYFORMAT");
     if (flags & SDL_HWPALETTE)
         printf (" - SDL_HWPALETTE");
     if (flags & SDL_DOUBLEBUF)
         printf (" - SDL_DOUBLEBUF");
     if (flags & SDL_FULLSCREEN)
         printf (" - SDL_FULLSCREEN");
     if (flags & SDL_OPENGL)
         printf (" - SDL_OPENGL");
     if (flags & SDL_OPENGLBLIT)
         printf (" - SDL_OPENGLBLIT");
     if (flags & SDL_RESIZABLE)
         printf (" - SDL_RESIZABLE");
     if (flags & SDL_NOFRAME)
         printf (" - SDL_NOFRAME");

     printf ("\n");
 }
 // This is a way of telling whether or not to use hardware surfaces
 // Note: this does nothing on Mac OS X at the moment - there is no
 // hardware-accelerated blitting support.
 - (Uint32)fastestFlags:(Uint32)flags :(int)width :(int)height :(int)bpp
 {
 	const SDL_VideoInfo *info;

 	// Hardware acceleration is only used in fullscreen mode
 	flags |= SDL_FULLSCREEN;

 	// Check for various video capabilities
 	info = SDL_GetVideoInfo();
 	if ( info->blit_hw_CC && info->blit_fill ) {
 		// We use accelerated colorkeying and color filling
 		flags |= SDL_HWSURFACE;
 	}
 	// If we have enough video memory, and will use accelerated
 	//   blits directly to it, then use page flipping.
 	if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {

         // Direct hardware blitting without double-buffering
 		// causes really bad flickering.
 		if ( info->video_mem*1024 > (height*width*bpp/8) ) {
 			flags |= SDL_DOUBLEBUF;
 		} else {
 			flags &= ~SDL_HWSURFACE;
 		}
 	}

 	// Return the flags
 	return flags;
 }

 - (int)loadSpriteFromFile:(const char*)file
 {
 	SDL_Surface *temp;

 	// Load the sprite image
 	_sprite = SDL_LoadBMP (file);
 	if ( _sprite == NULL ) {
 		fprintf (stderr, "Couldn't load %s: %s", file, SDL_GetError ());
 		return (-1);
 	}

 	// Set transparent pixel as the pixel at (0,0)
 	if ( _sprite->format->palette ) {
 		SDL_SetColorKey (_sprite, (SDL_SRCCOLORKEY|SDL_RLEACCEL),
 						 *(Uint8 *)_sprite->pixels);
 	}

 	/* Convert sprite to video format */
 	temp = SDL_DisplayFormat (_sprite);
 	SDL_FreeSurface (_sprite);
 	if ( temp == NULL ) {
 		fprintf(stderr, "Couldn't convert background: %s\n",
                 SDL_GetError ());
 		return (-1);
 	}
 	_sprite = temp;

 	// We're ready to roll. :)
 	return 0;
 }

 - (void)allocSprites
 {
     /* Allocate memory for the sprite info */
 	_mem = (Uint8 *)malloc (4*sizeof(SDL_Rect)*_nSprites);
 	if ( _mem == NULL ) {
 		fprintf (stderr, "Out of memory!\n");
 		exit (2);
 	}

 	_sprite_rects = (SDL_Rect *)_mem;
 	_positions = _sprite_rects;
 	_sprite_rects += _nSprites;
 	_velocities = _sprite_rects;
 	_sprite_rects += _nSprites;
 	_sprite_w = _sprite->w;
 	_sprite_h = _sprite->h;
 }

 - (void)freeSprites
 {
     free (_mem);
     _mem = NULL;
 }

 - (void)initSprites
 {
     // Give each sprite a random starting position and velocity
     int i;

 	srand(time(NULL));
 	for ( i=0; i < _nSprites; ++i ) {
 		_positions[i].x = rand()%(_screen->w - _sprite->w);
 		_positions[i].y = rand()%(_screen->h - _sprite->h);
 		_positions[i].w = _sprite->w;
 		_positions[i].h = _sprite->h;
 		_velocities[i].x = 0;
 		_velocities[i].y = 0;
 		while ( ! _velocities[i].x && ! _velocities[i].y ) {
 			_velocities[i].x = (rand()%(_max_speed*2+1)) - _max_speed;
 			_velocities[i].y = (rand()%(_max_speed*2+1)) - _max_speed;
 		}
 	}
 }

 - (void)moveSprites:(int)backgroundColor;
 {
 	int i, nupdates;
 	SDL_Rect area, *position, *velocity;

 	nupdates = 0;
 	// Erase all the sprites if necessary
 	if ( _sprites_visible ) {
 		SDL_FillRect (_screen, NULL, backgroundColor);
 	}

 	// Move the sprite, bounce at the wall, and draw
 	for ( i=0; i < _nSprites; ++i ) {
 		position = &_positions[i];
 		velocity = &_velocities[i];
 		position->x += velocity->x;
 		if ( (position->x < 0) || (position->x >= (_screen->w - _sprite_w)) ) {
 			velocity->x = -velocity->x;
 			position->x += velocity->x;
 		}
 		position->y += velocity->y;
 		if ( (position->y < 0) || (position->y >= (_screen->h - _sprite_w)) ) {
 			velocity->y = -velocity->y;
 			position->y += velocity->y;
 		}

 		// Blit the sprite onto the screen
 		area = *position;
 		SDL_BlitSurface (_sprite, NULL, _screen, &area);
 		_sprite_rects[nupdates++] = area;
 	}

 	// Update the screen!
 	if ( _doFlip ) {
 		SDL_Flip (_screen);
 	} else {
 		SDL_UpdateRects (_screen, nupdates, _sprite_rects);
 	}

 	_sprites_visible = 1;
 }

 - (int)run:(int)argc argv:(char*[])argv
 {
 	int width, height;
 	Uint8  video_bpp;
 	Uint32 videoflags;
 	Uint32 background;
 	int    done;
 	SDL_Event event;
     Uint32 then, now, frames;

 	// Initialize SDL
 	if ( SDL_Init (SDL_INIT_VIDEO) < 0 ) {
 		fprintf (stderr, "Couldn't initialize SDL: %s\n", SDL_GetError ());
 		exit (1);
 	}
 	atexit(SDL_Quit);

 	videoflags = SDL_SWSURFACE|SDL_ANYFORMAT;
 	width = 640;
 	height = 480;
 	video_bpp = 8;
 	while ( argc > 1 ) {
 		--argc;
 		if ( strcmp(argv[argc-1], "-width") == 0 ) {
 			width = atoi (argv[argc]);
 			--argc;
 		} else
 		if ( strcmp(argv[argc-1], "-height") == 0 ) {
 			height = atoi (argv[argc]);
 			--argc;
 		} else
 		if ( strcmp(argv[argc-1], "-bpp") == 0 ) {
 			video_bpp = atoi (argv[argc]);
 			videoflags &= ~SDL_ANYFORMAT;
 			--argc;
 		} else
 		if ( strcmp (argv[argc], "-fast") == 0 ) {
 			videoflags = [ self fastestFlags:videoflags :width :height :video_bpp ];
 		} else
 		if ( strcmp (argv[argc], "-hw") == 0 ) {
 			videoflags ^= SDL_HWSURFACE;
 		} else
 		if ( strcmp (argv[argc], "-flip") == 0 ) {
 			videoflags ^= SDL_DOUBLEBUF;
 		} else
 		if ( strcmp (argv[argc], "-fullscreen") == 0 ) {
 			videoflags ^= SDL_FULLSCREEN;
 		} else
 		if ( isdigit(argv[argc][0]) ) {
 			_nSprites = atoi (argv[argc]);
 		} else {
 			fprintf (stderr,
 	"Usage: %s [-bpp N] [-hw] [-flip] [-fast] [-fullscreen] [numSprites]\n",
 								argv[0]);
 			exit (1);
 		}
 	}

     // The width/height passed to SDL_SetVideoMode should match the size of the NSView
     width = [ _view frame ].size.width;
     height = [ _view frame ].size.height;
     videoflags &= ~SDL_FULLSCREEN; // this only for windowed mode
     if ( [ _window styleMask ] & NSResizableWindowMask ) // enable resizable window
         videoflags |= SDL_RESIZABLE;
     [ self setupCocoaWindow ];
     [ self setCocoaEnvironmentVariables ];
     _mouse_x = width/2;
     _mouse_y = width/2;

 	// Set video mode
 	_screen = SDL_SetVideoMode (width, height, video_bpp, videoflags);
 	if ( ! _screen ) {
 		fprintf (stderr, "Couldn't set %dx%d video mode: %s\n",
                     width, height, SDL_GetError());
 		exit (2);
 	}

 	// Print out surface info
 	[ self printFlags:videoflags     withName:"Requested flags: " ];
 	[ self printFlags:_screen->flags withName:"Got flags:       " ];

 	// Load the sprite
 	// The sprite is located in the Resources section of the .app bundle.
 	// SDL does not seem aware of bundle paths, so we must construct the path manually.
 	NSString* resource_path = [[NSBundle mainBundle] resourcePath];
 	NSString* icon_path = [resource_path stringByAppendingString:@"/icon.bmp"];
 	if ( [ self loadSpriteFromFile:[icon_path UTF8String] ] < 0 ) {
 		exit (1);
 	}

     [ self allocSprites ];
     [ self initSprites ];

 	background = SDL_MapRGB (_screen->format, 0x00, 0x00, 0x00);

 	// Print out information about our surfaces
 	printf("Screen is at %d bits per pixel\n", _screen->format->BitsPerPixel);
 	if ( (_screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
 		printf ("Screen is in video memory\n");
 	} else {
 		printf ("Screen is in system memory\n");
 	}
 	if ( (_screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
 		printf ("Screen has double-buffering enabled\n");
 	}
 	if ( (_sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
 		printf ("Sprite is in video memory\n");
 	} else {
 		printf ("Sprite is in system memory\n");
 	}

 	// Run a sample blit to trigger blit acceleration
 	{
         SDL_Rect dst;
 		dst.x = 0;
 		dst.y = 0;
 		dst.w = _sprite->w;
 		dst.h = _sprite->h;
 		SDL_BlitSurface (_sprite, NULL, _screen, &dst);
 		SDL_FillRect (_screen, &dst, background);
 	}
 	if ( (_sprite->flags & SDL_HWACCEL) == SDL_HWACCEL ) {
 		printf("Sprite blit uses hardware acceleration\n");
 	}
 	if ( (_sprite->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
 		printf("Sprite blit uses RLE acceleration\n");
 	}

 	// Loop, blitting sprites and waiting for a keystroke
 	frames = 0;
 	then = SDL_GetTicks();
 	done = 0;
 	_sprites_visible = 0;
 	while ( !done ) {
 		// Check for events
 		++frames;
 		while ( SDL_PollEvent(&event) ) {
 			switch (event.type) {

                 case SDL_VIDEORESIZE:

                     // Recreate the video mode. Use the same bpp and flags
                     // that the original window was created with
                     _screen = SDL_SetVideoMode (event.resize.w, event.resize.h,
                                                 video_bpp, videoflags);

                     // Clear screen and reinit sprite positions
                     SDL_FillRect (_screen, NULL, 0);
                     [ self initSprites ];
                     break;

                 case SDL_MOUSEMOTION:

                     _velocities[_nSprites-1].x = 0;
                     _velocities[_nSprites-1].y = 0;
                     _positions[_nSprites-1].x = event.motion.x - _sprite->w/2;
                     _positions[_nSprites-1].y = event.motion.y - _sprite->h/2;
                     //printf ("motion: %d %d\n", event.motion.x, event.motion.y);
                     break;

                 case SDL_MOUSEBUTTONDOWN:

                     _velocities[_nSprites-1].x = 0;
                     _velocities[_nSprites-1].y = 0;
                     _positions[_nSprites-1].x = event.button.x;
                     _positions[_nSprites-1].y = event.button.y;
                     //printf ("button: %d %d\n", event.button.x, event.button.y);
 					break;

                 case SDL_KEYDOWN:

 					// Escape also quits the app
                     if (event.key.keysym.sym == SDLK_ESCAPE)
                         done = 1;

                     // Control-W warps the cursor
                     if (event.key.keysym.sym == SDLK_w &&
                         ( SDL_GetModState () & KMOD_LCTRL ) )
                         SDL_WarpMouse (_screen->w/2, _screen->h/2);

                     // Control-G toggles input grabbing
                     if (event.key.keysym.sym == SDLK_g &&
                         ( SDL_GetModState () & KMOD_LCTRL ) )
                         if ( SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_OFF )
                             SDL_WM_GrabInput (SDL_GRAB_ON);
                         else
                             SDL_WM_GrabInput (SDL_GRAB_OFF);
                     break;

 				case SDL_QUIT:
 					done = 1;
 					break;
 				default:
 					break;
 			}
 		}

         // Draw sprites
         [ self moveSprites:background ];

         // Update fps counter every 100 frames
         if ((frames % 100) == 0) {
             now = SDL_GetTicks ();
             [ _framesPerSecond setFloatValue:((float)frames*1000)/(now-then) ];
             frames = 0;
             then = now;
         }
 	}
 	[ self freeSprites ];
     SDL_FreeSurface (_sprite);

 	SDL_Quit ();
 	return 0;
 }

 - (IBAction)changeNumberOfSprites:(id)sender
 {
     [ _numSprites setIntValue:[ sender intValue ] ];
     [ self freeSprites ];
     _nSprites = [ sender intValue ];
     [ self allocSprites ];
     [ self initSprites ];
     SDL_FillRect (_screen, NULL, 0);
     SDL_Flip (_screen);
 }

 - (IBAction)selectUpdateMode:(id)sender
 {
     _doFlip = ![ sender selectedRow ]; // row is 0 or 1
 }

 @end

 int main(int argc, char *argv[])
 {
     // Hand off to instance of MyController
     // This instance is created when SDLMain.nib is loaded,
     // and the global variable is set in [SDLMain applicationDidFinishLaunching:]
     return [ gController run:argc argv:argv ];
 }
	//
	// MyController.m
	// SDL Custom Cocoa App
	//
	// Created by Darrell Walisser on Fri Jul 18 2003.
	// Copyright (c) 2003 __MyCompanyName__. All rights reserved.
	//

	#import "MyController.h"
	#import "SDL.h"

	id gController;

	@implementation MyController

	- (id)init
	{
	self = [ super init ];
	if (self) {

	_nSprites = 10;
	_max_speed = 4;
	_doFlip = 0;
	_mem = NULL;
	_screen = NULL;
	_sprite_rects = NULL;
	_positions = NULL;
	_velocities = NULL;
	_sprites_visible = 1;
	_sprite_w = 0;
	_sprite_h = 0;
	_mouse_x = 0;
	_mouse_y = 0;
	}

	return self;
	}

	- (void)setupCocoaWindow
	{
	// If you want the close button to send SDL_Quit,
	// you can attach the SDL_QuartzWindowDelegate to the window
	[ _window setDelegate:
	[ [ [ SDL_QuartzWindowDelegate alloc ] init ] autorelease ] ];

	// Make the window visible and the frontmost window
	[ _window makeKeyAndOrderFront:nil ];

	// Make the window accept passive motion events (when the button is released)
	[ _window setAcceptsMouseMovedEvents:YES ];
	}

	- (void)setCocoaEnvironmentVariables
	{
	// Export cocoa objects to environment
	// SDL will use these when you call SDL_SetVideoMode

	// The window must be visible when you call SDL_SetVideoMode,
	// and the view must lie completely within the window.
	//
	// The width and height passed to SDL_SetVideoMode should match
	// the width/height of the view (the window can be any size)
	//
	// For resizing to work, you must set the appropriate
	// attributes on the window and view. Then the SDL_RESIZABLE
	// flag will be set automatically
	//
	// SDL will retain a reference to the window, and
	// will release it when unsetting the video mode
	//
	// The view is not retained (the window object manages this).
	//
	char buffer[256];
	printf ("NSWindow=%p\n", _window);
	sprintf (buffer, "%d", (int)_window);
	setenv ("SDL_NSWindowPointer", buffer, 1);

	printf ("NSQuickDrawView=%p\n", _view);
	sprintf (buffer, "%d", (int)_view);
	setenv ("SDL_NSQuickDrawViewPointer", buffer, 1);

	// Also tell SDL to pass keyboard events to Cocoa
	// In this case, Cocoa will get the event before SDL_PollEvent returns it
	// Note that mouse events (button, motion) will always be passed, regardless of this setting
	setenv ("SDL_ENABLEAPPEVENTS", "1", 1);
	}

	- (void)printFlags:(Uint32)flags withName:(const char*)name
	{
	printf ("%s", name);

	if (flags & SDL_SWSURFACE)
	printf (" - SDL_SWSURFACE");
	if (flags & SDL_HWSURFACE)
	printf (" - SDL_HWSURFACE");
	if (flags & SDL_ASYNCBLIT)
	printf (" - SDL_ASYNCBLIT");
	if (flags & SDL_ANYFORMAT)
	printf (" - SDL_ANYFORMAT");
	if (flags & SDL_HWPALETTE)
	printf (" - SDL_HWPALETTE");
	if (flags & SDL_DOUBLEBUF)
	printf (" - SDL_DOUBLEBUF");
	if (flags & SDL_FULLSCREEN)
	printf (" - SDL_FULLSCREEN");
	if (flags & SDL_OPENGL)
	printf (" - SDL_OPENGL");
	if (flags & SDL_OPENGLBLIT)
	printf (" - SDL_OPENGLBLIT");
	if (flags & SDL_RESIZABLE)
	printf (" - SDL_RESIZABLE");
	if (flags & SDL_NOFRAME)
	printf (" - SDL_NOFRAME");

	printf ("\n");
	}
	// This is a way of telling whether or not to use hardware surfaces
	// Note: this does nothing on Mac OS X at the moment - there is no
	// hardware-accelerated blitting support.
	- (Uint32)fastestFlags:(Uint32)flags :(int)width :(int)height :(int)bpp
	{
	const SDL_VideoInfo *info;

	// Hardware acceleration is only used in fullscreen mode
	flags \|= SDL_FULLSCREEN;

	// Check for various video capabilities
	info = SDL_GetVideoInfo();
	if ( info->blit_hw_CC && info->blit_fill ) {
	// We use accelerated colorkeying and color filling
	flags \|= SDL_HWSURFACE;
	}
	// If we have enough video memory, and will use accelerated
	// blits directly to it, then use page flipping.
	if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {

	// Direct hardware blitting without double-buffering
	// causes really bad flickering.
	if ( info->video_mem1024 > (heightwidth*bpp/8) ) {
	flags \|= SDL_DOUBLEBUF;
	} else {
	flags &= ~SDL_HWSURFACE;
	}
	}

	// Return the flags
	return flags;
	}

	- (int)loadSpriteFromFile:(const char*)file
	{
	SDL_Surface *temp;

	// Load the sprite image
	_sprite = SDL_LoadBMP (file);
	if ( _sprite == NULL ) {
	fprintf (stderr, "Couldn't load %s: %s", file, SDL_GetError ());
	return (-1);
	}

	// Set transparent pixel as the pixel at (0,0)
	if ( _sprite->format->palette ) {
	SDL_SetColorKey (_sprite, (SDL_SRCCOLORKEY\|SDL_RLEACCEL),
	(Uint8 )_sprite->pixels);
	}

	/* Convert sprite to video format */
	temp = SDL_DisplayFormat (_sprite);
	SDL_FreeSurface (_sprite);
	if ( temp == NULL ) {
	fprintf(stderr, "Couldn't convert background: %s\n",
	SDL_GetError ());
	return (-1);
	}
	_sprite = temp;

	// We're ready to roll. :)
	return 0;
	}

	- (void)allocSprites
	{
	/* Allocate memory for the sprite info */
	_mem = (Uint8 )malloc (4sizeof(SDL_Rect)*_nSprites);
	if ( _mem == NULL ) {
	fprintf (stderr, "Out of memory!\n");
	exit (2);
	}

	_sprite_rects = (SDL_Rect *)_mem;
	_positions = _sprite_rects;
	_sprite_rects += _nSprites;
	_velocities = _sprite_rects;
	_sprite_rects += _nSprites;
	_sprite_w = _sprite->w;
	_sprite_h = _sprite->h;
	}

	- (void)freeSprites
	{
	free (_mem);
	_mem = NULL;
	}

	- (void)initSprites
	{
	// Give each sprite a random starting position and velocity
	int i;

	srand(time(NULL));
	for ( i=0; i < _nSprites; ++i ) {
	_positions[i].x = rand()%(_screen->w - _sprite->w);
	_positions[i].y = rand()%(_screen->h - _sprite->h);
	_positions[i].w = _sprite->w;
	_positions[i].h = _sprite->h;
	_velocities[i].x = 0;
	_velocities[i].y = 0;
	while ( ! _velocities[i].x && ! _velocities[i].y ) {
	_velocities[i].x = (rand()%(_max_speed*2+1)) - _max_speed;
	_velocities[i].y = (rand()%(_max_speed*2+1)) - _max_speed;
	}
	}
	}

	- (void)moveSprites:(int)backgroundColor;
	{
	int i, nupdates;
	SDL_Rect area, position, velocity;

	nupdates = 0;
	// Erase all the sprites if necessary
	if ( _sprites_visible ) {
	SDL_FillRect (_screen, NULL, backgroundColor);
	}

	// Move the sprite, bounce at the wall, and draw
	for ( i=0; i < _nSprites; ++i ) {
	position = &_positions[i];
	velocity = &_velocities[i];
	position->x += velocity->x;
	if ( (position->x < 0) \|\| (position->x >= (_screen->w - _sprite_w)) ) {
	velocity->x = -velocity->x;
	position->x += velocity->x;
	}
	position->y += velocity->y;
	if ( (position->y < 0) \|\| (position->y >= (_screen->h - _sprite_w)) ) {
	velocity->y = -velocity->y;
	position->y += velocity->y;
	}

	// Blit the sprite onto the screen
	area = *position;
	SDL_BlitSurface (_sprite, NULL, _screen, &area);
	_sprite_rects[nupdates++] = area;
	}

	// Update the screen!
	if ( _doFlip ) {
	SDL_Flip (_screen);
	} else {
	SDL_UpdateRects (_screen, nupdates, _sprite_rects);
	}

	_sprites_visible = 1;
	}

	- (int)run:(int)argc argv:(char*[])argv
	{
	int width, height;
	Uint8 video_bpp;
	Uint32 videoflags;
	Uint32 background;
	int done;
	SDL_Event event;
	Uint32 then, now, frames;

	// Initialize SDL
	if ( SDL_Init (SDL_INIT_VIDEO) < 0 ) {
	fprintf (stderr, "Couldn't initialize SDL: %s\n", SDL_GetError ());
	exit (1);
	}
	atexit(SDL_Quit);

	videoflags = SDL_SWSURFACE\|SDL_ANYFORMAT;
	width = 640;
	height = 480;
	video_bpp = 8;
	while ( argc > 1 ) {
	--argc;
	if ( strcmp(argv[argc-1], "-width") == 0 ) {
	width = atoi (argv[argc]);
	--argc;
	} else
	if ( strcmp(argv[argc-1], "-height") == 0 ) {
	height = atoi (argv[argc]);
	--argc;
	} else
	if ( strcmp(argv[argc-1], "-bpp") == 0 ) {
	video_bpp = atoi (argv[argc]);
	videoflags &= ~SDL_ANYFORMAT;
	--argc;
	} else
	if ( strcmp (argv[argc], "-fast") == 0 ) {
	videoflags = [ self fastestFlags:videoflags :width :height :video_bpp ];
	} else
	if ( strcmp (argv[argc], "-hw") == 0 ) {
	videoflags ^= SDL_HWSURFACE;
	} else
	if ( strcmp (argv[argc], "-flip") == 0 ) {
	videoflags ^= SDL_DOUBLEBUF;
	} else
	if ( strcmp (argv[argc], "-fullscreen") == 0 ) {
	videoflags ^= SDL_FULLSCREEN;
	} else
	if ( isdigit(argv[argc][0]) ) {
	_nSprites = atoi (argv[argc]);
	} else {
	fprintf (stderr,
	"Usage: %s [-bpp N] [-hw] [-flip] [-fast] [-fullscreen] [numSprites]\n",
	argv[0]);
	exit (1);
	}
	}

	// The width/height passed to SDL_SetVideoMode should match the size of the NSView
	width = [ _view frame ].size.width;
	height = [ _view frame ].size.height;
	videoflags &= ~SDL_FULLSCREEN; // this only for windowed mode
	if ( [ _window styleMask ] & NSResizableWindowMask ) // enable resizable window
	videoflags \|= SDL_RESIZABLE;
	[ self setupCocoaWindow ];
	[ self setCocoaEnvironmentVariables ];
	_mouse_x = width/2;
	_mouse_y = width/2;

	// Set video mode
	_screen = SDL_SetVideoMode (width, height, video_bpp, videoflags);
	if ( ! _screen ) {
	fprintf (stderr, "Couldn't set %dx%d video mode: %s\n",
	width, height, SDL_GetError());
	exit (2);
	}

	// Print out surface info
	[ self printFlags:videoflags withName:"Requested flags: " ];
	[ self printFlags:_screen->flags withName:"Got flags: " ];

	// Load the sprite
	// The sprite is located in the Resources section of the .app bundle.
	// SDL does not seem aware of bundle paths, so we must construct the path manually.
	NSString* resource_path = [[NSBundle mainBundle] resourcePath];
	NSString* icon_path = [resource_path stringByAppendingString:@"/icon.bmp"];
	if ( [ self loadSpriteFromFile:[icon_path UTF8String] ] < 0 ) {
	exit (1);
	}

	[ self allocSprites ];
	[ self initSprites ];

	background = SDL_MapRGB (_screen->format, 0x00, 0x00, 0x00);

	// Print out information about our surfaces
	printf("Screen is at %d bits per pixel\n", _screen->format->BitsPerPixel);
	if ( (_screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
	printf ("Screen is in video memory\n");
	} else {
	printf ("Screen is in system memory\n");
	}
	if ( (_screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
	printf ("Screen has double-buffering enabled\n");
	}
	if ( (_sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) {
	printf ("Sprite is in video memory\n");
	} else {
	printf ("Sprite is in system memory\n");
	}

	// Run a sample blit to trigger blit acceleration
	{
	SDL_Rect dst;
	dst.x = 0;
	dst.y = 0;
	dst.w = _sprite->w;
	dst.h = _sprite->h;
	SDL_BlitSurface (_sprite, NULL, _screen, &dst);
	SDL_FillRect (_screen, &dst, background);
	}
	if ( (_sprite->flags & SDL_HWACCEL) == SDL_HWACCEL ) {
	printf("Sprite blit uses hardware acceleration\n");
	}
	if ( (_sprite->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
	printf("Sprite blit uses RLE acceleration\n");
	}

	// Loop, blitting sprites and waiting for a keystroke
	frames = 0;
	then = SDL_GetTicks();
	done = 0;
	_sprites_visible = 0;
	while ( !done ) {
	// Check for events
	++frames;
	while ( SDL_PollEvent(&event) ) {
	switch (event.type) {

	case SDL_VIDEORESIZE:

	// Recreate the video mode. Use the same bpp and flags
	// that the original window was created with
	_screen = SDL_SetVideoMode (event.resize.w, event.resize.h,
	video_bpp, videoflags);

	// Clear screen and reinit sprite positions
	SDL_FillRect (_screen, NULL, 0);
	[ self initSprites ];
	break;

	case SDL_MOUSEMOTION:

	_velocities[_nSprites-1].x = 0;
	_velocities[_nSprites-1].y = 0;
	_positions[_nSprites-1].x = event.motion.x - _sprite->w/2;
	_positions[_nSprites-1].y = event.motion.y - _sprite->h/2;
	//printf ("motion: %d %d\n", event.motion.x, event.motion.y);
	break;

	case SDL_MOUSEBUTTONDOWN:

	_velocities[_nSprites-1].x = 0;
	_velocities[_nSprites-1].y = 0;
	_positions[_nSprites-1].x = event.button.x;
	_positions[_nSprites-1].y = event.button.y;
	//printf ("button: %d %d\n", event.button.x, event.button.y);
	break;

	case SDL_KEYDOWN:

	// Escape also quits the app
	if (event.key.keysym.sym == SDLK_ESCAPE)
	done = 1;

	// Control-W warps the cursor
	if (event.key.keysym.sym == SDLK_w &&
	( SDL_GetModState () & KMOD_LCTRL ) )
	SDL_WarpMouse (_screen->w/2, _screen->h/2);

	// Control-G toggles input grabbing
	if (event.key.keysym.sym == SDLK_g &&
	( SDL_GetModState () & KMOD_LCTRL ) )
	if ( SDL_WM_GrabInput (SDL_GRAB_QUERY) == SDL_GRAB_OFF )
	SDL_WM_GrabInput (SDL_GRAB_ON);
	else
	SDL_WM_GrabInput (SDL_GRAB_OFF);
	break;

	case SDL_QUIT:
	done = 1;
	break;
	default:
	break;
	}
	}

	// Draw sprites
	[ self moveSprites:background ];

	// Update fps counter every 100 frames
	if ((frames % 100) == 0) {
	now = SDL_GetTicks ();
	[ _framesPerSecond setFloatValue:((float)frames*1000)/(now-then) ];
	frames = 0;
	then = now;
	}
	}
	[ self freeSprites ];
	SDL_FreeSurface (_sprite);

	SDL_Quit ();
	return 0;
	}

	- (IBAction)changeNumberOfSprites:(id)sender
	{
	[ _numSprites setIntValue:[ sender intValue ] ];
	[ self freeSprites ];
	_nSprites = [ sender intValue ];
	[ self allocSprites ];
	[ self initSprites ];
	SDL_FillRect (_screen, NULL, 0);
	SDL_Flip (_screen);
	}

	- (IBAction)selectUpdateMode:(id)sender
	{
	_doFlip = ![ sender selectedRow ]; // row is 0 or 1
	}

	@end

	int main(int argc, char *argv[])
	{
	// Hand off to instance of MyController
	// This instance is created when SDLMain.nib is loaded,
	// and the global variable is set in [SDLMain applicationDidFinishLaunching:]
	return [ gController run:argc argv:argv ];
	}