800fd64b78561c85f9ff1b65884db2bfc8768e60
2 {
3 $Id: sdl.pas,v 1.31 2007/05/29 21:30:48 savage Exp $
5 }
6 {******************************************************************************}
7 { }
8 { JEDI-SDL : Pascal units for SDL - Simple DirectMedia Layer }
9 { Conversion of the Simple DirectMedia Layer Headers }
10 { }
11 { Portions created by Sam Lantinga <slouken@devolution.com> are }
12 { Copyright (C) 1997-2004 Sam Lantinga }
13 { 5635-34 Springhouse Dr. }
14 { Pleasanton, CA 94588 (USA) }
15 { }
16 { All Rights Reserved. }
17 { }
18 { The original files are : SDL.h }
19 { SDL_main.h }
20 { SDL_types.h }
21 { SDL_rwops.h }
22 { SDL_timer.h }
23 { SDL_audio.h }
24 { SDL_cdrom.h }
25 { SDL_joystick.h }
26 { SDL_mouse.h }
27 { SDL_keyboard.h }
28 { SDL_events.h }
29 { SDL_video.h }
30 { SDL_byteorder.h }
31 { SDL_version.h }
32 { SDL_active.h }
33 { SDL_thread.h }
34 { SDL_mutex .h }
35 { SDL_getenv.h }
36 { SDL_loadso.h }
37 { }
38 { The initial developer of this Pascal code was : }
39 { Dominique Louis <Dominique@SavageSoftware.com.au> }
40 { }
41 { Portions created by Dominique Louis are }
42 { Copyright (C) 2000 - 2004 Dominique Louis. }
43 { }
44 { }
45 { Contributor(s) }
46 { -------------- }
47 { Tom Jones <tigertomjones@gmx.de> His Project inspired this conversion }
48 { Matthias Thoma <ma.thoma@gmx.de> }
49 { }
50 { Obtained through: }
51 { Joint Endeavour of Delphi Innovators ( Project JEDI ) }
52 { }
53 { You may retrieve the latest version of this file at the Project }
54 { JEDI home page, located at http://delphi-jedi.org }
55 { }
56 { The contents of this file are used with permission, subject to }
57 { the Mozilla Public License Version 1.1 (the "License"); you may }
58 { not use this file except in compliance with the License. You may }
59 { obtain a copy of the License at }
60 { http://www.mozilla.org/MPL/MPL-1.1.html }
61 { }
62 { Software distributed under the License is distributed on an }
63 { "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or }
64 { implied. See the License for the specific language governing }
65 { rights and limitations under the License. }
66 { }
67 { Description }
68 { ----------- }
69 { }
70 { }
71 { }
72 { }
73 { }
74 { }
75 { }
76 { Requires }
77 { -------- }
78 { The SDL Runtime libraris on Win32 : SDL.dll on Linux : libSDL.so }
79 { They are available from... }
80 { http://www.libsdl.org . }
81 { }
82 { Programming Notes }
83 { ----------------- }
84 { }
85 { }
86 { }
87 { }
88 { Revision History }
89 { ---------------- }
90 { May 08 2001 - DL : Added Keyboard State Array ( See demos for how to }
91 { use ) }
92 { PKeyStateArr = ^TKeyStateArr; }
93 { TKeyStateArr = array[0..65000] of UInt8; }
94 { As most games will need it. }
95 { }
96 { April 02 2001 - DL : Added SDL_getenv.h definitions and tested version }
97 { 1.2.0 compatability. }
98 { }
99 { March 13 2001 - MT : Added Linux compatibility. }
100 { }
101 { March 10 2001 - MT : Added externalsyms for DEFINES }
102 { Changed the license header }
103 { }
104 { March 09 2001 - MT : Added Kylix Ifdefs/Deleted the uses mmsystem }
105 { }
106 { March 01 2001 - DL : Update conversion of version 1.1.8 }
107 { }
108 { July 22 2001 - DL : Added TUInt8Array and PUIntArray after suggestions }
109 { from Matthias Thoma and Eric Grange. }
110 { }
111 { October 12 2001 - DL : Various changes as suggested by Matthias Thoma and }
112 { David Acklam }
113 { }
114 { October 24 2001 - DL : Added FreePascal support as per suggestions from }
115 { Dean Ellis. }
116 { }
117 { October 27 2001 - DL : Added SDL_BUTTON macro }
118 { }
119 { November 08 2001 - DL : Bug fix as pointed out by Puthoon. }
120 { }
121 { November 29 2001 - DL : Bug fix of SDL_SetGammaRamp as pointed out by Simon}
122 { Rushton. }
123 { }
124 { November 30 2001 - DL : SDL_NOFRAME added as pointed out by Simon Rushton. }
125 { }
126 { December 11 2001 - DL : Added $WEAKPACKAGEUNIT ON to facilitate useage in }
127 { Components }
128 { }
129 { January 05 2002 - DL : Added SDL_Swap32 function as suggested by Matthias }
130 { Thoma and also made sure the _getenv from }
131 { MSVCRT.DLL uses the right calling convention }
132 { }
133 { January 25 2002 - DL : Updated conversion of SDL_AddTimer & }
134 { SDL_RemoveTimer as per suggestions from Matthias }
135 { Thoma. }
136 { }
137 { January 27 2002 - DL : Commented out exported function putenv and getenv }
138 { So that developers get used to using SDL_putenv }
139 { SDL_getenv, as they are more portable }
140 { }
141 { March 05 2002 - DL : Added FreeAnNil procedure for Delphi 4 users. }
142 { }
143 { October 23 2002 - DL : Added Delphi 3 Define of Win32. }
144 { If you intend to you Delphi 3... }
145 { ( which is officially unsupported ) make sure you }
146 { remove references to $EXTERNALSYM in this and other}
147 { SDL files. }
148 { }
149 { November 29 2002 - DL : Fixed bug in Declaration of SDL_GetRGBA that was }
150 { pointed out by Todd Lang }
151 { }
152 { April 03 2003 - DL : Added jedi-sdl.inc include file to support more }
153 { Pascal compilers. Initial support is now included }
154 { for GnuPascal, VirtualPascal, TMT and obviously }
155 { continue support for Delphi Kylix and FreePascal. }
156 { }
157 { April 08 2003 - MK : Aka Mr Kroket - Added Better FPC support }
158 { }
159 { April 24 2003 - DL : under instruction from Alexey Barkovoy, I have added}
160 { better TMT Pascal support and under instruction }
161 { from Prof. Abimbola Olowofoyeku (The African Chief),}
162 { I have added better Gnu Pascal support }
163 { }
164 { April 30 2003 - DL : under instruction from David Mears AKA }
165 { Jason Siletto, I have added FPC Linux support. }
166 { This was compiled with fpc 1.1, so remember to set }
167 { include file path. ie. -Fi/usr/share/fpcsrc/rtl/* }
168 { }
169 {
170 $Log: sdl.pas,v $
171 Revision 1.31 2007/05/29 21:30:48 savage
172 Changes as suggested by Almindor for 64bit compatibility.
174 Revision 1.30 2007/05/29 19:31:03 savage
175 Fix to TSDL_Overlay structure - thanks David Pethes (aka imcold)
177 Revision 1.29 2007/05/20 20:29:11 savage
178 Initial Changes to Handle 64 Bits
180 Revision 1.26 2007/02/11 13:38:04 savage
181 Added Nintendo DS support - Thanks Dean.
183 Revision 1.25 2006/12/02 00:12:52 savage
184 Updated to latest version
186 Revision 1.24 2006/05/18 21:10:04 savage
187 Added 1.2.10 Changes
189 Revision 1.23 2005/12/04 23:17:52 drellis
190 Added declaration of SInt8 and PSInt8
192 Revision 1.22 2005/05/24 21:59:03 savage
193 Re-arranged uses clause to work on Win32 and Linux, Thanks again Michalis.
195 Revision 1.21 2005/05/22 18:42:31 savage
196 Changes as suggested by Michalis Kamburelis. Thanks again.
198 Revision 1.20 2005/04/10 11:48:33 savage
199 Changes as suggested by Michalis, thanks.
201 Revision 1.19 2005/01/05 01:47:06 savage
202 Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
204 Revision 1.18 2005/01/04 23:14:41 savage
205 Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
207 Revision 1.17 2005/01/03 18:40:59 savage
208 Updated Version number to reflect latest one
210 Revision 1.16 2005/01/01 02:02:06 savage
211 Updated to v1.2.8
213 Revision 1.15 2004/12/24 18:57:11 savage
214 forgot to apply Michalis Kamburelis' patch to the implementation section. now fixed
216 Revision 1.14 2004/12/23 23:42:18 savage
217 Applied Patches supplied by Michalis Kamburelis ( THANKS! ), for greater FreePascal compatability.
219 Revision 1.13 2004/09/30 22:31:59 savage
220 Updated with slightly different header comments
222 Revision 1.12 2004/09/12 21:52:58 savage
223 Slight changes to fix some issues with the sdl classes.
225 Revision 1.11 2004/08/14 22:54:30 savage
226 Updated so that Library name defines are correctly defined for MacOS X.
228 Revision 1.10 2004/07/20 23:57:33 savage
229 Thanks to Paul Toth for spotting an error in the SDL Audio Convertion structures.
230 In TSDL_AudioCVT the filters variable should point to and array of pointers and not what I had there previously.
232 Revision 1.9 2004/07/03 22:07:22 savage
233 Added Bitwise Manipulation Functions for TSDL_VideoInfo struct.
235 Revision 1.8 2004/05/10 14:10:03 savage
236 Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
238 Revision 1.7 2004/04/13 09:32:08 savage
239 Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
241 Revision 1.6 2004/04/01 20:53:23 savage
242 Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
244 Revision 1.5 2004/02/22 15:32:10 savage
245 SDL_GetEnv Fix so it also works on FPC/Linux. Thanks to Rodrigo for pointing this out.
247 Revision 1.4 2004/02/21 23:24:29 savage
248 SDL_GetEnv Fix so that it is not define twice for FPC. Thanks to Rene Hugentobler for pointing out this bug,
250 Revision 1.3 2004/02/18 22:35:51 savage
251 Brought sdl.pas up to 1.2.7 compatability
252 Thus...
253 Added SDL_GL_STEREO,
254 SDL_GL_MULTISAMPLEBUFFERS,
255 SDL_GL_MULTISAMPLESAMPLES
257 Add DLL/Shared object functions
258 function SDL_LoadObject( const sofile : PChar ) : Pointer;
260 function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer;
262 procedure SDL_UnloadObject( handle : Pointer );
264 Added function to create RWops from const memory: SDL_RWFromConstMem()
265 function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops;
267 Ported SDL_cpuinfo.h so Now you can test for Specific CPU types.
269 Revision 1.2 2004/02/17 21:37:12 savage
270 Tidying up of units
272 Revision 1.1 2004/02/05 00:08:20 savage
273 Module 1.0 release
275 }
276 {******************************************************************************}
278 {$I jedi-sdl.inc}
280 interface
282 uses
283 {$IFDEF __GPC__}
284 system,
285 {$IFDEF WINDOWS}
286 wintypes,
287 {$ELSE}
288 {$ENDIF}
289 gpc;
290 {$ENDIF}
292 {$IFDEF HAS_TYPES}
294 {$ENDIF}
296 {$IFDEF WINDOWS}
297 Windows;
298 {$ENDIF}
300 {$IFDEF OS2}
301 doscalls;
302 {$ENDIF OS2}
304 {$IFDEF UNIX}
305 {$IFDEF FPC}
306 pthreads,
307 unixtype,
308 baseunix,
309 {$IFNDEF GP2X}
310 unix,
311 {$ELSE}
312 unix;
313 {$ENDIF}
314 {$IFNDEF GP2X}
315 x,
316 xlib;
317 {$ENDIF}
318 {$ELSE}
319 Libc,
320 Xlib;
321 {$ENDIF}
322 {$ENDIF}
324 {$IFDEF __MACH__}
325 GPCMacOSAll;
326 {$ENDIF}
328 {$IFDEF MORPHOS}
329 exec;
330 {$ENDIF}
332 const
333 {$IFDEF WINDOWS}
335 {$ENDIF}
337 {$IFDEF OS2}
339 {$ENDIF OS2}
341 {$IFDEF UNIX}
342 {$IFDEF DARWIN}
344 {$linklib libSDL-1.2.0}
345 {$linklib SDLmain}
346 {$linkframework Cocoa}
347 {$PASCALMAINNAME SDL_main}
348 {$ELSE}
349 {$IFDEF FPC}
351 {$ELSE}
353 {$ENDIF}
354 {$ENDIF}
355 {$ENDIF}
357 {$IFDEF MACOS}
359 {$ENDIF}
361 {$IFDEF NDS}
363 {$linklib libSDL.a}
364 {$linklib libnds9.a}
365 {$linklib libc.a}
366 {$linklib libgcc.a}
367 {$linklib libsysbase.a}
368 {$ENDIF}
370 {$IFDEF MORPHOS}
372 {$ENDIF}
374 // SDL_verion.h constants
375 // Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
377 {$EXTERNALSYM SDL_MAJOR_VERSION}
379 {$EXTERNALSYM SDL_MINOR_VERSION}
381 {$EXTERNALSYM SDL_PATCHLEVEL}
383 // SDL.h constants
385 {$EXTERNALSYM SDL_INIT_TIMER}
387 {$EXTERNALSYM SDL_INIT_AUDIO}
389 {$EXTERNALSYM SDL_INIT_VIDEO}
391 {$EXTERNALSYM SDL_INIT_CDROM}
393 {$EXTERNALSYM SDL_INIT_JOYSTICK}
395 {$EXTERNALSYM SDL_INIT_NOPARACHUTE}
397 {$EXTERNALSYM SDL_INIT_EVENTTHREAD}
399 {$EXTERNALSYM SDL_INIT_EVERYTHING}
401 // SDL_error.h constants
403 {$EXTERNALSYM ERR_MAX_STRLEN}
405 {$EXTERNALSYM ERR_MAX_ARGS}
407 // SDL_types.h constants
409 {$EXTERNALSYM SDL_PRESSED}
411 {$EXTERNALSYM SDL_RELEASED}
413 // SDL_timer.h constants
414 // This is the OS scheduler timeslice, in milliseconds
416 {$EXTERNALSYM SDL_TIMESLICE}
417 // This is the maximum resolution of the SDL timer on all platforms
419 {$EXTERNALSYM TIMER_RESOLUTION}
421 // SDL_audio.h constants
423 {$EXTERNALSYM AUDIO_U8}
425 {$EXTERNALSYM AUDIO_S8}
427 {$EXTERNALSYM AUDIO_U16LSB}
429 {$EXTERNALSYM AUDIO_S16LSB}
431 {$EXTERNALSYM AUDIO_U16MSB}
433 {$EXTERNALSYM AUDIO_S16MSB}
435 {$EXTERNALSYM AUDIO_U16}
437 {$EXTERNALSYM AUDIO_S16}
440 // SDL_cdrom.h constants
441 // The maximum number of CD-ROM tracks on a disk
443 {$EXTERNALSYM SDL_MAX_TRACKS}
444 // The types of CD-ROM track possible
446 {$EXTERNALSYM SDL_AUDIO_TRACK}
448 {$EXTERNALSYM SDL_DATA_TRACK}
450 // Conversion functions from frames to Minute/Second/Frames and vice versa
452 {$EXTERNALSYM CD_FPS}
453 // SDL_byteorder.h constants
454 // The two types of endianness
456 {$EXTERNALSYM SDL_LIL_ENDIAN}
458 {$EXTERNALSYM SDL_BIG_ENDIAN}
460 {$IFDEF FPC_LITTLE_ENDIAN}
462 {$ELSE}
464 {$ENDIF}
465 {$EXTERNALSYM SDL_BYTEORDER}
467 // Native audio byte ordering
468 {$IFDEF FPC_LITTLE_ENDIAN}
471 {$ELSE}
474 {$ENDIF}
475 {$EXTERNALSYM AUDIO_U16SYS}
476 {$EXTERNALSYM AUDIO_S16SYS}
479 {$EXTERNALSYM SDL_MIX_MAXVOLUME}
481 // SDL_joystick.h constants
483 {$EXTERNALSYM MAX_JOYSTICKS}
485 {$EXTERNALSYM MAX_AXES}
487 {$EXTERNALSYM MAX_BUTTONS}
489 {$EXTERNALSYM AXIS_MIN}
491 {$EXTERNALSYM AXIS_MAX}
493 {$EXTERNALSYM JOY_AXIS_THRESHOLD}
494 //JOY_BUTTON_FLAG(n) (1<<n)
495 // array to hold joystick ID values
496 //static UInt SYS_JoystickID[MAX_JOYSTICKS];
497 //static JOYCAPS SYS_Joystick[MAX_JOYSTICKS];
499 { Get the current state of a POV hat on a joystick
500 The return value is one of the following positions: }
502 {$EXTERNALSYM SDL_HAT_CENTERED}
504 {$EXTERNALSYM SDL_HAT_UP}
506 {$EXTERNALSYM SDL_HAT_RIGHT}
508 {$EXTERNALSYM SDL_HAT_DOWN}
510 {$EXTERNALSYM SDL_HAT_LEFT}
512 {$EXTERNALSYM SDL_HAT_RIGHTUP}
514 {$EXTERNALSYM SDL_HAT_RIGHTDOWN}
516 {$EXTERNALSYM SDL_HAT_LEFTUP}
518 {$EXTERNALSYM SDL_HAT_LEFTDOWN}
520 // SDL_events.h constants
522 {$EXTERNALSYM SDL_NOEVENT}
524 {$EXTERNALSYM SDL_ACTIVEEVENT}
526 {$EXTERNALSYM SDL_KEYDOWN}
528 {$EXTERNALSYM SDL_KEYUP}
530 {$EXTERNALSYM SDL_MOUSEMOTION}
532 {$EXTERNALSYM SDL_MOUSEBUTTONDOWN}
534 {$EXTERNALSYM SDL_MOUSEBUTTONUP}
536 {$EXTERNALSYM SDL_JOYAXISMOTION}
538 {$EXTERNALSYM SDL_JOYBALLMOTION}
540 {$EXTERNALSYM SDL_JOYHATMOTION}
542 {$EXTERNALSYM SDL_JOYBUTTONDOWN}
544 {$EXTERNALSYM SDL_JOYBUTTONUP}
546 {$EXTERNALSYM SDL_QUIT}
548 {$EXTERNALSYM SDL_SYSWMEVENT}
550 {$EXTERNALSYM SDL_EVENT_RESERVEDA}
552 {$EXTERNALSYM SDL_EVENT_RESERVED}
554 {$EXTERNALSYM SDL_VIDEORESIZE}
556 {$EXTERNALSYM SDL_VIDEOEXPOSE}
558 {$EXTERNALSYM SDL_EVENT_RESERVED2}
560 {$EXTERNALSYM SDL_EVENT_RESERVED3}
562 {$EXTERNALSYM SDL_EVENT_RESERVED4}
564 {$EXTERNALSYM SDL_EVENT_RESERVED5}
566 {$EXTERNALSYM SDL_EVENT_RESERVED6}
568 {$EXTERNALSYM SDL_EVENT_RESERVED7}
569 // Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use
571 {$EXTERNALSYM SDL_USEREVENT}
572 // This last event is only for bounding internal arrays
573 // It is the number of bits in the event mask datatype -- UInt32
575 {$EXTERNALSYM SDL_NUMEVENTS}
578 {$EXTERNALSYM SDL_ALLEVENTS}
581 {$EXTERNALSYM SDL_ACTIVEEVENTMASK}
583 {$EXTERNALSYM SDL_KEYDOWNMASK}
585 {$EXTERNALSYM SDL_KEYUPMASK}
587 {$EXTERNALSYM SDL_MOUSEMOTIONMASK}
589 {$EXTERNALSYM SDL_MOUSEBUTTONDOWNMASK}
591 {$EXTERNALSYM SDL_MOUSEBUTTONUPMASK}
595 {$EXTERNALSYM SDL_MOUSEEVENTMASK}
597 {$EXTERNALSYM SDL_JOYAXISMOTIONMASK}
599 {$EXTERNALSYM SDL_JOYBALLMOTIONMASK}
601 {$EXTERNALSYM SDL_JOYHATMOTIONMASK}
603 {$EXTERNALSYM SDL_JOYBUTTONDOWNMASK}
605 {$EXTERNALSYM SDL_JOYBUTTONUPMASK}
611 {$EXTERNALSYM SDL_JOYEVENTMASK}
613 {$EXTERNALSYM SDL_VIDEORESIZEMASK}
615 {$EXTERNALSYM SDL_QUITMASK}
617 {$EXTERNALSYM SDL_SYSWMEVENTMASK}
619 { This function allows you to set the state of processing certain events.
620 If 'state' is set to SDL_IGNORE, that event will be automatically dropped
621 from the event queue and will not event be filtered.
622 If 'state' is set to SDL_ENABLE, that event will be processed normally.
623 If 'state' is set to SDL_QUERY, SDL_EventState() will return the
624 current processing state of the specified event. }
627 {$EXTERNALSYM SDL_QUERY}
629 {$EXTERNALSYM SDL_IGNORE}
631 {$EXTERNALSYM SDL_DISABLE}
633 {$EXTERNALSYM SDL_ENABLE}
635 //SDL_keyboard.h constants
636 // This is the mask which refers to all hotkey bindings
638 {$EXTERNALSYM SDL_ALL_HOTKEYS}
640 { Enable/Disable keyboard repeat. Keyboard repeat defaults to off.
641 'delay' is the initial delay in ms between the time when a key is
642 pressed, and keyboard repeat begins.
643 'interval' is the time in ms between keyboard repeat events. }
646 {$EXTERNALSYM SDL_DEFAULT_REPEAT_DELAY}
648 {$EXTERNALSYM SDL_DEFAULT_REPEAT_INTERVAL}
650 // The keyboard syms have been cleverly chosen to map to ASCII
652 {$EXTERNALSYM SDLK_UNKNOWN}
654 {$EXTERNALSYM SDLK_FIRST}
656 {$EXTERNALSYM SDLK_BACKSPACE}
658 {$EXTERNALSYM SDLK_TAB}
660 {$EXTERNALSYM SDLK_CLEAR}
662 {$EXTERNALSYM SDLK_RETURN}
664 {$EXTERNALSYM SDLK_PAUSE}
666 {$EXTERNALSYM SDLK_ESCAPE}
668 {$EXTERNALSYM SDLK_SPACE}
670 {$EXTERNALSYM SDLK_EXCLAIM}
672 {$EXTERNALSYM SDLK_QUOTEDBL}
674 {$EXTERNALSYM SDLK_HASH}
676 {$EXTERNALSYM SDLK_DOLLAR}
678 {$EXTERNALSYM SDLK_AMPERSAND}
680 {$EXTERNALSYM SDLK_QUOTE}
682 {$EXTERNALSYM SDLK_LEFTPAREN}
684 {$EXTERNALSYM SDLK_RIGHTPAREN}
686 {$EXTERNALSYM SDLK_ASTERISK}
688 {$EXTERNALSYM SDLK_PLUS}
690 {$EXTERNALSYM SDLK_COMMA}
692 {$EXTERNALSYM SDLK_MINUS}
694 {$EXTERNALSYM SDLK_PERIOD}
696 {$EXTERNALSYM SDLK_SLASH}
698 {$EXTERNALSYM SDLK_0}
700 {$EXTERNALSYM SDLK_1}
702 {$EXTERNALSYM SDLK_2}
704 {$EXTERNALSYM SDLK_3}
706 {$EXTERNALSYM SDLK_4}
708 {$EXTERNALSYM SDLK_5}
710 {$EXTERNALSYM SDLK_6}
712 {$EXTERNALSYM SDLK_7}
714 {$EXTERNALSYM SDLK_8}
716 {$EXTERNALSYM SDLK_9}
718 {$EXTERNALSYM SDLK_COLON}
720 {$EXTERNALSYM SDLK_SEMICOLON}
722 {$EXTERNALSYM SDLK_LESS}
724 {$EXTERNALSYM SDLK_EQUALS}
726 {$EXTERNALSYM SDLK_GREATER}
728 {$EXTERNALSYM SDLK_QUESTION}
730 {$EXTERNALSYM SDLK_AT}
732 { Skip uppercase letters }
735 {$EXTERNALSYM SDLK_LEFTBRACKET}
737 {$EXTERNALSYM SDLK_BACKSLASH}
739 {$EXTERNALSYM SDLK_RIGHTBRACKET}
741 {$EXTERNALSYM SDLK_CARET}
743 {$EXTERNALSYM SDLK_UNDERSCORE}
745 {$EXTERNALSYM SDLK_BACKQUOTE}
747 {$EXTERNALSYM SDLK_a}
749 {$EXTERNALSYM SDLK_b}
751 {$EXTERNALSYM SDLK_c}
753 {$EXTERNALSYM SDLK_d}
755 {$EXTERNALSYM SDLK_e}
757 {$EXTERNALSYM SDLK_f}
759 {$EXTERNALSYM SDLK_g}
761 {$EXTERNALSYM SDLK_h}
763 {$EXTERNALSYM SDLK_i}
765 {$EXTERNALSYM SDLK_j}
767 {$EXTERNALSYM SDLK_k}
769 {$EXTERNALSYM SDLK_l}
771 {$EXTERNALSYM SDLK_m}
773 {$EXTERNALSYM SDLK_n}
775 {$EXTERNALSYM SDLK_o}
777 {$EXTERNALSYM SDLK_p}
779 {$EXTERNALSYM SDLK_q}
781 {$EXTERNALSYM SDLK_r}
783 {$EXTERNALSYM SDLK_s}
785 {$EXTERNALSYM SDLK_t}
787 {$EXTERNALSYM SDLK_u}
789 {$EXTERNALSYM SDLK_v}
791 {$EXTERNALSYM SDLK_w}
793 {$EXTERNALSYM SDLK_x}
795 {$EXTERNALSYM SDLK_y}
797 {$EXTERNALSYM SDLK_z}
799 {$EXTERNALSYM SDLK_DELETE}
800 // End of ASCII mapped keysyms
802 // International keyboard syms
804 {$EXTERNALSYM SDLK_WORLD_0}
806 {$EXTERNALSYM SDLK_WORLD_1}
808 {$EXTERNALSYM SDLK_WORLD_2}
810 {$EXTERNALSYM SDLK_WORLD_3}
812 {$EXTERNALSYM SDLK_WORLD_4}
814 {$EXTERNALSYM SDLK_WORLD_5}
816 {$EXTERNALSYM SDLK_WORLD_6}
818 {$EXTERNALSYM SDLK_WORLD_7}
820 {$EXTERNALSYM SDLK_WORLD_8}
822 {$EXTERNALSYM SDLK_WORLD_9}
824 {$EXTERNALSYM SDLK_WORLD_10}
826 {$EXTERNALSYM SDLK_WORLD_11}
828 {$EXTERNALSYM SDLK_WORLD_12}
830 {$EXTERNALSYM SDLK_WORLD_13}
832 {$EXTERNALSYM SDLK_WORLD_14}
834 {$EXTERNALSYM SDLK_WORLD_15}
836 {$EXTERNALSYM SDLK_WORLD_16}
838 {$EXTERNALSYM SDLK_WORLD_17}
840 {$EXTERNALSYM SDLK_WORLD_18}
842 {$EXTERNALSYM SDLK_WORLD_19}
844 {$EXTERNALSYM SDLK_WORLD_20}
846 {$EXTERNALSYM SDLK_WORLD_21}
848 {$EXTERNALSYM SDLK_WORLD_22}
850 {$EXTERNALSYM SDLK_WORLD_23}
852 {$EXTERNALSYM SDLK_WORLD_24}
854 {$EXTERNALSYM SDLK_WORLD_25}
856 {$EXTERNALSYM SDLK_WORLD_26}
858 {$EXTERNALSYM SDLK_WORLD_27}
860 {$EXTERNALSYM SDLK_WORLD_28}
862 {$EXTERNALSYM SDLK_WORLD_29}
864 {$EXTERNALSYM SDLK_WORLD_30}
866 {$EXTERNALSYM SDLK_WORLD_31}
868 {$EXTERNALSYM SDLK_WORLD_32}
870 {$EXTERNALSYM SDLK_WORLD_33}
872 {$EXTERNALSYM SDLK_WORLD_34}
874 {$EXTERNALSYM SDLK_WORLD_35}
876 {$EXTERNALSYM SDLK_WORLD_36}
878 {$EXTERNALSYM SDLK_WORLD_37}
880 {$EXTERNALSYM SDLK_WORLD_38}
882 {$EXTERNALSYM SDLK_WORLD_39}
884 {$EXTERNALSYM SDLK_WORLD_40}
886 {$EXTERNALSYM SDLK_WORLD_41}
888 {$EXTERNALSYM SDLK_WORLD_42}
890 {$EXTERNALSYM SDLK_WORLD_43}
892 {$EXTERNALSYM SDLK_WORLD_44}
894 {$EXTERNALSYM SDLK_WORLD_45}
896 {$EXTERNALSYM SDLK_WORLD_46}
898 {$EXTERNALSYM SDLK_WORLD_47}
900 {$EXTERNALSYM SDLK_WORLD_48}
902 {$EXTERNALSYM SDLK_WORLD_49}
904 {$EXTERNALSYM SDLK_WORLD_50}
906 {$EXTERNALSYM SDLK_WORLD_51}
908 {$EXTERNALSYM SDLK_WORLD_52}
910 {$EXTERNALSYM SDLK_WORLD_53}
912 {$EXTERNALSYM SDLK_WORLD_54}
914 {$EXTERNALSYM SDLK_WORLD_55}
916 {$EXTERNALSYM SDLK_WORLD_56}
918 {$EXTERNALSYM SDLK_WORLD_57}
920 {$EXTERNALSYM SDLK_WORLD_58}
922 {$EXTERNALSYM SDLK_WORLD_59}
924 {$EXTERNALSYM SDLK_WORLD_60}
926 {$EXTERNALSYM SDLK_WORLD_61}
928 {$EXTERNALSYM SDLK_WORLD_62}
930 {$EXTERNALSYM SDLK_WORLD_63}
932 {$EXTERNALSYM SDLK_WORLD_64}
934 {$EXTERNALSYM SDLK_WORLD_65}
936 {$EXTERNALSYM SDLK_WORLD_66}
938 {$EXTERNALSYM SDLK_WORLD_67}
940 {$EXTERNALSYM SDLK_WORLD_68}
942 {$EXTERNALSYM SDLK_WORLD_69}
944 {$EXTERNALSYM SDLK_WORLD_70}
946 {$EXTERNALSYM SDLK_WORLD_71}
948 {$EXTERNALSYM SDLK_WORLD_72}
950 {$EXTERNALSYM SDLK_WORLD_73}
952 {$EXTERNALSYM SDLK_WORLD_74}
954 {$EXTERNALSYM SDLK_WORLD_75}
956 {$EXTERNALSYM SDLK_WORLD_76}
958 {$EXTERNALSYM SDLK_WORLD_77}
960 {$EXTERNALSYM SDLK_WORLD_78}
962 {$EXTERNALSYM SDLK_WORLD_79}
964 {$EXTERNALSYM SDLK_WORLD_80}
966 {$EXTERNALSYM SDLK_WORLD_81}
968 {$EXTERNALSYM SDLK_WORLD_82}
970 {$EXTERNALSYM SDLK_WORLD_83}
972 {$EXTERNALSYM SDLK_WORLD_84}
974 {$EXTERNALSYM SDLK_WORLD_85}
976 {$EXTERNALSYM SDLK_WORLD_86}
978 {$EXTERNALSYM SDLK_WORLD_87}
980 {$EXTERNALSYM SDLK_WORLD_88}
982 {$EXTERNALSYM SDLK_WORLD_89}
984 {$EXTERNALSYM SDLK_WORLD_90}
986 {$EXTERNALSYM SDLK_WORLD_91}
988 {$EXTERNALSYM SDLK_WORLD_92}
990 {$EXTERNALSYM SDLK_WORLD_93}
992 {$EXTERNALSYM SDLK_WORLD_94}
994 {$EXTERNALSYM SDLK_WORLD_95}
996 // Numeric keypad
998 {$EXTERNALSYM SDLK_KP0}
1000 {$EXTERNALSYM SDLK_KP1}
1002 {$EXTERNALSYM SDLK_KP2}
1004 {$EXTERNALSYM SDLK_KP3}
1006 {$EXTERNALSYM SDLK_KP4}
1008 {$EXTERNALSYM SDLK_KP5}
1010 {$EXTERNALSYM SDLK_KP6}
1012 {$EXTERNALSYM SDLK_KP7}
1014 {$EXTERNALSYM SDLK_KP8}
1016 {$EXTERNALSYM SDLK_KP9}
1018 {$EXTERNALSYM SDLK_KP_PERIOD}
1020 {$EXTERNALSYM SDLK_KP_DIVIDE}
1022 {$EXTERNALSYM SDLK_KP_MULTIPLY}
1024 {$EXTERNALSYM SDLK_KP_MINUS}
1026 {$EXTERNALSYM SDLK_KP_PLUS}
1028 {$EXTERNALSYM SDLK_KP_ENTER}
1030 {$EXTERNALSYM SDLK_KP_EQUALS}
1032 // Arrows + Home/End pad
1034 {$EXTERNALSYM SDLK_UP}
1036 {$EXTERNALSYM SDLK_DOWN}
1038 {$EXTERNALSYM SDLK_RIGHT}
1040 {$EXTERNALSYM SDLK_LEFT}
1042 {$EXTERNALSYM SDLK_INSERT}
1044 {$EXTERNALSYM SDLK_HOME}
1046 {$EXTERNALSYM SDLK_END}
1048 {$EXTERNALSYM SDLK_PAGEUP}
1050 {$EXTERNALSYM SDLK_PAGEDOWN}
1052 // Function keys
1054 {$EXTERNALSYM SDLK_F1}
1056 {$EXTERNALSYM SDLK_F2}
1058 {$EXTERNALSYM SDLK_F3}
1060 {$EXTERNALSYM SDLK_F4}
1062 {$EXTERNALSYM SDLK_F5}
1064 {$EXTERNALSYM SDLK_F6}
1066 {$EXTERNALSYM SDLK_F7}
1068 {$EXTERNALSYM SDLK_F8}
1070 {$EXTERNALSYM SDLK_F9}
1072 {$EXTERNALSYM SDLK_F10}
1074 {$EXTERNALSYM SDLK_F11}
1076 {$EXTERNALSYM SDLK_F12}
1078 {$EXTERNALSYM SDLK_F13}
1080 {$EXTERNALSYM SDLK_F14}
1082 {$EXTERNALSYM SDLK_F15}
1084 // Key state modifier keys
1086 {$EXTERNALSYM SDLK_NUMLOCK}
1088 {$EXTERNALSYM SDLK_CAPSLOCK}
1090 {$EXTERNALSYM SDLK_SCROLLOCK}
1092 {$EXTERNALSYM SDLK_RSHIFT}
1094 {$EXTERNALSYM SDLK_LSHIFT}
1096 {$EXTERNALSYM SDLK_RCTRL}
1098 {$EXTERNALSYM SDLK_LCTRL}
1100 {$EXTERNALSYM SDLK_RALT}
1102 {$EXTERNALSYM SDLK_LALT}
1104 {$EXTERNALSYM SDLK_RMETA}
1106 {$EXTERNALSYM SDLK_LMETA}
1108 {$EXTERNALSYM SDLK_LSUPER}
1110 {$EXTERNALSYM SDLK_RSUPER}
1112 {$EXTERNALSYM SDLK_MODE}
1114 {$EXTERNALSYM SDLK_COMPOSE}
1116 // Miscellaneous function keys
1118 {$EXTERNALSYM SDLK_HELP}
1120 {$EXTERNALSYM SDLK_PRINT}
1122 {$EXTERNALSYM SDLK_SYSREQ}
1124 {$EXTERNALSYM SDLK_BREAK}
1126 {$EXTERNALSYM SDLK_MENU}
1128 {$EXTERNALSYM SDLK_POWER}
1130 {$EXTERNALSYM SDLK_EURO}
1132 {$IFDEF GP2X}
1134 {$EXTERNALSYM SDLK_GP2X_UP}
1136 {$EXTERNALSYM SDLK_GP2X_UPLEFT}
1138 {$EXTERNALSYM SDLK_GP2X_LEFT}
1140 {$EXTERNALSYM SDLK_GP2X_DOWNLEFT}
1142 {$EXTERNALSYM SDLK_GP2X_DOWN}
1144 {$EXTERNALSYM SDLK_GP2X_DOWNRIGHT}
1146 {$EXTERNALSYM SDLK_GP2X_RIGHT}
1148 {$EXTERNALSYM SDLK_GP2X_UPRIGHT}
1150 {$EXTERNALSYM SDLK_GP2X_START}
1152 {$EXTERNALSYM SDLK_GP2X_SELECT}
1154 {$EXTERNALSYM SDLK_GP2X_L}
1156 {$EXTERNALSYM SDLK_GP2X_R}
1158 {$EXTERNALSYM SDLK_GP2X_A}
1160 {$EXTERNALSYM SDLK_GP2X_B}
1162 {$EXTERNALSYM SDLK_GP2X_Y}
1164 {$EXTERNALSYM SDLK_GP2X_X}
1166 {$EXTERNALSYM SDLK_GP2X_VOLUP}
1168 {$EXTERNALSYM SDLK_GP2X_VOLDOWN}
1170 {$EXTERNALSYM SDLK_GP2X_CLICK}
1171 {$ENDIF}
1173 // Enumeration of valid key mods (possibly OR'd together)
1175 {$EXTERNALSYM KMOD_NONE}
1177 {$EXTERNALSYM KMOD_LSHIFT}
1179 {$EXTERNALSYM KMOD_RSHIFT}
1181 {$EXTERNALSYM KMOD_LCTRL}
1183 {$EXTERNALSYM KMOD_RCTRL}
1185 {$EXTERNALSYM KMOD_LALT}
1187 {$EXTERNALSYM KMOD_RALT}
1189 {$EXTERNALSYM KMOD_LMETA}
1191 {$EXTERNALSYM KMOD_RMETA}
1193 {$EXTERNALSYM KMOD_NUM}
1195 {$EXTERNALSYM KMOD_CAPS}
1197 {$EXTERNALSYM KMOD_MODE}
1199 {$EXTERNALSYM KMOD_RESERVED}
1202 {$EXTERNALSYM KMOD_CTRL}
1204 {$EXTERNALSYM KMOD_SHIFT}
1206 {$EXTERNALSYM KMOD_ALT}
1208 {$EXTERNALSYM KMOD_META}
1210 //SDL_video.h constants
1211 // Transparency definitions: These define alpha as the opacity of a surface */
1213 {$EXTERNALSYM SDL_ALPHA_OPAQUE}
1215 {$EXTERNALSYM SDL_ALPHA_TRANSPARENT}
1217 // These are the currently supported flags for the SDL_surface
1218 // Available for SDL_CreateRGBSurface() or SDL_SetVideoMode()
1220 {$EXTERNALSYM SDL_SWSURFACE}
1222 {$EXTERNALSYM SDL_HWSURFACE}
1224 {$EXTERNALSYM SDL_ASYNCBLIT}
1225 // Available for SDL_SetVideoMode()
1227 {$EXTERNALSYM SDL_ANYFORMAT}
1229 {$EXTERNALSYM SDL_HWPALETTE}
1231 {$EXTERNALSYM SDL_DOUBLEBUF}
1233 {$EXTERNALSYM SDL_FULLSCREEN}
1235 {$EXTERNALSYM SDL_OPENGL}
1237 {$EXTERNALSYM SDL_OPENGLBLIT}
1239 {$EXTERNALSYM SDL_RESIZABLE}
1241 {$EXTERNALSYM SDL_NOFRAME}
1242 // Used internally (read-only)
1244 {$EXTERNALSYM SDL_HWACCEL}
1246 {$EXTERNALSYM SDL_SRCCOLORKEY}
1248 {$EXTERNALSYM SDL_RLEACCELOK}
1250 {$EXTERNALSYM SDL_RLEACCEL}
1252 {$EXTERNALSYM SDL_SRCALPHA}
1254 {$EXTERNALSYM SDL_SRCCLIPPING}
1256 {$EXTERNALSYM SDL_PREALLOC}
1258 { The most common video overlay formats.
1259 For an explanation of these pixel formats, see:
1260 http://www.webartz.com/fourcc/indexyuv.htm
1262 For information on the relationship between color spaces, see:
1263 http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html }
1266 {$EXTERNALSYM SDL_YV12_OVERLAY}
1268 {$EXTERNALSYM SDL_IYUV_OVERLAY}
1270 {$EXTERNALSYM SDL_YUY2_OVERLAY}
1272 {$EXTERNALSYM SDL_UYVY_OVERLAY}
1274 {$EXTERNALSYM SDL_YVYU_OVERLAY}
1276 // flags for SDL_SetPalette()
1278 {$EXTERNALSYM SDL_LOGPAL}
1280 {$EXTERNALSYM SDL_PHYSPAL}
1282 //SDL_mouse.h constants
1283 { Used as a mask when testing buttons in buttonstate
1284 Button 1: Left mouse button
1285 Button 2: Middle mouse button
1286 Button 3: Right mouse button
1287 Button 4: Mouse Wheel Up
1288 Button 5: Mouse Wheel Down
1289 }
1291 {$EXTERNALSYM SDL_BUTTON_LEFT}
1293 {$EXTERNALSYM SDL_BUTTON_MIDDLE}
1295 {$EXTERNALSYM SDL_BUTTON_RIGHT}
1297 {$EXTERNALSYM SDL_BUTTON_WHEELUP}
1299 {$EXTERNALSYM SDL_BUTTON_WHEELDOWN}
1301 {$EXTERNALSYM SDL_BUTTON_LMASK}
1303 {$EXTERNALSYM SDL_BUTTON_MMASK}
1305 {$EXTERNALSYM SDL_BUTTON_RMask}
1307 // SDL_active.h constants
1308 // The available application states
1310 {$EXTERNALSYM SDL_APPMOUSEFOCUS}
1312 {$EXTERNALSYM SDL_APPINPUTFOCUS}
1314 {$EXTERNALSYM SDL_APPACTIVE}
1316 // SDL_mutex.h constants
1317 // Synchronization functions which can time out return this value
1318 // they time out.
1321 {$EXTERNALSYM SDL_MUTEX_TIMEDOUT}
1323 // This is the timeout value which corresponds to never time out
1325 {$EXTERNALSYM SDL_MUTEX_MAXWAIT}
1327 {TSDL_GrabMode = (
1328 SDL_GRAB_QUERY,
1329 SDL_GRAB_OFF,
1330 SDL_GRAB_ON,
1331 SDL_GRAB_FULLSCREEN ); // Used internally}
1335 //SDL_GRAB_FULLSCREEN // Used internally
1337 type
1339 //SDL_types.h types
1340 // Basic data types
1349 {$EXTERNALSYM UInt8}
1354 {$EXTERNALSYM UInt16}
1358 {$EXTERNALSYM SInt8}
1362 {$EXTERNALSYM SInt16}
1366 {$EXTERNALSYM UInt32}
1369 {$EXTERNALSYM SInt32}
1380 {$EXTERNALSYM UInt64}
1387 {$EXTERNALSYM SInt64}
1391 // SDL_error.h types
1392 TSDL_errorcode = (
1393 SDL_ENOMEM,
1394 SDL_EFREAD,
1395 SDL_EFWRITE,
1396 SDL_EFSEEK,
1397 SDL_LASTERROR);
1400 {$EXTERNALSYM SDL_errorcode}
1405 (* #if 0 means: never
1406 1 : ( value_c : Byte );
1407 *)
1415 { This is a numeric value corresponding to the current error }
1418 { This is a key used to index into a language hashtable containing
1419 internationalized versions of the SDL error messages. If the key
1420 is not in the hashtable, or no hashtable is available, the key is
1421 used directly as an error message format string. }
1424 { These are the arguments for the error functions }
1429 // SDL_rwops.h types
1430 // This is the read/write operation structure -- very basic
1431 // some helper types to handle the unions
1432 // "packed" is only guessed
1436 // FILE * is only defined in Kylix so we use a simple Pointer
1450 // first declare the pointer type
1452 // now the pointer to function types
1453 {$IFNDEF __GPC__}
1455 TRead = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer ): Integer; cdecl;
1456 TWrite = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer ): Integer; cdecl;
1458 {$ELSE}
1460 TRead = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer ): Integer;
1463 {$ENDIF}
1464 // the variant record itself
1470 // a keyword as name is not allowed
1472 // be warned! structure alignment may arise at this point
1480 {$EXTERNALSYM SDL_RWops}
1483 // SDL_timer.h types
1484 // Function prototype for the timer callback function
1485 {$IFNDEF __GPC__}
1487 {$ELSE}
1489 {$ENDIF}
1491 { New timer API, supports multiple timers
1492 Written by Stephane Peter <megastep@lokigames.com> }
1494 { Function prototype for the new timer callback function.
1495 The callback function is passed the current timer interval and returns
1496 the next timer interval. If the returned value is the same as the one
1497 passed in, the periodic alarm continues, otherwise a new alarm is
1498 scheduled. If the callback returns 0, the periodic alarm is cancelled. }
1499 {$IFNDEF __GPC__}
1501 {$ELSE}
1503 {$ENDIF}
1505 // Definition of the timer ID type
1515 {$IFNDEF __GPC__}
1517 {$ELSE}
1519 {$ENDIF}
1521 // SDL_audio.h types
1522 // The calculated values in this structure are calculated by SDL_OpenAudio()
1532 { This function is called when the audio device needs more data.
1533 'stream' is a pointer to the audio data buffer
1534 'len' is the length of that buffer in bytes.
1535 Once the callback returns, the buffer will no longer be valid.
1536 Stereo samples are stored in a LRLRLR ordering.}
1541 // A structure to hold a set of audio conversion filters and buffers
1567 TSDL_Audiostatus = (
1568 SDL_AUDIO_STOPPED,
1569 SDL_AUDIO_PLAYING,
1570 SDL_AUDIO_PAUSED
1571 );
1573 // SDL_cdrom.h types
1574 TSDL_CDStatus = (
1575 CD_ERROR,
1576 CD_TRAYEMPTY,
1577 CD_STOPPED,
1578 CD_PLAYING,
1579 CD_PAUSED );
1590 // This structure is only current as of the last call to SDL_CDStatus()
1596 // The rest of this structure is only valid if there's a CD in drive
1603 //SDL_joystick.h types
1610 // The private structure used to keep track of a joystick
1613 // joystick ID
1615 // values used to translate device-specific coordinates into SDL-standard ranges
1625 // The SDL joystick structure
1648 // SDL_verion.h types
1656 // SDL_keyboard.h types
1669 // SDL_events.h types
1670 {Checks the event queue for messages and optionally returns them.
1671 If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
1672 the back of the event queue.
1673 If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
1674 of the event queue, matching 'mask', will be returned and will not
1675 be removed from the queue.
1676 If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
1677 of the event queue, matching 'mask', will be returned and will be
1678 removed from the queue.
1679 This function returns the number of events actually stored, or -1
1680 if there was an error. This function is thread-safe. }
1684 // Application visibility event structure
1691 // Keyboard event structure
1699 // Mouse motion event structure
1709 // Mouse button event structure
1719 // Joystick axis motion event structure
1727 // Joystick trackball motion event structure
1736 // Joystick hat position change event structure
1742 8 1 2
1743 7 0 3
1744 6 5 4
1746 Note that zero means the POV is centered. }
1750 // Joystick button event structure
1758 { The "window resized" event
1759 When you get this event, you are responsible for setting a new video
1760 mode with the new width and height. }
1767 // The "quit requested" event
1773 // A user-defined event type
1782 // The "screen redraw" event
1788 {$IFDEF Unix}
1789 //These are the various supported subsystems under UNIX
1791 {$ENDIF}
1793 // The windows custom event structure
1794 {$IFDEF WINDOWS}
1803 {$ELSE}
1805 {$IFDEF Unix}
1806 { The Linux custom event structure }
1811 {$IFDEF FPC}
1812 {$IFNDEF GP2X}
1814 {$ENDIF}
1815 {$ELSE}
1817 {$ENDIF}
1819 {$ELSE}
1820 { The generic custom event structure }
1826 {$ENDIF}
1828 {$ENDIF}
1830 // The Windows custom window manager information structure
1831 {$IFDEF WINDOWS}
1837 {$ELSE}
1839 // The Linux custom window manager information structure
1840 {$IFDEF Unix}
1841 {$IFNDEF GP2X}
1845 {* These locking functions should be called around
1846 any X11 functions using the display variable.
1847 They lock the event thread, so should not be
1848 called around event functions or from event filters.
1849 *}
1853 // Introduced in SDL 1.0.2
1857 {$ENDIF}
1863 {$IFNDEF GP2X}
1865 {$ENDIF}
1867 {$ELSE}
1868 // The generic custom window manager information structure
1874 {$ENDIF}
1876 {$ENDIF}
1903 { This function sets up a filter to process all events before they
1904 change internal state and are posted to the internal event queue.
1906 The filter is protypted as: }
1907 {$IFNDEF __GPC__}
1909 {$ELSE}
1911 {$ENDIF}
1913 // SDL_video.h types
1914 // Useful data types
1923 {$EXTERNALSYM SDL_Rect}
1942 // Everything in the pixel format structure is read-only
1964 {$IFDEF WINDOWS}
1965 {PPrivate_hwdata = ^TPrivate_hwdata;
1966 TPrivate_hwdata = record
1967 dd_surface : IDIRECTDRAWSURFACE3;
1968 dd_writebuf : IDIRECTDRAWSURFACE3;
1969 end;}
1970 {ELSE}
1971 {$ENDIF}
1973 // The structure passed to the low level blit functions
1990 // typedef for private surface blitting functions
1993 {$IFNDEF __GPC__}
1994 TSDL_Blit = function( src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect ): Integer; cdecl;
1995 {$ELSE}
1996 TSDL_Blit = function( src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect ): Integer;
1997 {$ENDIF}
1999 // The type definition for the low level blit functions
2000 //TSDL_LoBlit = procedure( info : PSDL_BlitInfo ); cdecl;
2002 // This is the private info structure for software accelerated blits
2003 {PPrivate_swaccel = ^TPrivate_swaccel;
2004 TPrivate_swaccel = record
2005 blit : TSDL_LoBlit;
2006 aux_data : Pointer;
2007 end;}
2009 // Blit mapping definition
2010 {PSDL_BlitMap = ^TSDL_BlitMap;
2011 TSDL_BlitMap = record
2012 dst : PSDL_Surface;
2013 identity : Integer;
2014 table : PUInt8;
2015 hw_blit : TSDL_Blit;
2016 sw_blit : TSDL_Blit;
2017 hw_data : PPrivate_hwaccel;
2018 sw_data : PPrivate_swaccel;
2020 // the version count matches the destination; mismatch indicates an invalid mapping
2021 format_version : Cardinal;
2022 end;}
2033 // clipping information:
2036 // Allow recursive locks
2038 // info for fast blit mapping to other surfaces
2040 // format version, bumped at every change to invalidate blit maps
2045 // Useful for determining the video hardware capabilities
2049 {hw_available: 1; // Can you create hardware surfaces
2050 wm_available: 1; // Can you talk to a window manager?
2051 UnusedBits1: 6;}
2053 {UnusedBits2: 1;
2054 blit_hw: 1; // Flag:UInt32 Accelerated blits HW --> HW
2055 blit_hw_CC: 1; // Flag:UInt32 Accelerated blits with Colorkey
2056 blit_hw_A: 1; // Flag:UInt32 Accelerated blits with Alpha
2057 blit_sw: 1; // Flag:UInt32 Accelerated blits SW --> HW
2058 blit_sw_CC: 1; // Flag:UInt32 Accelerated blits with Colorkey
2059 blit_sw_A: 1; // Flag:UInt32 Accelerated blits with Alpha
2060 blit_fill: 1; // Flag:UInt32 Accelerated color fill}
2068 // The YUV hardware video overlay
2075 // An array of pitches, one for each plane. Pitch is the length of a row in bytes.
2077 // An array of pointers to the data of each plane. The overlay should be locked before these pointers are used.
2079 // This will be set to 1 if the overlay is hardware accelerated.
2082 // Public enumeration for setting the OpenGL window attributes.
2083 TSDL_GLAttr = (
2084 SDL_GL_RED_SIZE,
2085 SDL_GL_GREEN_SIZE,
2086 SDL_GL_BLUE_SIZE,
2087 SDL_GL_ALPHA_SIZE,
2088 SDL_GL_BUFFER_SIZE,
2089 SDL_GL_DOUBLEBUFFER,
2090 SDL_GL_DEPTH_SIZE,
2091 SDL_GL_STENCIL_SIZE,
2092 SDL_GL_ACCUM_RED_SIZE,
2093 SDL_GL_ACCUM_GREEN_SIZE,
2094 SDL_GL_ACCUM_BLUE_SIZE,
2095 SDL_GL_ACCUM_ALPHA_SIZE,
2096 SDL_GL_STEREO,
2097 SDL_GL_MULTISAMPLEBUFFERS,
2098 SDL_GL_MULTISAMPLESAMPLES,
2099 SDL_GL_ACCELERATED_VISUAL,
2100 SDL_GL_SWAP_CONTROL);
2114 // SDL_mutex.h types
2116 {$IFDEF WINDOWS}
2121 {$ENDIF}
2123 {$IFDEF Unix}
2127 {$IFDEF PTHREAD_NO_RECURSIVE_MUTEX}
2130 {$ENDIF}
2132 {$ENDIF}
2134 {$IFDEF NDS}
2141 {$ENDIF}
2143 {$IFDEF MORPHOS}
2146 {$WARNING FIXME!!}
2149 {$ENDIF}
2151 {$IFDEF __MACH__}
2152 {$define USE_NAMED_SEMAPHORES}
2153 // Broken sem_getvalue() in MacOS X Public Beta */
2154 {$define BROKEN_SEMGETVALUE}
2155 {$ENDIF}
2158 {$IFDEF WINDOWS}
2159 // WINDOWS or Machintosh
2164 {$ELSE}
2165 {$IFDEF FPC}
2166 // This should be semaphore.h
2177 {$ENDIF}
2181 {$IFNDEF USE_NAMED_SEMAPHORES}
2183 {$ENDIF}
2185 {$IFDEF BROKEN_SEMGETVALUE}
2186 { This is a little hack for MacOS X -
2187 It's not thread-safe, but it's better than nothing }
2189 {$ENDIF}
2191 {$ENDIF}
2198 {$IFDEF Unix}
2200 {$ELSE}
2201 // Generic Cond structure
2207 {$ENDIF}
2210 // SDL_thread.h types
2211 {$IFDEF WINDOWS}
2213 {$ENDIF}
2215 {$IFDEF Unix}
2217 {$ENDIF}
2219 {$IFDEF NDS}
2221 {$ENDIF}
2223 {$IFDEF MORPHOS}
2225 {$ENDIF}
2227 { This is the system-independent thread info structure }
2237 // Helper Types
2239 // Keyboard State Array ( See demos for how to use )
2243 // Types required so we don't need to use Windows.pas
2249 // General arrays
2257 {$IFDEF HAS_TYPES}
2259 {$ELSE}
2260 {$IFDEF WINDOWS}
2261 {$IFDEF __GPC__}
2263 {$ELSE}
2265 {$ENDIF}
2266 {$ELSE}
2267 //Can't define TPoint : neither Types nor Windows unit available.
2268 {$ENDIF}
2269 {$ENDIF}
2272 {$IFDEF HAS_TYPES}
2274 {$ELSE}
2275 {$IFDEF WINDOWS}
2276 {$IFDEF __GPC__}
2278 {$ELSE}
2280 {$ENDIF}
2281 {$ELSE}
2282 //Can't define TRect: neither Types nor Windows unit available.
2283 {$ENDIF}
2284 {$ENDIF}
2286 { Generic procedure pointer }
2289 {------------------------------------------------------------------------------}
2290 { initialization }
2291 {------------------------------------------------------------------------------}
2293 { This function loads the SDL dynamically linked library and initializes
2294 the subsystems specified by 'flags' (and those satisfying dependencies)
2295 Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
2296 signal handlers for some commonly ignored fatal signals (like SIGSEGV) }
2298 {$IFDEF MORPHOS}
2299 {$I powersdl.inc}
2300 {$ELSE}
2302 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2303 {$EXTERNALSYM SDL_Init}
2305 // This function initializes specific SDL subsystems
2307 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2308 {$EXTERNALSYM SDL_InitSubSystem}
2310 // This function cleans up specific SDL subsystems
2312 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_QuitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2313 {$EXTERNALSYM SDL_QuitSubSystem}
2315 { This function returns mask of the specified subsystems which have
2316 been initialized.
2317 If 'flags' is 0, it returns a mask of all initialized subsystems. }
2320 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WasInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2321 {$EXTERNALSYM SDL_WasInit}
2323 { This function cleans up all initialized subsystems and unloads the
2324 dynamically linked library. You should call it upon all exit conditions. }
2326 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Quit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2327 {$EXTERNALSYM SDL_Quit}
2329 {$IFDEF WINDOWS}
2330 // This should be called from your WinMain() function, if any
2332 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RegisterApp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2333 {$EXTERNALSYM SDL_RegisterApp}
2334 {$ENDIF}
2336 {$IFDEF __MACH__}
2337 // This should be called from your main() function, if any
2339 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitQuickDraw'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2340 {$EXTERNALSYM SDL_InitQuickDraw}
2341 {$ENDIF}
2344 {------------------------------------------------------------------------------}
2345 { types }
2346 {------------------------------------------------------------------------------}
2347 // The number of elements in a table
2349 {$EXTERNALSYM SDL_TABLESIZE}
2352 {------------------------------------------------------------------------------}
2353 { error-handling }
2354 {------------------------------------------------------------------------------}
2355 // Public functions
2357 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2358 {$EXTERNALSYM SDL_GetError}
2360 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2361 {$EXTERNALSYM SDL_SetError}
2363 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ClearError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2364 {$EXTERNALSYM SDL_ClearError}
2366 {$IFNDEF WINDOWS}
2368 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Error'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2369 {$EXTERNALSYM SDL_Error}
2370 {$ENDIF}
2372 // Private error message function - used internally
2375 {------------------------------------------------------------------------------}
2376 { io handling }
2377 {------------------------------------------------------------------------------}
2378 // Functions to create SDL_RWops structures from various data sources
2381 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFile'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2382 {$EXTERNALSYM SDL_RWFromFile}
2384 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2385 {$EXTERNALSYM SDL_FreeRW}
2387 //fp is FILE *fp ???
2389 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2390 {$EXTERNALSYM SDL_RWFromFP}
2392 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2393 {$EXTERNALSYM SDL_RWFromMem}
2395 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromConstMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2396 {$EXTERNALSYM SDL_RWFromConstMem}
2398 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AllocRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2399 {$EXTERNALSYM SDL_AllocRW}
2402 {$EXTERNALSYM SDL_RWSeek}
2404 {$EXTERNALSYM SDL_RWTell}
2406 {$EXTERNALSYM SDL_RWRead}
2408 {$EXTERNALSYM SDL_RWWrite}
2410 {$EXTERNALSYM SDL_RWClose}
2412 {------------------------------------------------------------------------------}
2413 { time-handling }
2414 {------------------------------------------------------------------------------}
2416 { Get the number of milliseconds since the SDL library initialization. }
2417 { Note that this value wraps if the program runs for more than ~49 days. }
2419 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetTicks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2420 {$EXTERNALSYM SDL_GetTicks}
2422 // Wait a specified number of milliseconds before returning
2424 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Delay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2425 {$EXTERNALSYM SDL_Delay}
2427 { Add a new timer to the pool of timers already running. }
2428 { Returns a timer ID, or NULL when an error occurs. }
2429 function SDL_AddTimer(interval: UInt32; callback: TSDL_NewTimerCallback; param : Pointer): PSDL_TimerID;
2430 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AddTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2431 {$EXTERNALSYM SDL_AddTimer}
2433 { Remove one of the multiple timers knowing its ID. }
2434 { Returns a boolean value indicating success. }
2436 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RemoveTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2437 {$EXTERNALSYM SDL_RemoveTimer}
2440 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2441 {$EXTERNALSYM SDL_SetTimer}
2443 {------------------------------------------------------------------------------}
2444 { audio-routines }
2445 {------------------------------------------------------------------------------}
2447 { These functions are used internally, and should not be used unless you
2448 have a specific need to specify the audio driver you want to use.
2449 You should normally use SDL_Init() or SDL_InitSubSystem(). }
2452 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2453 {$EXTERNALSYM SDL_AudioInit}
2455 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2456 {$EXTERNALSYM SDL_AudioQuit}
2458 { This function fills the given character buffer with the name of the
2459 current audio driver, and returns a Pointer to it if the audio driver has
2460 been initialized. It returns NULL if no driver has been initialized. }
2463 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2464 {$EXTERNALSYM SDL_AudioDriverName}
2466 { This function opens the audio device with the desired parameters, and
2467 returns 0 if successful, placing the actual hardware parameters in the
2468 structure pointed to by 'obtained'. If 'obtained' is NULL, the audio
2469 data passed to the callback function will be guaranteed to be in the
2470 requested format, and will be automatically converted to the hardware
2471 audio format if necessary. This function returns -1 if it failed
2472 to open the audio device, or couldn't set up the audio thread.
2474 When filling in the desired audio spec structure,
2475 'desired->freq' should be the desired audio frequency in samples-per-second.
2476 'desired->format' should be the desired audio format.
2477 'desired->samples' is the desired size of the audio buffer, in samples.
2478 This number should be a power of two, and may be adjusted by the audio
2479 driver to a value more suitable for the hardware. Good values seem to
2480 range between 512 and 8096 inclusive, depending on the application and
2481 CPU speed. Smaller values yield faster response time, but can lead
2482 to underflow if the application is doing heavy processing and cannot
2483 fill the audio buffer in time. A stereo sample consists of both right
2484 and left channels in LR ordering.
2485 Note that the number of samples is directly related to time by the
2486 following formula: ms = (samples*1000)/freq
2487 'desired->size' is the size in bytes of the audio buffer, and is
2488 calculated by SDL_OpenAudio().
2489 'desired->silence' is the value used to set the buffer to silence,
2490 and is calculated by SDL_OpenAudio().
2491 'desired->callback' should be set to a function that will be called
2492 when the audio device is ready for more data. It is passed a pointer
2493 to the audio buffer, and the length in bytes of the audio buffer.
2494 This function usually runs in a separate thread, and so you should
2495 protect data structures that it accesses by calling SDL_LockAudio()
2496 and SDL_UnlockAudio() in your code.
2497 'desired->userdata' is passed as the first parameter to your callback
2498 function.
2500 The audio device starts out playing silence when it's opened, and should
2501 be enabled for playing by calling SDL_PauseAudio(0) when you are ready
2502 for your audio callback function to be called. Since the audio driver
2503 may modify the requested size of the audio buffer, you should allocate
2504 any local mixing buffers after you open the audio device. }
2507 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_OpenAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2508 {$EXTERNALSYM SDL_OpenAudio}
2510 { Get the current audio state: }
2512 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAudioStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2513 {$EXTERNALSYM SDL_GetAudioStatus}
2515 { This function pauses and unpauses the audio callback processing.
2516 It should be called with a parameter of 0 after opening the audio
2517 device to start playing sound. This is so you can safely initialize
2518 data for your callback function after opening the audio device.
2519 Silence will be written to the audio device during the pause. }
2522 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PauseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2523 {$EXTERNALSYM SDL_PauseAudio}
2525 { This function loads a WAVE from the data source, automatically freeing
2526 that source if 'freesrc' is non-zero. For example, to load a WAVE file,
2527 you could do:
2528 SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
2530 If this function succeeds, it returns the given SDL_AudioSpec,
2531 filled with the audio data format of the wave data, and sets
2532 'audio_buf' to a malloc()'d buffer containing the audio data,
2533 and sets 'audio_len' to the length of that audio buffer, in bytes.
2534 You need to free the audio buffer with SDL_FreeWAV() when you are
2535 done with it.
2537 This function returns NULL and sets the SDL error message if the
2538 wave file cannot be opened, uses an unknown data format, or is
2539 corrupt. Currently raw and MS-ADPCM WAVE files are supported. }
2543 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadWAV_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2544 {$EXTERNALSYM SDL_LoadWAV_RW}
2546 // Compatibility convenience function -- loads a WAV from a file
2549 {$EXTERNALSYM SDL_LoadWAV}
2551 { This function frees data previously allocated with SDL_LoadWAV_RW() }
2554 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeWAV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2555 {$EXTERNALSYM SDL_FreeWAV}
2557 { This function takes a source format and rate and a destination format
2558 and rate, and initializes the 'cvt' structure with information needed
2559 by SDL_ConvertAudio() to convert a buffer of audio data from one format
2560 to the other.
2561 This function returns 0, or -1 if there was an error. }
2565 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_BuildAudioCVT'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2566 {$EXTERNALSYM SDL_BuildAudioCVT}
2568 { Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
2569 created an audio buffer cvt->buf, and filled it with cvt->len bytes of
2570 audio data in the source format, this function will convert it in-place
2571 to the desired format.
2572 The data conversion may expand the size of the audio data, so the buffer
2573 cvt->buf should be allocated after the cvt structure is initialized by
2574 SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long. }
2576 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2577 {$EXTERNALSYM SDL_ConvertAudio}
2579 { This takes two audio buffers of the playing audio format and mixes
2580 them, performing addition, volume adjustment, and overflow clipping.
2581 The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
2582 for full audio volume. Note this does not change hardware volume.
2583 This is provided for convenience -- you can mix your own audio data. }
2586 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MixAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2587 {$EXTERNALSYM SDL_MixAudio}
2589 { The lock manipulated by these functions protects the callback function.
2590 During a LockAudio/UnlockAudio pair, you can be guaranteed that the
2591 callback function is not running. Do not call these from the callback
2592 function or you will cause deadlock. }
2594 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2595 {$EXTERNALSYM SDL_LockAudio}
2597 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2598 {$EXTERNALSYM SDL_UnlockAudio}
2600 { This function shuts down audio processing and closes the audio device. }
2603 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CloseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2604 {$EXTERNALSYM SDL_CloseAudio}
2606 {------------------------------------------------------------------------------}
2607 { CD-routines }
2608 {------------------------------------------------------------------------------}
2610 { Returns the number of CD-ROM drives on the system, or -1 if
2611 SDL_Init() has not been called with the SDL_INIT_CDROM flag. }
2614 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDNumDrives'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2615 {$EXTERNALSYM SDL_CDNumDrives}
2617 { Returns a human-readable, system-dependent identifier for the CD-ROM.
2618 Example:
2619 "/dev/cdrom"
2620 "E:"
2621 "/dev/disk/ide/1/master" }
2624 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2625 {$EXTERNALSYM SDL_CDName}
2627 { Opens a CD-ROM drive for access. It returns a drive handle on success,
2628 or NULL if the drive was invalid or busy. This newly opened CD-ROM
2629 becomes the default CD used when other CD functions are passed a NULL
2630 CD-ROM handle.
2631 Drives are numbered starting with 0. Drive 0 is the system default CD-ROM. }
2634 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2635 {$EXTERNALSYM SDL_CDOpen}
2637 { This function returns the current status of the given drive.
2638 If the drive has a CD in it, the table of contents of the CD and current
2639 play position of the CD will be stored in the SDL_CD structure. }
2642 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2643 {$EXTERNALSYM SDL_CDStatus}
2645 { Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'
2646 tracks and 'nframes' frames. If both 'ntrack' and 'nframe' are 0, play
2647 until the end of the CD. This function will skip data tracks.
2648 This function should only be called after calling SDL_CDStatus() to
2649 get track information about the CD.
2651 For example:
2652 // Play entire CD:
2653 if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
2654 SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
2655 // Play last track:
2656 if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
2657 begin
2658 SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
2659 end;
2661 // Play first and second track and 10 seconds of third track:
2662 if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
2663 SDL_CDPlayTracks(cdrom, 0, 0, 2, 10);
2665 This function returns 0, or -1 if there was an error. }
2669 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlayTracks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2670 {$EXTERNALSYM SDL_CDPlayTracks}
2673 { Play the given CD starting at 'start' frame for 'length' frames.
2674 It returns 0, or -1 if there was an error. }
2677 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2678 {$EXTERNALSYM SDL_CDPlay}
2680 // Pause play -- returns 0, or -1 on error
2682 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPause'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2683 {$EXTERNALSYM SDL_CDPause}
2685 // Resume play -- returns 0, or -1 on error
2687 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDResume'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2688 {$EXTERNALSYM SDL_CDResume}
2690 // Stop play -- returns 0, or -1 on error
2692 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStop'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2693 {$EXTERNALSYM SDL_CDStop}
2695 // Eject CD-ROM -- returns 0, or -1 on error
2697 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDEject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2698 {$EXTERNALSYM SDL_CDEject}
2700 // Closes the handle for the CD-ROM drive
2702 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2703 {$EXTERNALSYM SDL_CDClose}
2705 // Given a status, returns true if there's a disk in the drive
2707 {$EXTERNALSYM SDL_CDInDrive}
2709 // Conversion functions from frames to Minute/Second/Frames and vice versa
2712 {$EXTERNALSYM FRAMES_TO_MSF}
2714 {$EXTERNALSYM MSF_TO_FRAMES}
2716 {------------------------------------------------------------------------------}
2717 { JoyStick-routines }
2718 {------------------------------------------------------------------------------}
2720 { Count the number of joysticks attached to the system }
2722 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_NumJoysticks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2723 {$EXTERNALSYM SDL_NumJoysticks}
2725 { Get the implementation dependent name of a joystick.
2726 This can be called before any joysticks are opened.
2727 If no name can be found, this function returns NULL. }
2729 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2730 {$EXTERNALSYM SDL_JoystickName}
2732 { Open a joystick for use - the index passed as an argument refers to
2733 the N'th joystick on the system. This index is the value which will
2734 identify this joystick in future joystick events.
2736 This function returns a joystick identifier, or NULL if an error occurred. }
2738 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2739 {$EXTERNALSYM SDL_JoystickOpen}
2741 { Returns 1 if the joystick has been opened, or 0 if it has not. }
2743 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpened'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2744 {$EXTERNALSYM SDL_JoystickOpened}
2746 { Get the device index of an opened joystick. }
2748 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickIndex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2749 {$EXTERNALSYM SDL_JoystickIndex}
2751 { Get the number of general axis controls on a joystick }
2753 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumAxes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2754 {$EXTERNALSYM SDL_JoystickNumAxes}
2756 { Get the number of trackballs on a joystick
2757 Joystick trackballs have only relative motion events associated
2758 with them and their state cannot be polled. }
2760 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumBalls'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2761 {$EXTERNALSYM SDL_JoystickNumBalls}
2764 { Get the number of POV hats on a joystick }
2766 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumHats'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2767 {$EXTERNALSYM SDL_JoystickNumHats}
2769 { Get the number of buttons on a joystick }
2771 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumButtons'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2772 {$EXTERNALSYM SDL_JoystickNumButtons}
2774 { Update the current state of the open joysticks.
2775 This is called automatically by the event loop if any joystick
2776 events are enabled. }
2779 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickUpdate'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2780 {$EXTERNALSYM SDL_JoystickUpdate;}
2782 { Enable/disable joystick event polling.
2783 If joystick events are disabled, you must call SDL_JoystickUpdate()
2784 yourself and check the state of the joystick when you want joystick
2785 information.
2786 The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE. }
2789 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickEventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2790 {$EXTERNALSYM SDL_JoystickEventState}
2792 { Get the current state of an axis control on a joystick
2793 The state is a value ranging from -32768 to 32767.
2794 The axis indices start at index 0. }
2797 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetAxis'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2798 {$EXTERNALSYM SDL_JoystickGetAxis}
2800 { The hat indices start at index 0. }
2803 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetHat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2804 {$EXTERNALSYM SDL_JoystickGetHat}
2806 { Get the ball axis change since the last poll
2807 This returns 0, or -1 if you passed it invalid parameters.
2808 The ball indices start at index 0. }
2810 function SDL_JoystickGetBall(joystick: PSDL_Joystick; ball: Integer; var dx: Integer; var dy: Integer): Integer;
2811 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetBall'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2812 {$EXTERNALSYM SDL_JoystickGetBall}
2814 { Get the current state of a button on a joystick
2815 The button indices start at index 0. }
2817 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetButton'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2818 {$EXTERNALSYM SDL_JoystickGetButton}
2820 { Close a joystick previously opened with SDL_JoystickOpen() }
2822 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2823 {$EXTERNALSYM SDL_JoystickClose}
2825 {------------------------------------------------------------------------------}
2826 { event-handling }
2827 {------------------------------------------------------------------------------}
2829 { Pumps the event loop, gathering events from the input devices.
2830 This function updates the event queue and internal input device state.
2831 This should only be run in the thread that sets the video mode. }
2834 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PumpEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2835 {$EXTERNALSYM SDL_PumpEvents;}
2837 { Checks the event queue for messages and optionally returns them.
2838 If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
2839 the back of the event queue.
2840 If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
2841 of the event queue, matching 'mask', will be returned and will not
2842 be removed from the queue.
2843 If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
2844 of the event queue, matching 'mask', will be returned and will be
2845 removed from the queue.
2846 This function returns the number of events actually stored, or -1
2847 if there was an error. This function is thread-safe. }
2849 function SDL_PeepEvents(events: PSDL_Event; numevents: Integer; action: TSDL_eventaction; mask: UInt32): Integer;
2850 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PeepEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2851 {$EXTERNALSYM SDL_PeepEvents}
2853 { Polls for currently pending events, and returns 1 if there are any pending
2854 events, or 0 if there are none available. If 'event' is not NULL, the next
2855 event is removed from the queue and stored in that area. }
2858 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PollEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2859 {$EXTERNALSYM SDL_PollEvent}
2861 { Waits indefinitely for the next available event, returning 1, or 0 if there
2862 was an error while waiting for events. If 'event' is not NULL, the next
2863 event is removed from the queue and stored in that area. }
2866 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2867 {$EXTERNALSYM SDL_WaitEvent}
2870 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PushEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2871 {$EXTERNALSYM SDL_PushEvent}
2873 { If the filter returns 1, then the event will be added to the internal queue.
2874 If it returns 0, then the event will be dropped from the queue, but the
2875 internal state will still be updated. This allows selective filtering of
2876 dynamically arriving events.
2878 WARNING: Be very careful of what you do in the event filter function, as
2879 it may run in a different thread!
2881 There is one caveat when dealing with the SDL_QUITEVENT event type. The
2882 event filter is only called when the window manager desires to close the
2883 application window. If the event filter returns 1, then the window will
2884 be closed, otherwise the window will remain open if possible.
2885 If the quit event is generated by an interrupt signal, it will bypass the
2886 internal queue and be delivered to the application at the next event poll. }
2888 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2889 {$EXTERNALSYM SDL_SetEventFilter}
2891 { Return the current event filter - can be used to "chain" filters.
2892 If there is no event filter set, this function returns NULL. }
2895 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2896 {$EXTERNALSYM SDL_GetEventFilter}
2898 { This function allows you to set the state of processing certain events.
2899 If 'state' is set to SDL_IGNORE, that event will be automatically dropped
2900 from the event queue and will not event be filtered.
2901 If 'state' is set to SDL_ENABLE, that event will be processed normally.
2902 If 'state' is set to SDL_QUERY, SDL_EventState() will return the
2903 current processing state of the specified event. }
2906 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2907 {$EXTERNALSYM SDL_EventState}
2909 {------------------------------------------------------------------------------}
2910 { Version Routines }
2911 {------------------------------------------------------------------------------}
2913 { This macro can be used to fill a version structure with the compile-time
2914 version of the SDL library. }
2916 {$EXTERNALSYM SDL_VERSION}
2918 { This macro turns the version numbers into a numeric value:
2919 (1,2,3) -> (1203)
2920 This assumes that there will never be more than 100 patchlevels }
2923 {$EXTERNALSYM SDL_VERSIONNUM}
2925 // This is the version number macro for the current SDL version
2927 {$EXTERNALSYM SDL_COMPILEDVERSION}
2929 // This macro will evaluate to true if compiled with SDL at least X.Y.Z
2931 {$EXTERNALSYM SDL_VERSION_ATLEAST}
2933 { This function gets the version of the dynamically linked SDL library.
2934 it should NOT be used to fill a version structure, instead you should
2935 use the SDL_Version() macro. }
2938 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Linked_Version'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2939 {$EXTERNALSYM SDL_Linked_Version}
2941 {------------------------------------------------------------------------------}
2942 { video }
2943 {------------------------------------------------------------------------------}
2945 { These functions are used internally, and should not be used unless you
2946 have a specific need to specify the video driver you want to use.
2947 You should normally use SDL_Init() or SDL_InitSubSystem().
2949 SDL_VideoInit() initializes the video subsystem -- sets up a connection
2950 to the window manager, etc, and determines the current video mode and
2951 pixel format, but does not initialize a window or graphics mode.
2952 Note that event handling is activated by this routine.
2954 If you use both sound and video in your application, you need to call
2955 SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
2956 you won't be able to set full-screen display modes. }
2959 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2960 {$EXTERNALSYM SDL_VideoInit}
2962 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2963 {$EXTERNALSYM SDL_VideoQuit}
2965 { This function fills the given character buffer with the name of the
2966 video driver, and returns a pointer to it if the video driver has
2967 been initialized. It returns NULL if no driver has been initialized. }
2970 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2971 {$EXTERNALSYM SDL_VideoDriverName}
2973 { This function returns a pointer to the current display surface.
2974 If SDL is doing format conversion on the display surface, this
2975 function returns the publicly visible surface, not the real video
2976 surface. }
2979 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2980 {$EXTERNALSYM SDL_GetVideoSurface}
2982 { This function returns a read-only pointer to information about the
2983 video hardware. If this is called before SDL_SetVideoMode(), the 'vfmt'
2984 member of the returned structure will contain the pixel format of the
2985 "best" video mode. }
2987 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2988 {$EXTERNALSYM SDL_GetVideoInfo}
2990 { Check to see if a particular video mode is supported.
2991 It returns 0 if the requested mode is not supported under any bit depth,
2992 or returns the bits-per-pixel of the closest available mode with the
2993 given width and height. If this bits-per-pixel is different from the
2994 one used when setting the video mode, SDL_SetVideoMode() will succeed,
2995 but will emulate the requested bits-per-pixel with a shadow surface.
2997 The arguments to SDL_VideoModeOK() are the same ones you would pass to
2998 SDL_SetVideoMode() }
3001 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoModeOK'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3002 {$EXTERNALSYM SDL_VideoModeOK}
3004 { Return a pointer to an array of available screen dimensions for the
3005 given format and video flags, sorted largest to smallest. Returns
3006 NULL if there are no dimensions available for a particular format,
3007 or (SDL_Rect **)-1 if any dimension is okay for the given format.
3009 if 'format' is NULL, the mode list will be for the format given
3010 by SDL_GetVideoInfo( ) - > vfmt }
3013 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ListModes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3014 {$EXTERNALSYM SDL_ListModes}
3017 { Set up a video mode with the specified width, height and bits-per-pixel.
3019 If 'bpp' is 0, it is treated as the current display bits per pixel.
3021 If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
3022 requested bits-per-pixel, but will return whatever video pixel format is
3023 available. The default is to emulate the requested pixel format if it
3024 is not natively available.
3026 If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
3027 video memory, if possible, and you may have to call SDL_LockSurface()
3028 in order to access the raw framebuffer. Otherwise, the video surface
3029 will be created in system memory.
3031 If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
3032 updates asynchronously, but you must always lock before accessing pixels.
3033 SDL will wait for updates to complete before returning from the lock.
3035 If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
3036 that the colors set by SDL_SetColors() will be the colors you get.
3037 Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
3038 of the colors exactly the way they are requested, and you should look
3039 at the video surface structure to determine the actual palette.
3040 If SDL cannot guarantee that the colors you request can be set,
3041 i.e. if the colormap is shared, then the video surface may be created
3042 under emulation in system memory, overriding the SDL_HWSURFACE flag.
3044 If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
3045 a fullscreen video mode. The default is to create a windowed mode
3046 if the current graphics system has a window manager.
3047 If the SDL library is able to set a fullscreen video mode, this flag
3048 will be set in the surface that is returned.
3050 If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
3051 two surfaces in video memory and swap between them when you call
3052 SDL_Flip(). This is usually slower than the normal single-buffering
3053 scheme, but prevents "tearing" artifacts caused by modifying video
3054 memory while the monitor is refreshing. It should only be used by
3055 applications that redraw the entire screen on every update.
3057 This function returns the video framebuffer surface, or NULL if it fails. }
3060 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetVideoMode'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3061 {$EXTERNALSYM SDL_SetVideoMode}
3064 { Makes sure the given list of rectangles is updated on the given screen.
3065 If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
3066 screen.
3067 These functions should not be called while 'screen' is locked. }
3070 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3071 {$EXTERNALSYM SDL_UpdateRects}
3073 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3074 {$EXTERNALSYM SDL_UpdateRect}
3077 { On hardware that supports double-buffering, this function sets up a flip
3078 and returns. The hardware will wait for vertical retrace, and then swap
3079 video buffers before the next video surface blit or lock will return.
3080 On hardware that doesn not support double-buffering, this is equivalent
3081 to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
3082 The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
3083 setting the video mode for this function to perform hardware flipping.
3084 This function returns 0 if successful, or -1 if there was an error.}
3087 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Flip'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3088 {$EXTERNALSYM SDL_Flip}
3090 { Set the gamma correction for each of the color channels.
3091 The gamma values range (approximately) between 0.1 and 10.0
3093 If this function isn't supported directly by the hardware, it will
3094 be emulated using gamma ramps, if available. If successful, this
3095 function returns 0, otherwise it returns -1. }
3098 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGamma'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3099 {$EXTERNALSYM SDL_SetGamma}
3101 { Set the gamma translation table for the red, green, and blue channels
3102 of the video hardware. Each table is an array of 256 16-bit quantities,
3103 representing a mapping between the input and output for that channel.
3104 The input is the index into the array, and the output is the 16-bit
3105 gamma value at that index, scaled to the output color precision.
3107 You may pass NULL for any of the channels to leave it unchanged.
3108 If the call succeeds, it will return 0. If the display driver or
3109 hardware does not support gamma translation, or otherwise fails,
3110 this function will return -1. }
3112 function SDL_SetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;
3113 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3114 {$EXTERNALSYM SDL_SetGammaRamp}
3116 { Retrieve the current values of the gamma translation tables.
3118 You must pass in valid pointers to arrays of 256 16-bit quantities.
3119 Any of the pointers may be NULL to ignore that channel.
3120 If the call succeeds, it will return 0. If the display driver or
3121 hardware does not support gamma translation, or otherwise fails,
3122 this function will return -1. }
3124 function SDL_GetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;
3125 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3126 {$EXTERNALSYM SDL_GetGammaRamp}
3128 { Sets a portion of the colormap for the given 8-bit surface. If 'surface'
3129 is not a palettized surface, this function does nothing, returning 0.
3130 If all of the colors were set as passed to SDL_SetColors(), it will
3131 return 1. If not all the color entries were set exactly as given,
3132 it will return 0, and you should look at the surface palette to
3133 determine the actual color palette.
3135 When 'surface' is the surface associated with the current display, the
3136 display colormap will be updated with the requested colors. If
3137 SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
3138 will always return 1, and the palette is guaranteed to be set the way
3139 you desire, even if the window colormap has to be warped or run under
3140 emulation. }
3143 function SDL_SetColors(surface: PSDL_Surface; colors: PSDL_Color; firstcolor : Integer; ncolors: Integer) : Integer;
3144 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColors'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3145 {$EXTERNALSYM SDL_SetColors}
3147 { Sets a portion of the colormap for a given 8-bit surface.
3148 'flags' is one or both of:
3149 SDL_LOGPAL -- set logical palette, which controls how blits are mapped
3150 to/from the surface,
3151 SDL_PHYSPAL -- set physical palette, which controls how pixels look on
3152 the screen
3153 Only screens have physical palettes. Separate change of physical/logical
3154 palettes is only possible if the screen has SDL_HWPALETTE set.
3156 The return value is 1 if all colours could be set as requested, and 0
3157 otherwise.
3159 SDL_SetColors() is equivalent to calling this function with
3160 flags = (SDL_LOGPAL or SDL_PHYSPAL). }
3162 function SDL_SetPalette(surface: PSDL_Surface; flags: Integer; colors: PSDL_Color; firstcolor: Integer; ncolors: Integer): Integer;
3163 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetPalette'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3164 {$EXTERNALSYM SDL_SetPalette}
3166 { Maps an RGB triple to an opaque pixel value for a given pixel format }
3168 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3169 {$EXTERNALSYM SDL_MapRGB}
3171 { Maps an RGBA quadruple to a pixel value for a given pixel format }
3172 function SDL_MapRGBA(format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8; a: UInt8): UInt32;
3173 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3174 {$EXTERNALSYM SDL_MapRGBA}
3176 { Maps a pixel value into the RGB components for a given pixel format }
3178 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3179 {$EXTERNALSYM SDL_GetRGB}
3181 { Maps a pixel value into the RGBA components for a given pixel format }
3182 procedure SDL_GetRGBA(pixel: UInt32; fmt: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8);
3183 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3184 {$EXTERNALSYM SDL_GetRGBA}
3186 { Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
3187 If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
3188 If the depth is greater than 8 bits, the pixel format is set using the
3189 flags '[RGB]mask'.
3190 If the function runs out of memory, it will return NULL.
3192 The 'flags' tell what kind of surface to create.
3193 SDL_SWSURFACE means that the surface should be created in system memory.
3194 SDL_HWSURFACE means that the surface should be created in video memory,
3195 with the same format as the display surface. This is useful for surfaces
3196 that will not change much, to take advantage of hardware acceleration
3197 when being blitted to the display surface.
3198 SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
3199 this surface, but you must always lock it before accessing the pixels.
3200 SDL will wait for current blits to finish before returning from the lock.
3201 SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
3202 If the hardware supports acceleration of colorkey blits between
3203 two surfaces in video memory, SDL will try to place the surface in
3204 video memory. If this isn't possible or if there is no hardware
3205 acceleration available, the surface will be placed in system memory.
3206 SDL_SRCALPHA means that the surface will be used for alpha blits and
3207 if the hardware supports hardware acceleration of alpha blits between
3208 two surfaces in video memory, to place the surface in video memory
3209 if possible, otherwise it will be placed in system memory.
3210 If the surface is created in video memory, blits will be _much_ faster,
3211 but the surface format must be identical to the video surface format,
3212 and the only way to access the pixels member of the surface is to use
3213 the SDL_LockSurface() and SDL_UnlockSurface() calls.
3214 If the requested surface actually resides in video memory, SDL_HWSURFACE
3215 will be set in the flags member of the returned surface. If for some
3216 reason the surface could not be placed in video memory, it will not have
3217 the SDL_HWSURFACE flag set, and will be created in system memory instead. }
3221 {$EXTERNALSYM SDL_AllocSurface}
3223 function SDL_CreateRGBSurface(flags: UInt32; width, height, depth: Integer; RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
3224 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3225 {$EXTERNALSYM SDL_CreateRGBSurface}
3229 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurfaceFrom'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3230 {$EXTERNALSYM SDL_CreateRGBSurfaceFrom}
3233 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3234 {$EXTERNALSYM SDL_FreeSurface}
3237 {$EXTERNALSYM SDL_MustLock}
3238 { SDL_LockSurface() sets up a surface for directly accessing the pixels.
3239 Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
3240 to and read from 'surface->pixels', using the pixel format stored in
3241 'surface->format'. Once you are done accessing the surface, you should
3242 use SDL_UnlockSurface() to release it.
3244 Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates
3245 to 0, then you can read and write to the surface at any time, and the
3246 pixel format of the surface will not change. In particular, if the
3247 SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
3248 will not need to lock the display surface before accessing it.
3250 No operating system or library calls should be made between lock/unlock
3251 pairs, as critical system locks may be held during this time.
3253 SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked. }
3255 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3256 {$EXTERNALSYM SDL_LockSurface}
3259 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3260 {$EXTERNALSYM SDL_UnlockSurface}
3262 { Load a surface from a seekable SDL data source (memory or file.)
3263 If 'freesrc' is non-zero, the source will be closed after being read.
3264 Returns the new surface, or NULL if there was an error.
3265 The new surface should be freed with SDL_FreeSurface(). }
3267 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3268 {$EXTERNALSYM SDL_LoadBMP_RW}
3270 // Convenience macro -- load a surface from a file
3272 {$EXTERNALSYM SDL_LoadBMP}
3274 { Save a surface to a seekable SDL data source (memory or file.)
3275 If 'freedst' is non-zero, the source will be closed after being written.
3276 Returns 0 if successful or -1 if there was an error. }
3279 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SaveBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3280 {$EXTERNALSYM SDL_SaveBMP_RW}
3282 // Convenience macro -- save a surface to a file
3284 {$EXTERNALSYM SDL_SaveBMP}
3286 { Sets the color key (transparent pixel) in a blittable surface.
3287 If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
3288 'key' will be the transparent pixel in the source image of a blit.
3289 SDL_RLEACCEL requests RLE acceleration for the surface if present,
3290 and removes RLE acceleration if absent.
3291 If 'flag' is 0, this function clears any current color key.
3292 This function returns 0, or -1 if there was an error. }
3295 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColorKey'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3296 {$EXTERNALSYM SDL_SetColorKey}
3298 { This function sets the alpha value for the entire surface, as opposed to
3299 using the alpha component of each pixel. This value measures the range
3300 of transparency of the surface, 0 being completely transparent to 255
3301 being completely opaque. An 'alpha' value of 255 causes blits to be
3302 opaque, the source pixels copied to the destination (the default). Note
3303 that per-surface alpha can be combined with colorkey transparency.
3305 If 'flag' is 0, alpha blending is disabled for the surface.
3306 If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
3307 OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
3308 surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed. }
3312 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3313 {$EXTERNALSYM SDL_SetAlpha}
3315 { Sets the clipping rectangle for the destination surface in a blit.
3317 If the clip rectangle is NULL, clipping will be disabled.
3318 If the clip rectangle doesn't intersect the surface, the function will
3319 return SDL_FALSE and blits will be completely clipped. Otherwise the
3320 function returns SDL_TRUE and blits to the surface will be clipped to
3321 the intersection of the surface area and the clipping rectangle.
3323 Note that blits are automatically clipped to the edges of the source
3324 and destination surfaces. }
3326 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3327 {$EXTERNALSYM SDL_SetClipRect}
3329 { Gets the clipping rectangle for the destination surface in a blit.
3330 'rect' must be a pointer to a valid rectangle which will be filled
3331 with the correct values. }
3333 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3334 {$EXTERNALSYM SDL_GetClipRect}
3336 { Creates a new surface of the specified format, and then copies and maps
3337 the given surface to it so the blit of the converted surface will be as
3338 fast as possible. If this function fails, it returns NULL.
3340 The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
3341 semantics. You can also pass SDL_RLEACCEL in the flags parameter and
3342 SDL will try to RLE accelerate colorkey and alpha blits in the resulting
3343 surface.
3345 This function is used internally by SDL_DisplayFormat(). }
3347 function SDL_ConvertSurface(src: PSDL_Surface; fmt: PSDL_PixelFormat; flags: UInt32): PSDL_Surface;
3348 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3349 {$EXTERNALSYM SDL_ConvertSurface}
3351 {
3352 This performs a fast blit from the source surface to the destination
3353 surface. It assumes that the source and destination rectangles are
3354 the same size. If either 'srcrect' or 'dstrect' are NULL, the entire
3355 surface (src or dst) is copied. The final blit rectangles are saved
3356 in 'srcrect' and 'dstrect' after all clipping is performed.
3357 If the blit is successful, it returns 0, otherwise it returns -1.
3359 The blit function should not be called on a locked surface.
3361 The blit semantics for surfaces with and without alpha and colorkey
3362 are defined as follows:
3364 RGBA->RGB:
3365 SDL_SRCALPHA set:
3366 alpha-blend (using alpha-channel).
3367 SDL_SRCCOLORKEY ignored.
3368 SDL_SRCALPHA not set:
3369 copy RGB.
3370 if SDL_SRCCOLORKEY set, only copy the pixels matching the
3371 RGB values of the source colour key, ignoring alpha in the
3372 comparison.
3374 RGB->RGBA:
3375 SDL_SRCALPHA set:
3376 alpha-blend (using the source per-surface alpha value);
3377 set destination alpha to opaque.
3378 SDL_SRCALPHA not set:
3379 copy RGB, set destination alpha to opaque.
3380 both:
3381 if SDL_SRCCOLORKEY set, only copy the pixels matching the
3382 source colour key.
3384 RGBA->RGBA:
3385 SDL_SRCALPHA set:
3386 alpha-blend (using the source alpha channel) the RGB values;
3387 leave destination alpha untouched. [Note: is this correct?]
3388 SDL_SRCCOLORKEY ignored.
3389 SDL_SRCALPHA not set:
3390 copy all of RGBA to the destination.
3391 if SDL_SRCCOLORKEY set, only copy the pixels matching the
3392 RGB values of the source colour key, ignoring alpha in the
3393 comparison.
3395 RGB->RGB:
3396 SDL_SRCALPHA set:
3397 alpha-blend (using the source per-surface alpha value).
3398 SDL_SRCALPHA not set:
3399 copy RGB.
3400 both:
3401 if SDL_SRCCOLORKEY set, only copy the pixels matching the
3402 source colour key.
3404 If either of the surfaces were in video memory, and the blit returns -2,
3405 the video memory was lost, so it should be reloaded with artwork and
3406 re-blitted:
3407 while ( SDL_BlitSurface(image, imgrect, screen, dstrect) = -2 ) do
3408 begin
3409 while ( SDL_LockSurface(image) < 0 ) do
3410 Sleep(10);
3411 -- Write image pixels to image->pixels --
3412 SDL_UnlockSurface(image);
3413 end;
3415 This happens under DirectX 5.0 when the system switches away from your
3416 fullscreen application. The lock will also fail until you have access
3417 to the video memory again. }
3419 { You should call SDL_BlitSurface() unless you know exactly how SDL
3420 blitting works internally and how to use the other blit functions. }
3422 function SDL_BlitSurface(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3423 {$EXTERNALSYM SDL_BlitSurface}
3425 { This is the public blit function, SDL_BlitSurface(), and it performs
3426 rectangle validation and clipping before passing it to SDL_LowerBlit() }
3427 function SDL_UpperBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3428 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpperBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3429 {$EXTERNALSYM SDL_UpperBlit}
3431 { This is a semi-private blit function and it performs low-level surface
3432 blitting only. }
3433 function SDL_LowerBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3434 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LowerBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3435 {$EXTERNALSYM SDL_LowerBlit}
3437 { This function performs a fast fill of the given rectangle with 'color'
3438 The given rectangle is clipped to the destination surface clip area
3439 and the final fill rectangle is saved in the passed in pointer.
3440 If 'dstrect' is NULL, the whole surface will be filled with 'color'
3441 The color should be a pixel of the format used by the surface, and
3442 can be generated by the SDL_MapRGB() function.
3443 This function returns 0 on success, or -1 on error. }
3446 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FillRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3447 {$EXTERNALSYM SDL_FillRect}
3449 { This function takes a surface and copies it to a new surface of the
3450 pixel format and colors of the video framebuffer, suitable for fast
3451 blitting onto the display surface. It calls SDL_ConvertSurface()
3453 If you want to take advantage of hardware colorkey or alpha blit
3454 acceleration, you should set the colorkey and alpha value before
3455 calling this function.
3457 If the conversion fails or runs out of memory, it returns NULL }
3460 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3461 {$EXTERNALSYM SDL_DisplayFormat}
3463 { This function takes a surface and copies it to a new surface of the
3464 pixel format and colors of the video framebuffer (if possible),
3465 suitable for fast alpha blitting onto the display surface.
3466 The new surface will always have an alpha channel.
3468 If you want to take advantage of hardware colorkey or alpha blit
3469 acceleration, you should set the colorkey and alpha value before
3470 calling this function.
3472 If the conversion fails or runs out of memory, it returns NULL }
3476 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormatAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3477 {$EXTERNALSYM SDL_DisplayFormatAlpha}
3479 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
3480 //* YUV video surface overlay functions */
3481 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
3483 { This function creates a video output overlay
3484 Calling the returned surface an overlay is something of a misnomer because
3485 the contents of the display surface underneath the area where the overlay
3486 is shown is undefined - it may be overwritten with the converted YUV data. }
3488 function SDL_CreateYUVOverlay(width: Integer; height: Integer; format: UInt32; display: PSDL_Surface): PSDL_Overlay;
3489 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3490 {$EXTERNALSYM SDL_CreateYUVOverlay}
3492 // Lock an overlay for direct access, and unlock it when you are done
3494 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3495 {$EXTERNALSYM SDL_LockYUVOverlay}
3498 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3499 {$EXTERNALSYM SDL_UnlockYUVOverlay}
3502 { Blit a video overlay to the display surface.
3503 The contents of the video surface underneath the blit destination are
3504 not defined.
3505 The width and height of the destination rectangle may be different from
3506 that of the overlay, but currently only 2x scaling is supported. }
3509 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3510 {$EXTERNALSYM SDL_DisplayYUVOverlay}
3512 // Free a video overlay
3514 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3515 {$EXTERNALSYM SDL_FreeYUVOverlay}
3517 {------------------------------------------------------------------------------}
3518 { OpenGL Routines }
3519 {------------------------------------------------------------------------------}
3521 { Dynamically load a GL driver, if SDL is built with dynamic GL.
3523 SDL links normally with the OpenGL library on your system by default,
3524 but you can compile it to dynamically load the GL driver at runtime.
3525 If you do this, you need to retrieve all of the GL functions used in
3526 your program from the dynamic library using SDL_GL_GetProcAddress().
3528 This is disabled in default builds of SDL. }
3532 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_LoadLibrary'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3533 {$EXTERNALSYM SDL_GL_LoadLibrary}
3535 { Get the address of a GL function (for extension functions) }
3537 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetProcAddress'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3538 {$EXTERNALSYM SDL_GL_GetProcAddress}
3540 { Set an attribute of the OpenGL subsystem before intialization. }
3542 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3543 {$EXTERNALSYM SDL_GL_SetAttribute}
3545 { Get an attribute of the OpenGL subsystem from the windowing
3546 interface, such as glX. This is of course different from getting
3547 the values from SDL's internal OpenGL subsystem, which only
3548 stores the values you request before initialization.
3550 Developers should track the values they pass into SDL_GL_SetAttribute
3551 themselves if they want to retrieve these values. }
3554 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3555 {$EXTERNALSYM SDL_GL_GetAttribute}
3557 { Swap the OpenGL buffers, if double-buffering is supported. }
3560 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SwapBuffers'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3561 {$EXTERNALSYM SDL_GL_SwapBuffers;}
3563 { Internal functions that should not be called unless you have read
3564 and understood the source code for these functions. }
3567 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3568 {$EXTERNALSYM SDL_GL_UpdateRects}
3570 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Lock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3571 {$EXTERNALSYM SDL_GL_Lock;}
3573 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Unlock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3574 {$EXTERNALSYM SDL_GL_Unlock;}
3576 {* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
3577 {* These functions allow interaction with the window manager, if any. *}
3578 {* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
3580 { Sets/Gets the title and icon text of the display window }
3582 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3583 {$EXTERNALSYM SDL_WM_GetCaption}
3585 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3586 {$EXTERNALSYM SDL_WM_SetCaption}
3588 { Sets the icon for the display window.
3589 This function must be called before the first call to SDL_SetVideoMode().
3590 It takes an icon surface, and a mask in MSB format.
3591 If 'mask' is NULL, the entire icon surface will be used as the icon. }
3593 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetIcon'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3594 {$EXTERNALSYM SDL_WM_SetIcon}
3596 { This function iconifies the window, and returns 1 if it succeeded.
3597 If the function succeeds, it generates an SDL_APPACTIVE loss event.
3598 This function is a noop and returns 0 in non-windowed environments. }
3601 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_IconifyWindow'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3602 {$EXTERNALSYM SDL_WM_IconifyWindow}
3604 { Toggle fullscreen mode without changing the contents of the screen.
3605 If the display surface does not require locking before accessing
3606 the pixel information, then the memory pointers will not change.
3608 If this function was able to toggle fullscreen mode (change from
3609 running in a window to fullscreen, or vice-versa), it will return 1.
3610 If it is not implemented, or fails, it returns 0.
3612 The next call to SDL_SetVideoMode() will set the mode fullscreen
3613 attribute based on the flags parameter - if SDL_FULLSCREEN is not
3614 set, then the display will be windowed by default where supported.
3616 This is currently only implemented in the X11 video driver. }
3619 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_ToggleFullScreen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3620 {$EXTERNALSYM SDL_WM_ToggleFullScreen}
3622 { Grabbing means that the mouse is confined to the application window,
3623 and nearly all keyboard input is passed directly to the application,
3624 and not interpreted by a window manager, if any. }
3627 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GrabInput'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3628 {$EXTERNALSYM SDL_WM_GrabInput}
3630 {------------------------------------------------------------------------------}
3631 { mouse-routines }
3632 {------------------------------------------------------------------------------}
3634 { Retrieve the current state of the mouse.
3635 The current button state is returned as a button bitmask, which can
3636 be tested using the SDL_BUTTON(X) macros, and x and y are set to the
3637 current mouse cursor position. You can pass NULL for either x or y. }
3640 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3641 {$EXTERNALSYM SDL_GetMouseState}
3643 { Retrieve the current state of the mouse.
3644 The current button state is returned as a button bitmask, which can
3645 be tested using the SDL_BUTTON(X) macros, and x and y are set to the
3646 mouse deltas since the last call to SDL_GetRelativeMouseState(). }
3648 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRelativeMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3649 {$EXTERNALSYM SDL_GetRelativeMouseState}
3651 { Set the position of the mouse cursor (generates a mouse motion event) }
3653 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WarpMouse'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3654 {$EXTERNALSYM SDL_WarpMouse}
3656 { Create a cursor using the specified data and mask (in MSB format).
3657 The cursor width must be a multiple of 8 bits.
3659 The cursor is created in black and white according to the following:
3660 data mask resulting pixel on screen
3661 0 1 White
3662 1 1 Black
3663 0 0 Transparent
3664 1 0 Inverted color if possible, black if not.
3666 Cursors created with this function must be freed with SDL_FreeCursor(). }
3668 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3669 {$EXTERNALSYM SDL_CreateCursor}
3671 { Set the currently active cursor to the specified one.
3672 If the cursor is currently visible, the change will be immediately
3673 represented on the display. }
3675 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3676 {$EXTERNALSYM SDL_SetCursor}
3678 { Returns the currently active cursor. }
3680 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3681 {$EXTERNALSYM SDL_GetCursor}
3683 { Deallocates a cursor created with SDL_CreateCursor(). }
3685 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3686 {$EXTERNALSYM SDL_FreeCursor}
3688 { Toggle whether or not the cursor is shown on the screen.
3689 The cursor start off displayed, but can be turned off.
3690 SDL_ShowCursor() returns 1 if the cursor was being displayed
3691 before the call, or 0 if it was not. You can query the current
3692 state by passing a 'toggle' value of -1. }
3694 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ShowCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3695 {$EXTERNALSYM SDL_ShowCursor}
3699 {------------------------------------------------------------------------------}
3700 { Keyboard-routines }
3701 {------------------------------------------------------------------------------}
3703 { Enable/Disable UNICODE translation of keyboard input.
3704 This translation has some overhead, so translation defaults off.
3705 If 'enable' is 1, translation is enabled.
3706 If 'enable' is 0, translation is disabled.
3707 If 'enable' is -1, the translation state is not changed.
3708 It returns the previous state of keyboard translation. }
3710 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableUNICODE'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3711 {$EXTERNALSYM SDL_EnableUNICODE}
3713 { If 'delay' is set to 0, keyboard repeat is disabled. }
3715 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3716 {$EXTERNALSYM SDL_EnableKeyRepeat}
3719 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3720 {$EXTERNALSYM SDL_GetKeyRepeat}
3722 { Get a snapshot of the current state of the keyboard.
3723 Returns an array of keystates, indexed by the SDLK_* syms.
3724 Used:
3726 UInt8 *keystate = SDL_GetKeyState(NULL);
3727 if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed }
3730 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3731 {$EXTERNALSYM SDL_GetKeyState}
3733 { Get the current key modifier state }
3735 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3736 {$EXTERNALSYM SDL_GetModState}
3738 { Set the current key modifier state
3739 This does not change the keyboard state, only the key modifier flags. }
3741 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3742 {$EXTERNALSYM SDL_SetModState}
3744 { Get the name of an SDL virtual keysym }
3746 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3747 {$EXTERNALSYM SDL_GetKeyName}
3749 {------------------------------------------------------------------------------}
3750 { Active Routines }
3751 {------------------------------------------------------------------------------}
3753 { This function returns the current state of the application, which is a
3754 bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and
3755 SDL_APPACTIVE. If SDL_APPACTIVE is set, then the user is able to
3756 see your application, otherwise it has been iconified or disabled. }
3759 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAppState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3760 {$EXTERNALSYM SDL_GetAppState}
3763 { Mutex functions }
3765 { Create a mutex, initialized unlocked }
3768 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3769 {$EXTERNALSYM SDL_CreateMutex}
3771 { Lock the mutex (Returns 0, or -1 on error) }
3774 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3775 { $ EXTERNALSYM SDL_mutexP}
3778 {$EXTERNALSYM SDL_LockMutex}
3780 { Unlock the mutex (Returns 0, or -1 on error) }
3782 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3783 {$EXTERNALSYM SDL_mutexV}
3786 {$EXTERNALSYM SDL_UnlockMutex}
3788 { Destroy a mutex }
3790 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3791 {$EXTERNALSYM SDL_DestroyMutex}
3793 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3794 { Semaphore functions }
3795 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3796 { Create a semaphore, initialized with value, returns NULL on failure. }
3798 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateSemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3799 {$EXTERNALSYM SDL_CreateSemaphore}
3802 { Destroy a semaphore }
3804 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroySemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3805 {$EXTERNALSYM SDL_DestroySemaphore}
3807 { This function suspends the calling thread until the semaphore pointed
3808 to by sem has a positive count. It then atomically decreases the semaphore
3809 count. }
3812 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3813 {$EXTERNALSYM SDL_SemWait}
3815 { Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,
3816 SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error. }
3819 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemTryWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3820 {$EXTERNALSYM SDL_SemTryWait}
3822 { Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
3823 the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
3824 the allotted time, and -1 on error.
3825 On some platforms this function is implemented by looping with a delay
3826 of 1 ms, and so should be avoided if possible. }
3829 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3830 {$EXTERNALSYM SDL_SemTryWait}
3832 { Atomically increases the semaphore's count (not blocking), returns 0,
3833 or -1 on error. }
3836 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemPost'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3837 {$EXTERNALSYM SDL_SemTryWait}
3839 { Returns the current count of the semaphore }
3842 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemValue'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3843 {$EXTERNALSYM SDL_SemValue}
3845 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3846 { Condition variable functions }
3847 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3848 { Create a condition variable }
3850 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3851 {$EXTERNALSYM SDL_CreateCond}
3853 { Destroy a condition variable }
3855 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3856 {$EXTERNALSYM SDL_DestroyCond}
3858 { Restart one of the threads that are waiting on the condition variable,
3859 returns 0 or -1 on error. }
3862 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondSignal'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3863 {$EXTERNALSYM SDL_CondSignal}
3865 { Restart all threads that are waiting on the condition variable,
3866 returns 0 or -1 on error. }
3869 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondBroadcast'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3870 {$EXTERNALSYM SDL_CondBroadcast}
3873 { Wait on the condition variable, unlocking the provided mutex.
3874 The mutex must be locked before entering this function!
3875 Returns 0 when it is signaled, or -1 on error. }
3878 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3879 {$EXTERNALSYM SDL_CondWait}
3881 { Waits for at most 'ms' milliseconds, and returns 0 if the condition
3882 variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
3883 signaled in the allotted time, and -1 on error.
3884 On some platforms this function is implemented by looping with a delay
3885 of 1 ms, and so should be avoided if possible. }
3888 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3889 {$EXTERNALSYM SDL_CondWaitTimeout}
3891 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3892 { Condition variable functions }
3893 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3895 { Create a thread }
3897 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3898 {$EXTERNALSYM SDL_CreateThread}
3900 { Get the 32-bit thread identifier for the current thread }
3902 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3903 {$EXTERNALSYM SDL_ThreadID}
3905 { Get the 32-bit thread identifier for the specified thread,
3906 equivalent to SDL_ThreadID() if the specified thread is NULL. }
3908 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3909 {$EXTERNALSYM SDL_GetThreadID}
3911 { Wait for a thread to finish.
3912 The return code for the thread function is placed in the area
3913 pointed to by 'status', if 'status' is not NULL. }
3916 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3917 {$EXTERNALSYM SDL_WaitThread}
3919 { Forcefully kill a thread without worrying about its state }
3921 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_KillThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3922 {$EXTERNALSYM SDL_KillThread}
3924 {------------------------------------------------------------------------------}
3925 { Get Environment Routines }
3926 {------------------------------------------------------------------------------}
3927 {$IFDEF WINDOWS}
3930 {$ENDIF}
3932 {$IFDEF Unix}
3933 {$IFDEF FPC}
3936 {$ENDIF}
3937 {$ENDIF}
3939 { Put a variable of the form "name=value" into the environment }
3940 //function SDL_putenv(const variable: PChar): integer; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';
3942 {$EXTERNALSYM SDL_putenv}
3944 // The following function has been commented out to encourage developers to use
3945 // SDL_putenv as it it more portable
3946 //function putenv(const variable: PChar): integer;
3947 //{$EXTERNALSYM putenv}
3949 {$IFDEF WINDOWS}
3950 {$IFNDEF __GPC__}
3952 {$ENDIF}
3953 {$ENDIF}
3955 {* Retrieve a variable named "name" from the environment }
3956 //function SDL_getenv(const name: PChar): PChar; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';
3958 {$EXTERNALSYM SDL_getenv}
3960 // The following function has been commented out to encourage developers to use
3961 // SDL_getenv as it it more portable
3962 //function getenv(const name: PChar): PChar;
3963 //{$EXTERNALSYM getenv}
3965 {*
3966 * This function gives you custom hooks into the window manager information.
3967 * It fills the structure pointed to by 'info' with custom information and
3968 * returns 1 if the function is implemented. If it's not implemented, or
3969 * the version member of the 'info' structure is invalid, it returns 0.
3970 *}
3972 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetWMInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3973 {$EXTERNALSYM SDL_GetWMInfo}
3975 {------------------------------------------------------------------------------}
3977 //SDL_loadso.h
3978 {* This function dynamically loads a shared object and returns a pointer
3979 * to the object handle (or NULL if there was an error).
3980 * The 'sofile' parameter is a system dependent name of the object file.
3981 *}
3983 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3984 {$EXTERNALSYM SDL_LoadObject}
3986 {* Given an object handle, this function looks up the address of the
3987 * named function in the shared object and returns it. This address
3988 * is no longer valid after calling SDL_UnloadObject().
3989 *}
3991 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadFunction'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3992 {$EXTERNALSYM SDL_LoadFunction}
3994 {* Unload a shared object from memory *}
3996 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnloadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3997 {$EXTERNALSYM SDL_UnloadObject}
4001 {------------------------------------------------------------------------------}
4004 {$EXTERNALSYM SDL_Swap32}
4006 {$ENDIF MORPHOS}
4008 { FreeAndNil frees the given TObject instance and sets the variable reference
4009 to nil. Be careful to only pass TObjects to this routine. }
4012 { Exit procedure handling }
4014 { AddExitProc adds the given procedure to the run-time library's exit
4015 procedure list. When an application terminates, its exit procedures are
4016 executed in reverse order of definition, i.e. the last procedure passed
4017 to AddExitProc is the first one to get executed upon termination. }
4020 // Bitwise Checking functions
4027 implementation
4029 {$IFDEF __GPC__}
4031 {$ENDIF}
4034 begin
4039 begin
4040 {$IFNDEF WINDOWS}
4042 {$ENDIF}
4046 begin
4051 begin
4056 begin
4061 begin
4066 begin
4070 function SDL_LoadWAV(filename: PChar; spec: PSDL_AudioSpec; audio_buf: PUInt8; audiolen: PUInt32): PSDL_AudioSpec;
4071 begin
4076 begin
4082 var
4084 begin
4094 begin
4099 begin
4106 begin
4111 begin
4113 );
4117 begin
4122 begin
4127 begin
4132 PSDL_Surface;
4134 begin
4140 begin
4146 begin
4152 begin
4157 begin
4161 {$IFDEF WINDOWS}
4164 {$ENDIF}
4168 begin
4169 {$IFDEF WINDOWS}
4171 {$ENDIF}
4173 {$IFDEF UNIX}
4174 {$IFDEF FPC}
4176 {$ELSE}
4178 {$ENDIF}
4179 {$ENDIF}
4182 {$IFDEF WINDOWS}
4183 {$IFNDEF __GPC__}
4186 {$ENDIF}
4187 {$ENDIF}
4190 begin
4191 {$IFDEF WINDOWS}
4193 {$IFDEF __GPC__}
4195 {$ELSE}
4197 {$ENDIF}
4199 {$ELSE}
4201 {$IFDEF UNIX}
4203 {$IFDEF FPC}
4205 {$ELSE}
4207 {$ENDIF}
4209 {$ELSE UNIX}
4210 {$IFDEF OS2}
4212 {$ENDIF OS2}
4213 {$ENDIF}
4215 {$ENDIF}
4219 begin
4224 begin
4225 Result := ((D shl 24) or ((D shl 8) and $00FF0000) or ((D shr 8) and $0000FF00) or (D shr 24));
4229 {$IFNDEF __GPC__}
4230 {$IFNDEF __TMT__}
4231 var
4233 {$ENDIF}
4234 {$ENDIF}
4235 begin
4236 {$IFNDEF __GPC__}
4237 {$IFNDEF __TMT__}
4241 {$ENDIF}
4242 {$ENDIF}
4245 { Exit procedure handling }
4246 type
4254 var
4258 var
4261 begin
4267 Proc;
4271 var
4273 begin
4283 begin
4288 begin
4293 begin