Unpacked project archives to get individual file history in subversion
--HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402564
This commit is contained in:
Sam Lantinga
parent
98ce0f8871
commit
316a61731f
199 changed files with 90702 additions and 16 deletions
|
|
@ -0,0 +1,506 @@
|
|||
//
|
||||
// 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 ];
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue