Mercurial > sdl-ios-xcode
view test/testalpha.c @ 563:04dcaf3da918
Massive Quartz input enhancements from Darrell Walisser. His email:
Enclosed is a patch that addresses the following:
--Various minor cleanups.
Removed dead/obsolete code, made some style cleanups
--Mouse Events
Now keep track of what button(s) were pressed so we know when to send
the mouse up event. This fixes the case where the mouse is dragged
outside of the game window and released (in which case we want to send
the mouse up event even though the mouse is outside the game window).
--Input Grabbing
Here is my take on the grabbing situation, which is the basis for the
new implementation.
There are 3 grab states, ungrabbed (UG), visible (VG), and invisible
(IG). Both VG and IG keep the mouse constrained to the window and
produce relative motion events. In VG the cursor is visible (duh), in
IG it is not. In VG, absolute motion events also work.
There are 6 actions that can affect grabbing:
1. Set Fullscreen/Window (F/W). In fullscreen, a visible grab should do
nothing. However, a fullscreen visible grab can be treated just like a
windowed visible grab, which is what I have done to help simplify
things.
2. Cursor hide/show (H/S). If the cursor is hidden when grabbing, the
grab is an invisible grab. If the cursor is visible, the grab should
just constrain the mouse to the window.
3. Input grab/ungrab(G/U). If grabbed, the cursor should be confined to
the window as should the keyboard input. On Mac OS X, the keyboard
input is implicitly grabbed by confining the cursor, except for
command-tab which can switch away from the application. Should the
window come to the foreground if the application is deactivated and
grab input is called? This isn't necessary in this implementation
because the grab state will be asserted upon activation.
Using my notation, these are all the cases that need to be handled
(state + action = new state).
UG+U = UG
UG+G = VG or IG, if cursor is visible or not
UG+H = UG
UG+S = UG
VG+U = UG
VG+G = VG
VG+H = IG
VG+S = VG
IG+U = UG
IG+G = IG
IG+H = IG
IG+S = VG
The cases that result in the same state can be ignored in the code,
which cuts it down to just 5 cases.
Another issue is what happens when the app loses/gains input focus from
deactivate/activate or iconify/deiconify. I think that if input focus
is ever lost (outside of SDL's control), the grab state should be
suspended and the cursor should become visible and active again. When
regained, the cursor should reappear in its original location and/or
grab state. This way, when reactivating the cursor is still in the same
position as before so apps shouldn't get confused when the next motion
event comes in. This is what I've done in this patch.
author | Ryan C. Gordon <icculus@icculus.org> |
---|---|
date | Fri, 27 Dec 2002 20:52:41 +0000 |
parents | 74212992fb08 |
children | 609543e2b3a1 |
line wrap: on
line source
/* Simple program: Fill a colormap with gray and stripe it down the screen, Then move an alpha valued sprite around the screen. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include "SDL.h" #define FRAME_TICKS (1000/30) /* 30 frames/second */ /* Create a "light" -- a yellowish surface with variable alpha */ SDL_Surface *CreateLight(SDL_Surface *screen, int radius) { Uint8 trans, alphamask; int range, addition; int xdist, ydist; Uint16 x, y; Uint16 skip; Uint32 pixel; SDL_Surface *light; #ifdef LIGHT_16BIT Uint16 *buf; /* Create a 16 (4/4/4/4) bpp square with a full 4-bit alpha channel */ /* Note: this isn't any faster than a 32 bit alpha surface */ alphamask = 0x0000000F; light = SDL_CreateRGBSurface(SDL_SWSURFACE, 2*radius, 2*radius, 16, 0x0000F000, 0x00000F00, 0x000000F0, alphamask); #else Uint32 *buf; /* Create a 32 (8/8/8/8) bpp square with a full 8-bit alpha channel */ alphamask = 0x000000FF; light = SDL_CreateRGBSurface(SDL_SWSURFACE, 2*radius, 2*radius, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, alphamask); if ( light == NULL ) { fprintf(stderr, "Couldn't create light: %s\n", SDL_GetError()); return(NULL); } #endif /* Fill with a light yellow-orange color */ skip = light->pitch-(light->w*light->format->BytesPerPixel); #ifdef LIGHT_16BIT buf = (Uint16 *)light->pixels; #else buf = (Uint32 *)light->pixels; #endif /* Get a tranparent pixel value - we'll add alpha later */ pixel = SDL_MapRGBA(light->format, 0xFF, 0xDD, 0x88, 0); for ( y=0; y<light->h; ++y ) { for ( x=0; x<light->w; ++x ) { *buf++ = pixel; } buf += skip; /* Almost always 0, but just in case... */ } /* Calculate alpha values for the surface. */ #ifdef LIGHT_16BIT buf = (Uint16 *)light->pixels; #else buf = (Uint32 *)light->pixels; #endif for ( y=0; y<light->h; ++y ) { for ( x=0; x<light->w; ++x ) { /* Slow distance formula (from center of light) */ xdist = x-(light->w/2); ydist = y-(light->h/2); range = (int)sqrt(xdist*xdist+ydist*ydist); /* Scale distance to range of transparency (0-255) */ if ( range > radius ) { trans = alphamask; } else { /* Increasing transparency with distance */ trans = (Uint8)((range*alphamask)/radius); /* Lights are very transparent */ addition = (alphamask+1)/8; if ( (int)trans+addition > alphamask ) { trans = alphamask; } else { trans += addition; } } /* We set the alpha component as the right N bits */ *buf++ |= (255-trans); } buf += skip; /* Almost always 0, but just in case... */ } /* Enable RLE acceleration of this alpha surface */ SDL_SetAlpha(light, SDL_SRCALPHA|SDL_RLEACCEL, 0); /* We're done! */ return(light); } static Uint32 flashes = 0; static Uint32 flashtime = 0; void FlashLight(SDL_Surface *screen, SDL_Surface *light, int x, int y) { SDL_Rect position; Uint32 ticks1; Uint32 ticks2; /* Easy, center light */ position.x = x-(light->w/2); position.y = y-(light->h/2); position.w = light->w; position.h = light->h; ticks1 = SDL_GetTicks(); SDL_BlitSurface(light, NULL, screen, &position); ticks2 = SDL_GetTicks(); SDL_UpdateRects(screen, 1, &position); ++flashes; /* Update time spend doing alpha blitting */ flashtime += (ticks2-ticks1); } static int sprite_visible = 0; static SDL_Surface *sprite; static SDL_Surface *backing; static SDL_Rect position; static int x_vel, y_vel; static int alpha_vel; int LoadSprite(SDL_Surface *screen, char *file) { SDL_Surface *converted; /* 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, *(Uint8 *)sprite->pixels); } /* Convert sprite to video format */ converted = SDL_DisplayFormat(sprite); SDL_FreeSurface(sprite); if ( converted == NULL ) { fprintf(stderr, "Couldn't convert background: %s\n", SDL_GetError()); return(-1); } sprite = converted; /* Create the background */ backing = SDL_CreateRGBSurface(SDL_SWSURFACE, sprite->w, sprite->h, 8, 0, 0, 0, 0); if ( backing == NULL ) { fprintf(stderr, "Couldn't create background: %s\n", SDL_GetError()); SDL_FreeSurface(sprite); return(-1); } /* Convert background to video format */ converted = SDL_DisplayFormat(backing); SDL_FreeSurface(backing); if ( converted == NULL ) { fprintf(stderr, "Couldn't convert background: %s\n", SDL_GetError()); SDL_FreeSurface(sprite); return(-1); } backing = converted; /* Set the initial position of the sprite */ position.x = (screen->w-sprite->w)/2; position.y = (screen->h-sprite->h)/2; position.w = sprite->w; position.h = sprite->h; x_vel = 0; y_vel = 0; alpha_vel = 1; /* We're ready to roll. :) */ return(0); } void AttractSprite(Uint16 x, Uint16 y) { x_vel = ((int)x-position.x)/10; y_vel = ((int)y-position.y)/10; } void MoveSprite(SDL_Surface *screen, SDL_Surface *light) { SDL_Rect updates[2]; int alpha; /* Erase the sprite if it was visible */ if ( sprite_visible ) { updates[0] = position; SDL_BlitSurface(backing, NULL, screen, &updates[0]); } else { updates[0].x = 0; updates[0].y = 0; updates[0].w = 0; updates[0].h = 0; sprite_visible = 1; } /* Since the sprite is off the screen, we can do other drawing without being overwritten by the saved area behind the sprite. */ if ( light != NULL ) { int x, y; SDL_GetMouseState(&x, &y); FlashLight(screen, light, x, y); } /* Move the sprite, bounce at the wall */ position.x += x_vel; if ( (position.x < 0) || (position.x >= screen->w) ) { x_vel = -x_vel; position.x += x_vel; } position.y += y_vel; if ( (position.y < 0) || (position.y >= screen->h) ) { y_vel = -y_vel; position.y += y_vel; } /* Update transparency (fade in and out) */ alpha = sprite->format->alpha; if ( (alpha+alpha_vel) < 0 ) { alpha_vel = -alpha_vel; } else if ( (alpha+alpha_vel) > 255 ) { alpha_vel = -alpha_vel; } SDL_SetAlpha(sprite, SDL_SRCALPHA, (Uint8)(alpha+alpha_vel)); /* Save the area behind the sprite */ updates[1] = position; SDL_BlitSurface(screen, &updates[1], backing, NULL); /* Blit the sprite onto the screen */ updates[1] = position; SDL_BlitSurface(sprite, NULL, screen, &updates[1]); /* Make it so! */ SDL_UpdateRects(screen, 2, updates); } void WarpSprite(SDL_Surface *screen, int x, int y) { SDL_Rect updates[2]; /* Erase, move, Draw, update */ updates[0] = position; SDL_BlitSurface(backing, NULL, screen, &updates[0]); position.x = x-sprite->w/2; /* Center about X */ position.y = y-sprite->h/2; /* Center about Y */ updates[1] = position; SDL_BlitSurface(screen, &updates[1], backing, NULL); updates[1] = position; SDL_BlitSurface(sprite, NULL, screen, &updates[1]); SDL_UpdateRects(screen, 2, updates); } int main(int argc, char *argv[]) { const SDL_VideoInfo *info; SDL_Surface *screen; Uint8 video_bpp; Uint32 videoflags; Uint8 *buffer; int i, done; SDL_Event event; SDL_Surface *light; int mouse_pressed; Uint32 ticks, lastticks; /* Initialize SDL */ if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); exit(1); } atexit(SDL_Quit); /* Alpha blending doesn't work well at 8-bit color */ info = SDL_GetVideoInfo(); if ( info->vfmt->BitsPerPixel > 8 ) { video_bpp = info->vfmt->BitsPerPixel; } else { video_bpp = 16; } videoflags = SDL_SWSURFACE; while ( argc > 1 ) { --argc; if ( strcmp(argv[argc-1], "-bpp") == 0 ) { video_bpp = atoi(argv[argc]); --argc; } else if ( strcmp(argv[argc], "-hw") == 0 ) { videoflags |= SDL_HWSURFACE; } else if ( strcmp(argv[argc], "-warp") == 0 ) { videoflags |= SDL_HWPALETTE; } else if ( strcmp(argv[argc], "-fullscreen") == 0 ) { videoflags |= SDL_FULLSCREEN; } else { fprintf(stderr, "Usage: %s [-bpp N] [-warp] [-hw] [-fullscreen]\n", argv[0]); exit(1); } } /* Set 640x480 video mode */ if ( (screen=SDL_SetVideoMode(640,480,video_bpp,videoflags)) == NULL ) { fprintf(stderr, "Couldn't set 640x480x%d video mode: %s\n", video_bpp, SDL_GetError()); exit(2); } /* Set the surface pixels and refresh! */ if ( SDL_LockSurface(screen) < 0 ) { fprintf(stderr, "Couldn't lock the display surface: %s\n", SDL_GetError()); exit(2); } buffer=(Uint8 *)screen->pixels; for ( i=0; i<screen->h; ++i ) { memset(buffer,(i*255)/screen->h, screen->pitch); buffer += screen->pitch; } SDL_UnlockSurface(screen); SDL_UpdateRect(screen, 0, 0, 0, 0); /* Create the light */ light = CreateLight(screen, 82); if ( light == NULL ) { exit(1); } /* Load the sprite */ if ( LoadSprite(screen, "icon.bmp") < 0 ) { SDL_FreeSurface(light); exit(1); } /* Set a clipping rectangle to clip the outside edge of the screen */ { SDL_Rect clip; clip.x = 32; clip.y = 32; clip.w = screen->w-(2*32); clip.h = screen->h-(2*32); SDL_SetClipRect(screen, &clip); } /* Wait for a keystroke */ lastticks = SDL_GetTicks(); done = 0; mouse_pressed = 0; while ( !done ) { /* Update the frame -- move the sprite */ if ( mouse_pressed ) { MoveSprite(screen, light); mouse_pressed = 0; } else { MoveSprite(screen, NULL); } /* Slow down the loop to 30 frames/second */ ticks = SDL_GetTicks(); if ( (ticks-lastticks) < FRAME_TICKS ) { #ifdef CHECK_SLEEP_GRANULARITY fprintf(stderr, "Sleeping %d ticks\n", FRAME_TICKS-(ticks-lastticks)); #endif SDL_Delay(FRAME_TICKS-(ticks-lastticks)); #ifdef CHECK_SLEEP_GRANULARITY fprintf(stderr, "Slept %d ticks\n", (SDL_GetTicks()-ticks)); #endif } lastticks = ticks; /* Check for events */ while ( SDL_PollEvent(&event) ) { switch (event.type) { /* Attract sprite while mouse is held down */ case SDL_MOUSEMOTION: if (event.motion.state != 0) { AttractSprite(event.motion.x, event.motion.y); mouse_pressed = 1; } break; case SDL_MOUSEBUTTONDOWN: if ( event.button.button == 1 ) { AttractSprite(event.button.x, event.button.y); mouse_pressed = 1; } else { SDL_Rect area; area.x = event.button.x-16; area.y = event.button.y-16; area.w = 32; area.h = 32; SDL_FillRect(screen, &area, 0); SDL_UpdateRects(screen,1,&area); } break; case SDL_KEYDOWN: /* Any keypress quits the app... */ case SDL_QUIT: done = 1; break; default: break; } } } SDL_FreeSurface(light); SDL_FreeSurface(sprite); SDL_FreeSurface(backing); /* Print out some timing information */ if ( flashes > 0 ) { printf("%d alpha blits, ~%4.4f ms per blit\n", flashes, (float)flashtime/flashes); } return(0); }