Mercurial > sdl-ios-xcode

comparison include/SDL_video.h @ 0:74212992fb08

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author Sam Lantinga <slouken@lokigames.com>
date Thu, 26 Apr 2001 16:45:43 +0000
parents
children 45b1c4303f87
comparison
equal deleted inserted replaced
-1:000000000000 0:74212992fb08
1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this library; if not, write to the Free
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19 Sam Lantinga
20 slouken@devolution.com
21 */
22
23 #ifdef SAVE_RCSID
24 static char rcsid =
25 "@(#) $Id$";
26 #endif
27
28 /* Header file for access to the SDL raw framebuffer window */
29
30 #ifndef _SDL_video_h
31 #define _SDL_video_h
32
33 #include <stdio.h>
34
35 #include "SDL_types.h"
36 #include "SDL_mutex.h"
37 #include "SDL_rwops.h"
38
39 #include "begin_code.h"
40 /* Set up for C function definitions, even when using C++ */
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
44
45 /* Transparency definitions: These define alpha as the opacity of a surface */
46 #define SDL_ALPHA_OPAQUE 255
47 #define SDL_ALPHA_TRANSPARENT 0
48
49 /* Useful data types */
50 typedef struct {
51 Sint16 x, y;
52 Uint16 w, h;
53 } SDL_Rect;
54
55 typedef struct {
56 Uint8 r;
57 Uint8 g;
58 Uint8 b;
59 Uint8 unused;
60 } SDL_Color;
61
62 typedef struct {
63 int ncolors;
64 SDL_Color *colors;
65 } SDL_Palette;
66
67 /* Everything in the pixel format structure is read-only */
68 typedef struct SDL_PixelFormat {
69 SDL_Palette *palette;
70 Uint8 BitsPerPixel;
71 Uint8 BytesPerPixel;
72 Uint8 Rloss;
73 Uint8 Gloss;
74 Uint8 Bloss;
75 Uint8 Aloss;
76 Uint8 Rshift;
77 Uint8 Gshift;
78 Uint8 Bshift;
79 Uint8 Ashift;
80 Uint32 Rmask;
81 Uint32 Gmask;
82 Uint32 Bmask;
83 Uint32 Amask;
84
85 /* RGB color key information */
86 Uint32 colorkey;
87 /* Alpha value information (per-surface alpha) */
88 Uint8 alpha;
89 } SDL_PixelFormat;
90
91 /* typedef for private surface blitting functions */
92 struct SDL_Surface;
93 typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
94 struct SDL_Surface *dst, SDL_Rect *dstrect);
95
96 /* This structure should be treated as read-only, except for 'pixels',
97 which, if not NULL, contains the raw pixel data for the surface.
98 */
99 typedef struct SDL_Surface {
100 Uint32 flags; /* Read-only */
101 SDL_PixelFormat *format; /* Read-only */
102 int w, h; /* Read-only */
103 Uint16 pitch; /* Read-only */
104 void *pixels; /* Read-write */
105 int offset; /* Private */
106
107 /* Hardware-specific surface info */
108 struct private_hwdata *hwdata;
109
110 /* clipping information */
111 SDL_Rect clip_rect; /* Read-only */
112 Uint32 unused1; /* for binary compatibility */
113
114 /* Allow recursive locks */
115 Uint32 locked; /* Private */
116
117 /* info for fast blit mapping to other surfaces */
118 struct SDL_BlitMap *map; /* Private */
119
120 /* format version, bumped at every change to invalidate blit maps */
121 unsigned int format_version; /* Private */
122
123 /* Reference count -- used when freeing surface */
124 int refcount; /* Read-mostly */
125 } SDL_Surface;
126
127 /* These are the currently supported flags for the SDL_surface */
128 /* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
129 #define SDL_SWSURFACE 0x00000000 /* Surface is in system memory */
130 #define SDL_HWSURFACE 0x00000001 /* Surface is in video memory */
131 #define SDL_ASYNCBLIT 0x00000004 /* Use asynchronous blits if possible */
132 /* Available for SDL_SetVideoMode() */
133 #define SDL_ANYFORMAT 0x10000000 /* Allow any video depth/pixel-format */
134 #define SDL_HWPALETTE 0x20000000 /* Surface has exclusive palette */
135 #define SDL_DOUBLEBUF 0x40000000 /* Set up double-buffered video mode */
136 #define SDL_FULLSCREEN 0x80000000 /* Surface is a full screen display */
137 #define SDL_OPENGL 0x00000002 /* Create an OpenGL rendering context */
138 #define SDL_OPENGLBLIT 0x0000000A /* Create an OpenGL rendering context and use it for blitting */
139 #define SDL_RESIZABLE 0x00000010 /* This video mode may be resized */
140 #define SDL_NOFRAME 0x00000020 /* No window caption or edge frame */
141 /* Used internally (read-only) */
142 #define SDL_HWACCEL 0x00000100 /* Blit uses hardware acceleration */
143 #define SDL_SRCCOLORKEY 0x00001000 /* Blit uses a source color key */
144 #define SDL_RLEACCELOK 0x00002000 /* Private flag */
145 #define SDL_RLEACCEL 0x00004000 /* Surface is RLE encoded */
146 #define SDL_SRCALPHA 0x00010000 /* Blit uses source alpha blending */
147 #define SDL_PREALLOC 0x01000000 /* Surface uses preallocated memory */
148
149 /* Evaluates to true if the surface needs to be locked before access */
150 #define SDL_MUSTLOCK(surface) \
151 (surface->offset || \
152 ((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0))
153
154
155 /* Useful for determining the video hardware capabilities */
156 typedef struct {
157 Uint32 hw_available :1; /* Flag: Can you create hardware surfaces? */
158 Uint32 wm_available :1; /* Flag: Can you talk to a window manager? */
159 Uint32 UnusedBits1 :6;
160 Uint32 UnusedBits2 :1;
161 Uint32 blit_hw :1; /* Flag: Accelerated blits HW --> HW */
162 Uint32 blit_hw_CC :1; /* Flag: Accelerated blits with Colorkey */
163 Uint32 blit_hw_A :1; /* Flag: Accelerated blits with Alpha */
164 Uint32 blit_sw :1; /* Flag: Accelerated blits SW --> HW */
165 Uint32 blit_sw_CC :1; /* Flag: Accelerated blits with Colorkey */
166 Uint32 blit_sw_A :1; /* Flag: Accelerated blits with Alpha */
167 Uint32 blit_fill :1; /* Flag: Accelerated color fill */
168 Uint32 UnusedBits3 :16;
169 Uint32 video_mem; /* The total amount of video memory (in K) */
170 SDL_PixelFormat *vfmt; /* Value: The format of the video surface */
171 } SDL_VideoInfo;
172
173
174 /* The most common video overlay formats.
175 For an explanation of these pixel formats, see:
176 http://www.webartz.com/fourcc/indexyuv.htm
177
178 For information on the relationship between color spaces, see:
179 http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
180 */
181 #define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U (3 planes) */
182 #define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V (3 planes) */
183 #define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
184 #define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
185 #define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 (1 plane) */
186
187 /* The YUV hardware video overlay */
188 typedef struct SDL_Overlay {
189 Uint32 format; /* Read-only */
190 int w, h; /* Read-only */
191 int planes; /* Read-only */
192 Uint16 *pitches; /* Read-only */
193 Uint8 **pixels; /* Read-write */
194
195 /* Hardware-specific surface info */
196 struct private_yuvhwfuncs *hwfuncs;
197 struct private_yuvhwdata *hwdata;
198
199 /* Special flags */
200 Uint32 hw_overlay :1; /* Flag: This overlay hardware accelerated? */
201 Uint32 UnusedBits :31;
202 } SDL_Overlay;
203
204
205 /* Public enumeration for setting the OpenGL window attributes. */
206 typedef enum {
207 SDL_GL_RED_SIZE,
208 SDL_GL_GREEN_SIZE,
209 SDL_GL_BLUE_SIZE,
210 SDL_GL_ALPHA_SIZE,
211 SDL_GL_BUFFER_SIZE,
212 SDL_GL_DOUBLEBUFFER,
213 SDL_GL_DEPTH_SIZE,
214 SDL_GL_STENCIL_SIZE,
215 SDL_GL_ACCUM_RED_SIZE,
216 SDL_GL_ACCUM_GREEN_SIZE,
217 SDL_GL_ACCUM_BLUE_SIZE,
218 SDL_GL_ACCUM_ALPHA_SIZE
219 } SDL_GLattr;
220
221 /* flags for SDL_SetPalette() */
222 #define SDL_LOGPAL 0x01
223 #define SDL_PHYSPAL 0x02
224
225 /* Function prototypes */
226
227 /* These functions are used internally, and should not be used unless you
228 * have a specific need to specify the video driver you want to use.
229 * You should normally use SDL_Init() or SDL_InitSubSystem().
230 *
231 * SDL_VideoInit() initializes the video subsystem -- sets up a connection
232 * to the window manager, etc, and determines the current video mode and
233 * pixel format, but does not initialize a window or graphics mode.
234 * Note that event handling is activated by this routine.
235 *
236 * If you use both sound and video in your application, you need to call
237 * SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
238 * you won't be able to set full-screen display modes.
239 */
240 extern DECLSPEC int SDL_VideoInit(const char *driver_name, Uint32 flags);
241 extern DECLSPEC void SDL_VideoQuit(void);
242
243 /* This function fills the given character buffer with the name of the
244 * video driver, and returns a pointer to it if the video driver has
245 * been initialized. It returns NULL if no driver has been initialized.
246 */
247 extern DECLSPEC char *SDL_VideoDriverName(char *namebuf, int maxlen);
248
249 /*
250 * This function returns a pointer to the current display surface.
251 * If SDL is doing format conversion on the display surface, this
252 * function returns the publicly visible surface, not the real video
253 * surface.
254 */
255 extern DECLSPEC SDL_Surface * SDL_GetVideoSurface(void);
256
257 /*
258 * This function returns a read-only pointer to information about the
259 * video hardware. If this is called before SDL_SetVideoMode(), the 'vfmt'
260 * member of the returned structure will contain the pixel format of the
261 * "best" video mode.
262 */
263 extern DECLSPEC const SDL_VideoInfo * SDL_GetVideoInfo(void);
264
265 /*
266 * Check to see if a particular video mode is supported.
267 * It returns 0 if the requested mode is not supported under any bit depth,
268 * or returns the bits-per-pixel of the closest available mode with the
269 * given width and height. If this bits-per-pixel is different from the
270 * one used when setting the video mode, SDL_SetVideoMode() will succeed,
271 * but will emulate the requested bits-per-pixel with a shadow surface.
272 *
273 * The arguments to SDL_VideoModeOK() are the same ones you would pass to
274 * SDL_SetVideoMode()
275 */
276 extern DECLSPEC int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
277
278 /*
279 * Return a pointer to an array of available screen dimensions for the
280 * given format and video flags, sorted largest to smallest. Returns
281 * NULL if there are no dimensions available for a particular format,
282 * or (SDL_Rect **)-1 if any dimension is okay for the given format.
283 *
284 * If 'format' is NULL, the mode list will be for the format given
285 * by SDL_GetVideoInfo()->vfmt
286 */
287 extern DECLSPEC SDL_Rect ** SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
288
289 /*
290 * Set up a video mode with the specified width, height and bits-per-pixel.
291 *
292 * If 'bpp' is 0, it is treated as the current display bits per pixel.
293 *
294 * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
295 * requested bits-per-pixel, but will return whatever video pixel format is
296 * available. The default is to emulate the requested pixel format if it
297 * is not natively available.
298 *
299 * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
300 * video memory, if possible, and you may have to call SDL_LockSurface()
301 * in order to access the raw framebuffer. Otherwise, the video surface
302 * will be created in system memory.
303 *
304 * If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
305 * updates asynchronously, but you must always lock before accessing pixels.
306 * SDL will wait for updates to complete before returning from the lock.
307 *
308 * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
309 * that the colors set by SDL_SetColors() will be the colors you get.
310 * Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
311 * of the colors exactly the way they are requested, and you should look
312 * at the video surface structure to determine the actual palette.
313 * If SDL cannot guarantee that the colors you request can be set,
314 * i.e. if the colormap is shared, then the video surface may be created
315 * under emulation in system memory, overriding the SDL_HWSURFACE flag.
316 *
317 * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
318 * a fullscreen video mode. The default is to create a windowed mode
319 * if the current graphics system has a window manager.
320 * If the SDL library is able to set a fullscreen video mode, this flag
321 * will be set in the surface that is returned.
322 *
323 * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
324 * two surfaces in video memory and swap between them when you call
325 * SDL_Flip(). This is usually slower than the normal single-buffering
326 * scheme, but prevents "tearing" artifacts caused by modifying video
327 * memory while the monitor is refreshing. It should only be used by
328 * applications that redraw the entire screen on every update.
329 *
330 * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
331 * window manager, if any, to resize the window at runtime. When this
332 * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
333 * and you must respond to the event by re-calling SDL_SetVideoMode()
334 * with the requested size (or another size that suits the application).
335 *
336 * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
337 * without any title bar or frame decoration. Fullscreen video modes have
338 * this flag set automatically.
339 *
340 * This function returns the video framebuffer surface, or NULL if it fails.
341 *
342 * If you rely on functionality provided by certain video flags, check the
343 * flags of the returned surface to make sure that functionality is available.
344 * SDL will fall back to reduced functionality if the exact flags you wanted
345 * are not available.
346 */
347 extern DECLSPEC SDL_Surface *SDL_SetVideoMode
348 (int width, int height, int bpp, Uint32 flags);
349
350 /*
351 * Makes sure the given list of rectangles is updated on the given screen.
352 * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
353 * screen.
354 * These functions should not be called while 'screen' is locked.
355 */
356 extern DECLSPEC void SDL_UpdateRects
357 (SDL_Surface *screen, int numrects, SDL_Rect *rects);
358 extern DECLSPEC void SDL_UpdateRect
359 (SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
360
361 /*
362 * On hardware that supports double-buffering, this function sets up a flip
363 * and returns. The hardware will wait for vertical retrace, and then swap
364 * video buffers before the next video surface blit or lock will return.
365 * On hardware that doesn not support double-buffering, this is equivalent
366 * to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
367 * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
368 * setting the video mode for this function to perform hardware flipping.
369 * This function returns 0 if successful, or -1 if there was an error.
370 */
371 extern DECLSPEC int SDL_Flip(SDL_Surface *screen);
372
373 /*
374 * Set the gamma correction for each of the color channels.
375 * The gamma values range (approximately) between 0.1 and 10.0
376 *
377 * If this function isn't supported directly by the hardware, it will
378 * be emulated using gamma ramps, if available. If successful, this
379 * function returns 0, otherwise it returns -1.
380 */
381 extern DECLSPEC int SDL_SetGamma(float red, float green, float blue);
382
383 /*
384 * Set the gamma translation table for the red, green, and blue channels
385 * of the video hardware. Each table is an array of 256 16-bit quantities,
386 * representing a mapping between the input and output for that channel.
387 * The input is the index into the array, and the output is the 16-bit
388 * gamma value at that index, scaled to the output color precision.
389 *
390 * You may pass NULL for any of the channels to leave it unchanged.
391 * If the call succeeds, it will return 0. If the display driver or
392 * hardware does not support gamma translation, or otherwise fails,
393 * this function will return -1.
394 */
395 extern DECLSPEC int SDL_SetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
396
397 /*
398 * Retrieve the current values of the gamma translation tables.
399 *
400 * You must pass in valid pointers to arrays of 256 16-bit quantities.
401 * Any of the pointers may be NULL to ignore that channel.
402 * If the call succeeds, it will return 0. If the display driver or
403 * hardware does not support gamma translation, or otherwise fails,
404 * this function will return -1.
405 */
406 extern DECLSPEC int SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
407
408 /*
409 * Sets a portion of the colormap for the given 8-bit surface. If 'surface'
410 * is not a palettized surface, this function does nothing, returning 0.
411 * If all of the colors were set as passed to SDL_SetColors(), it will
412 * return 1. If not all the color entries were set exactly as given,
413 * it will return 0, and you should look at the surface palette to
414 * determine the actual color palette.
415 *
416 * When 'surface' is the surface associated with the current display, the
417 * display colormap will be updated with the requested colors. If
418 * SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
419 * will always return 1, and the palette is guaranteed to be set the way
420 * you desire, even if the window colormap has to be warped or run under
421 * emulation.
422 */
423 extern DECLSPEC int SDL_SetColors(SDL_Surface *surface,
424 SDL_Color *colors, int firstcolor, int ncolors);
425
426 /*
427 * Sets a portion of the colormap for a given 8-bit surface.
428 * 'flags' is one or both of:
429 * SDL_LOGPAL -- set logical palette, which controls how blits are mapped
430 * to/from the surface,
431 * SDL_PHYSPAL -- set physical palette, which controls how pixels look on
432 * the screen
433 * Only screens have physical palettes. Separate change of physical/logical
434 * palettes is only possible if the screen has SDL_HWPALETTE set.
435 *
436 * The return value is 1 if all colours could be set as requested, and 0
437 * otherwise.
438 *
439 * SDL_SetColors() is equivalent to calling this function with
440 * flags = (SDL_LOGPAL|SDL_PHYSPAL).
441 */
442 extern DECLSPEC int SDL_SetPalette(SDL_Surface *surface, int flags,
443 SDL_Color *colors, int firstcolor,
444 int ncolors);
445
446 /*
447 * Maps an RGB triple to an opaque pixel value for a given pixel format
448 */
449 extern DECLSPEC Uint32 SDL_MapRGB
450 (SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
451
452 /*
453 * Maps an RGBA quadruple to a pixel value for a given pixel format
454 */
455 extern DECLSPEC Uint32 SDL_MapRGBA(SDL_PixelFormat *format,
456 Uint8 r, Uint8 g, Uint8 b, Uint8 a);
457
458 /*
459 * Maps a pixel value into the RGB components for a given pixel format
460 */
461 extern DECLSPEC void SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt,
462 Uint8 *r, Uint8 *g, Uint8 *b);
463
464 /*
465 * Maps a pixel value into the RGBA components for a given pixel format
466 */
467 extern DECLSPEC void SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt,
468 Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
469
470 /*
471 * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
472 * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
473 * If the depth is greater than 8 bits, the pixel format is set using the
474 * flags '[RGB]mask'.
475 * If the function runs out of memory, it will return NULL.
476 *
477 * The 'flags' tell what kind of surface to create.
478 * SDL_SWSURFACE means that the surface should be created in system memory.
479 * SDL_HWSURFACE means that the surface should be created in video memory,
480 * with the same format as the display surface. This is useful for surfaces
481 * that will not change much, to take advantage of hardware acceleration
482 * when being blitted to the display surface.
483 * SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
484 * this surface, but you must always lock it before accessing the pixels.
485 * SDL will wait for current blits to finish before returning from the lock.
486 * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
487 * If the hardware supports acceleration of colorkey blits between
488 * two surfaces in video memory, SDL will try to place the surface in
489 * video memory. If this isn't possible or if there is no hardware
490 * acceleration available, the surface will be placed in system memory.
491 * SDL_SRCALPHA means that the surface will be used for alpha blits and
492 * if the hardware supports hardware acceleration of alpha blits between
493 * two surfaces in video memory, to place the surface in video memory
494 * if possible, otherwise it will be placed in system memory.
495 * If the surface is created in video memory, blits will be _much_ faster,
496 * but the surface format must be identical to the video surface format,
497 * and the only way to access the pixels member of the surface is to use
498 * the SDL_LockSurface() and SDL_UnlockSurface() calls.
499 * If the requested surface actually resides in video memory, SDL_HWSURFACE
500 * will be set in the flags member of the returned surface. If for some
501 * reason the surface could not be placed in video memory, it will not have
502 * the SDL_HWSURFACE flag set, and will be created in system memory instead.
503 */
504 #define SDL_AllocSurface SDL_CreateRGBSurface
505 extern DECLSPEC SDL_Surface *SDL_CreateRGBSurface
506 (Uint32 flags, int width, int height, int depth,
507 Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
508 extern DECLSPEC SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels,
509 int width, int height, int depth, int pitch,
510 Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
511 extern DECLSPEC void SDL_FreeSurface(SDL_Surface *surface);
512
513 /*
514 * SDL_LockSurface() sets up a surface for directly accessing the pixels.
515 * Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
516 * to and read from 'surface->pixels', using the pixel format stored in
517 * 'surface->format'. Once you are done accessing the surface, you should
518 * use SDL_UnlockSurface() to release it.
519 *
520 * Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates
521 * to 0, then you can read and write to the surface at any time, and the
522 * pixel format of the surface will not change. In particular, if the
523 * SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
524 * will not need to lock the display surface before accessing it.
525 *
526 * No operating system or library calls should be made between lock/unlock
527 * pairs, as critical system locks may be held during this time.
528 *
529 * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
530 */
531 extern DECLSPEC int SDL_LockSurface(SDL_Surface *surface);
532 extern DECLSPEC void SDL_UnlockSurface(SDL_Surface *surface);
533
534 /*
535 * Load a surface from a seekable SDL data source (memory or file.)
536 * If 'freesrc' is non-zero, the source will be closed after being read.
537 * Returns the new surface, or NULL if there was an error.
538 * The new surface should be freed with SDL_FreeSurface().
539 */
540 extern DECLSPEC SDL_Surface * SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
541
542 /* Convenience macro -- load a surface from a file */
543 #define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
544
545 /*
546 * Save a surface to a seekable SDL data source (memory or file.)
547 * If 'freedst' is non-zero, the source will be closed after being written.
548 * Returns 0 if successful or -1 if there was an error.
549 */
550 extern DECLSPEC int SDL_SaveBMP_RW
551 (SDL_Surface *surface, SDL_RWops *dst, int freedst);
552
553 /* Convenience macro -- save a surface to a file */
554 #define SDL_SaveBMP(surface, file) \
555 SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
556
557 /*
558 * Sets the color key (transparent pixel) in a blittable surface.
559 * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
560 * 'key' will be the transparent pixel in the source image of a blit.
561 * SDL_RLEACCEL requests RLE acceleration for the surface if present,
562 * and removes RLE acceleration if absent.
563 * If 'flag' is 0, this function clears any current color key.
564 * This function returns 0, or -1 if there was an error.
565 */
566 extern DECLSPEC int SDL_SetColorKey
567 (SDL_Surface *surface, Uint32 flag, Uint32 key);
568
569 /*
570 * This function sets the alpha value for the entire surface, as opposed to
571 * using the alpha component of each pixel. This value measures the range
572 * of transparency of the surface, 0 being completely transparent to 255
573 * being completely opaque. An 'alpha' value of 255 causes blits to be
574 * opaque, the source pixels copied to the destination (the default). Note
575 * that per-surface alpha can be combined with colorkey transparency.
576 *
577 * If 'flag' is 0, alpha blending is disabled for the surface.
578 * If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
579 * OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
580 * surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
581 */
582 extern DECLSPEC int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
583
584 /*
585 * Sets the clipping rectangle for the destination surface in a blit.
586 *
587 * If the clip rectangle is NULL, clipping will be disabled.
588 * If the clip rectangle doesn't intersect the surface, the function will
589 * return SDL_FALSE and blits will be completely clipped. Otherwise the
590 * function returns SDL_TRUE and blits to the surface will be clipped to
591 * the intersection of the surface area and the clipping rectangle.
592 *
593 * Note that blits are automatically clipped to the edges of the source
594 * and destination surfaces.
595 */
596 extern DECLSPEC SDL_bool SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect);
597
598 /*
599 * Gets the clipping rectangle for the destination surface in a blit.
600 * 'rect' must be a pointer to a valid rectangle which will be filled
601 * with the correct values.
602 */
603 extern DECLSPEC void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
604
605 /*
606 * Creates a new surface of the specified format, and then copies and maps
607 * the given surface to it so the blit of the converted surface will be as
608 * fast as possible. If this function fails, it returns NULL.
609 *
610 * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
611 * semantics. You can also pass SDL_RLEACCEL in the flags parameter and
612 * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
613 * surface.
614 *
615 * This function is used internally by SDL_DisplayFormat().
616 */
617 extern DECLSPEC SDL_Surface *SDL_ConvertSurface
618 (SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
619
620 /*
621 * This performs a fast blit from the source surface to the destination
622 * surface. It assumes that the source and destination rectangles are
623 * the same size. If either 'srcrect' or 'dstrect' are NULL, the entire
624 * surface (src or dst) is copied. The final blit rectangles are saved
625 * in 'srcrect' and 'dstrect' after all clipping is performed.
626 * If the blit is successful, it returns 0, otherwise it returns -1.
627 *
628 * The blit function should not be called on a locked surface.
629 *
630 * The blit semantics for surfaces with and without alpha and colorkey
631 * are defined as follows:
632 *
633 * RGBA->RGB:
634 * SDL_SRCALPHA set:
635 * alpha-blend (using alpha-channel).
636 * SDL_SRCCOLORKEY ignored.
637 * SDL_SRCALPHA not set:
638 * copy RGB.
639 * if SDL_SRCCOLORKEY set, only copy the pixels matching the
640 * RGB values of the source colour key, ignoring alpha in the
641 * comparison.
642 *
643 * RGB->RGBA:
644 * SDL_SRCALPHA set:
645 * alpha-blend (using the source per-surface alpha value);
646 * set destination alpha to opaque.
647 * SDL_SRCALPHA not set:
648 * copy RGB, set destination alpha to opaque.
649 * both:
650 * if SDL_SRCCOLORKEY set, only copy the pixels matching the
651 * source colour key.
652 *
653 * RGBA->RGBA:
654 * SDL_SRCALPHA set:
655 * alpha-blend (using the source alpha channel) the RGB values;
656 * leave destination alpha untouched. [Note: is this correct?]
657 * SDL_SRCCOLORKEY ignored.
658 * SDL_SRCALPHA not set:
659 * copy all of RGBA to the destination.
660 * if SDL_SRCCOLORKEY set, only copy the pixels matching the
661 * RGB values of the source colour key, ignoring alpha in the
662 * comparison.
663 *
664 * RGB->RGB:
665 * SDL_SRCALPHA set:
666 * alpha-blend (using the source per-surface alpha value).
667 * SDL_SRCALPHA not set:
668 * copy RGB.
669 * both:
670 * if SDL_SRCCOLORKEY set, only copy the pixels matching the
671 * source colour key.
672 *
673 * If either of the surfaces were in video memory, and the blit returns -2,
674 * the video memory was lost, so it should be reloaded with artwork and
675 * re-blitted:
676 while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
677 while ( SDL_LockSurface(image) < 0 )
678 Sleep(10);
679 -- Write image pixels to image->pixels --
680 SDL_UnlockSurface(image);
681 }
682 * This happens under DirectX 5.0 when the system switches away from your
683 * fullscreen application. The lock will also fail until you have access
684 * to the video memory again.
685 */
686 /* You should call SDL_BlitSurface() unless you know exactly how SDL
687 blitting works internally and how to use the other blit functions.
688 */
689 #define SDL_BlitSurface SDL_UpperBlit
690
691 /* This is the public blit function, SDL_BlitSurface(), and it performs
692 rectangle validation and clipping before passing it to SDL_LowerBlit()
693 */
694 extern DECLSPEC int SDL_UpperBlit
695 (SDL_Surface *src, SDL_Rect *srcrect,
696 SDL_Surface *dst, SDL_Rect *dstrect);
697 /* This is a semi-private blit function and it performs low-level surface
698 blitting only.
699 */
700 extern DECLSPEC int SDL_LowerBlit
701 (SDL_Surface *src, SDL_Rect *srcrect,
702 SDL_Surface *dst, SDL_Rect *dstrect);
703
704 /*
705 * This function performs a fast fill of the given rectangle with 'color'
706 * The given rectangle is clipped to the destination surface clip area
707 * and the final fill rectangle is saved in the passed in pointer.
708 * If 'dstrect' is NULL, the whole surface will be filled with 'color'
709 * The color should be a pixel of the format used by the surface, and
710 * can be generated by the SDL_MapRGB() function.
711 * This function returns 0 on success, or -1 on error.
712 */
713 extern DECLSPEC int SDL_FillRect
714 (SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
715
716 /*
717 * This function takes a surface and copies it to a new surface of the
718 * pixel format and colors of the video framebuffer, suitable for fast
719 * blitting onto the display surface. It calls SDL_ConvertSurface()
720 *
721 * If you want to take advantage of hardware colorkey or alpha blit
722 * acceleration, you should set the colorkey and alpha value before
723 * calling this function.
724 *
725 * If the conversion fails or runs out of memory, it returns NULL
726 */
727 extern DECLSPEC SDL_Surface * SDL_DisplayFormat(SDL_Surface *surface);
728
729 /*
730 * This function takes a surface and copies it to a new surface of the
731 * pixel format and colors of the video framebuffer (if possible),
732 * suitable for fast alpha blitting onto the display surface.
733 * The new surface will always have an alpha channel.
734 *
735 * If you want to take advantage of hardware colorkey or alpha blit
736 * acceleration, you should set the colorkey and alpha value before
737 * calling this function.
738 *
739 * If the conversion fails or runs out of memory, it returns NULL
740 */
741 extern DECLSPEC SDL_Surface * SDL_DisplayFormatAlpha(SDL_Surface *surface);
742
743
744 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
745 /* YUV video surface overlay functions */
746 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
747
748 /* This function creates a video output overlay
749 Calling the returned surface an overlay is something of a misnomer because
750 the contents of the display surface underneath the area where the overlay
751 is shown is undefined - it may be overwritten with the converted YUV data.
752 */
753 extern DECLSPEC SDL_Overlay *SDL_CreateYUVOverlay(int width, int height,
754 Uint32 format, SDL_Surface *display);
755
756 /* Lock an overlay for direct access, and unlock it when you are done */
757 extern DECLSPEC int SDL_LockYUVOverlay(SDL_Overlay *overlay);
758 extern DECLSPEC void SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
759
760 /* Blit a video overlay to the display surface.
761 The contents of the video surface underneath the blit destination are
762 not defined.
763 The width and height of the destination rectangle may be different from
764 that of the overlay, but currently only 2x scaling is supported.
765 */
766 extern DECLSPEC int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
767
768 /* Free a video overlay */
769 extern DECLSPEC void SDL_FreeYUVOverlay(SDL_Overlay *overlay);
770
771
772 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
773 /* OpenGL support functions. */
774 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
775
776 /*
777 * Dynamically load a GL driver, if SDL is built with dynamic GL.
778 *
779 * SDL links normally with the OpenGL library on your system by default,
780 * but you can compile it to dynamically load the GL driver at runtime.
781 * If you do this, you need to retrieve all of the GL functions used in
782 * your program from the dynamic library using SDL_GL_GetProcAddress().
783 *
784 * This is disabled in default builds of SDL.
785 */
786 extern DECLSPEC int SDL_GL_LoadLibrary(const char *path);
787
788 /*
789 * Get the address of a GL function (for extension functions)
790 */
791 extern DECLSPEC void *SDL_GL_GetProcAddress(const char* proc);
792
793 /*
794 * Set an attribute of the OpenGL subsystem before intialization.
795 */
796 extern DECLSPEC int SDL_GL_SetAttribute(SDL_GLattr attr, int value);
797
798 /*
799 * Get an attribute of the OpenGL subsystem from the windowing
800 * interface, such as glX. This is of course different from getting
801 * the values from SDL's internal OpenGL subsystem, which only
802 * stores the values you request before initialization.
803 *
804 * Developers should track the values they pass into SDL_GL_SetAttribute
805 * themselves if they want to retrieve these values.
806 */
807 extern DECLSPEC int SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
808
809 /*
810 * Swap the OpenGL buffers, if double-buffering is supported.
811 */
812 extern DECLSPEC void SDL_GL_SwapBuffers(void);
813
814 /*
815 * Internal functions that should not be called unless you have read
816 * and understood the source code for these functions.
817 */
818 extern DECLSPEC void SDL_GL_UpdateRects(int numrects, SDL_Rect* rects);
819 extern DECLSPEC void SDL_GL_Lock(void);
820 extern DECLSPEC void SDL_GL_Unlock(void);
821
822 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
823 /* These functions allow interaction with the window manager, if any. */
824 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
825
826 /*
827 * Sets/Gets the title and icon text of the display window
828 */
829 extern DECLSPEC void SDL_WM_SetCaption(const char *title, const char *icon);
830 extern DECLSPEC void SDL_WM_GetCaption(char **title, char **icon);
831
832 /*
833 * Sets the icon for the display window.
834 * This function must be called before the first call to SDL_SetVideoMode().
835 * It takes an icon surface, and a mask in MSB format.
836 * If 'mask' is NULL, the entire icon surface will be used as the icon.
837 */
838 extern DECLSPEC void SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
839
840 /*
841 * This function iconifies the window, and returns 1 if it succeeded.
842 * If the function succeeds, it generates an SDL_APPACTIVE loss event.
843 * This function is a noop and returns 0 in non-windowed environments.
844 */
845 extern DECLSPEC int SDL_WM_IconifyWindow(void);
846
847 /*
848 * Toggle fullscreen mode without changing the contents of the screen.
849 * If the display surface does not require locking before accessing
850 * the pixel information, then the memory pointers will not change.
851 *
852 * If this function was able to toggle fullscreen mode (change from
853 * running in a window to fullscreen, or vice-versa), it will return 1.
854 * If it is not implemented, or fails, it returns 0.
855 *
856 * The next call to SDL_SetVideoMode() will set the mode fullscreen
857 * attribute based on the flags parameter - if SDL_FULLSCREEN is not
858 * set, then the display will be windowed by default where supported.
859 *
860 * This is currently only implemented in the X11 video driver.
861 */
862 extern DECLSPEC int SDL_WM_ToggleFullScreen(SDL_Surface *surface);
863
864 /*
865 * This function allows you to set and query the input grab state of
866 * the application. It returns the new input grab state.
867 */
868 typedef enum {
869 SDL_GRAB_QUERY = -1,
870 SDL_GRAB_OFF = 0,
871 SDL_GRAB_ON = 1,
872 SDL_GRAB_FULLSCREEN /* Used internally */
873 } SDL_GrabMode;
874 /*
875 * Grabbing means that the mouse is confined to the application window,
876 * and nearly all keyboard input is passed directly to the application,
877 * and not interpreted by a window manager, if any.
878 */
879 extern DECLSPEC SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode);
880
881 /* Ends C function definitions when using C++ */
882 #ifdef __cplusplus
883 }
884 #endif
885 #include "close_code.h"
886
887 #endif /* _SDL_video_h */