diff options
Diffstat (limited to 'lib/oldwrappers/sdl/sdl.nim')
| -rwxr-xr-x | lib/oldwrappers/sdl/sdl.nim | 2522 |
1 files changed, 0 insertions, 2522 deletions
diff --git a/lib/oldwrappers/sdl/sdl.nim b/lib/oldwrappers/sdl/sdl.nim deleted file mode 100755 index 7d2b6ba26..000000000 --- a/lib/oldwrappers/sdl/sdl.nim +++ /dev/null @@ -1,2522 +0,0 @@ - -#****************************************************************************** -# -# JEDI-SDL : Pascal units for SDL - Simple DirectMedia Layer -# Conversion of the Simple DirectMedia Layer Headers -# -# Portions created by Sam Lantinga <slouken@devolution.com> are -# Copyright (C) 1997-2004 Sam Lantinga -# 5635-34 Springhouse Dr. -# Pleasanton, CA 94588 (USA) -# -# All Rights Reserved. -# -# The original files are : SDL.h -# SDL_main.h -# SDL_types.h -# SDL_rwops.h -# SDL_timer.h -# SDL_audio.h -# SDL_cdrom.h -# SDL_joystick.h -# SDL_mouse.h -# SDL_keyboard.h -# SDL_events.h -# SDL_video.h -# SDL_byteorder.h -# SDL_version.h -# SDL_active.h -# SDL_thread.h -# SDL_mutex .h -# SDL_getenv.h -# SDL_loadso.h -# -# The initial developer of this Pascal code was : -# Dominique Louis <Dominique@SavageSoftware.com.au> -# -# Portions created by Dominique Louis are -# Copyright (C) 2000 - 2004 Dominique Louis. -# -# -# Contributor(s) -# -------------- -# Tom Jones <tigertomjones@gmx.de> His Project inspired this conversion -# Matthias Thoma <ma.thoma@gmx.de> -# -# Obtained through: -# Joint Endeavour of Delphi Innovators ( Project JEDI ) -# -# You may retrieve the latest version of this file at the Project -# JEDI home page, located at http://delphi-jedi.org -# -# The contents of this file are used with permission, subject to -# the Mozilla Public License Version 1.1 (the "License"); you may -# not use this file except in compliance with the License. You may -# obtain a copy of the License at -# http://www.mozilla.org/MPL/MPL-1.1.html -# -# Software distributed under the License is distributed on an -# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or -# implied. See the License for the specific language governing -# rights and limitations under the License. -# -# Description -# ----------- -# -# -# -# -# -# -# -# Requires -# -------- -# The SDL Runtime libraris on Win32 : SDL.dll on Linux : libSDL.so -# They are available from... -# http://www.libsdl.org . -# -# Programming Notes -# ----------------- -# -# -# -# -# Revision History -# ---------------- -# May 08 2001 - DL : Added Keyboard State Array ( See demos for how to -# use ) -# PKeyStateArr = ^TKeyStateArr; -# TKeyStateArr = array[0..65000] of UInt8; -# As most games will need it. -# -# April 02 2001 - DL : Added SDL_getenv.h definitions and tested version -# 1.2.0 compatability. -# -# March 13 2001 - MT : Added Linux compatibility. -# -# March 10 2001 - MT : Added externalsyms for DEFINES -# Changed the license header -# -# March 09 2001 - MT : Added Kylix Ifdefs/Deleted the uses mmsystem -# -# March 01 2001 - DL : Update conversion of version 1.1.8 -# -# July 22 2001 - DL : Added TUInt8Array and PUIntArray after suggestions -# from Matthias Thoma and Eric Grange. -# -# October 12 2001 - DL : Various changes as suggested by Matthias Thoma and -# David Acklam -# -# October 24 2001 - DL : Added FreePascal support as per suggestions from -# Dean Ellis. -# -# October 27 2001 - DL : Added SDL_BUTTON macro -# -# November 08 2001 - DL : Bug fix as pointed out by Puthoon. -# -# November 29 2001 - DL : Bug fix of SDL_SetGammaRamp as pointed out by Simon -# Rushton. -# -# November 30 2001 - DL : SDL_NOFRAME added as pointed out by Simon Rushton. -# -# December 11 2001 - DL : Added $WEAKPACKAGEUNIT ON to facilitate useage in -# Components -# -# January 05 2002 - DL : Added SDL_Swap32 function as suggested by Matthias -# Thoma and also made sure the _getenv from -# MSVCRT.DLL uses the right calling convention -# -# January 25 2002 - DL : Updated conversion of SDL_AddTimer & -# SDL_RemoveTimer as per suggestions from Matthias -# Thoma. -# -# January 27 2002 - DL : Commented out exported function putenv and getenv -# So that developers get used to using SDL_putenv -# SDL_getenv, as they are more portable -# -# March 05 2002 - DL : Added FreeAnNil procedure for Delphi 4 users. -# -# October 23 2002 - DL : Added Delphi 3 Define of Win32. -# If you intend to you Delphi 3... -# ( which is officially unsupported ) make sure you -# remove references to $EXTERNALSYM in this and other -# SDL files. -# -# November 29 2002 - DL : Fixed bug in Declaration of SDL_GetRGBA that was -# pointed out by Todd Lang -# -# April 03 2003 - DL : Added jedi-sdl.inc include file to support more -# Pascal compilers. Initial support is now included -# for GnuPascal, VirtualPascal, TMT and obviously -# continue support for Delphi Kylix and FreePascal. -# -# April 08 2003 - MK : Aka Mr Kroket - Added Better FPC support -# -# April 24 2003 - DL : under instruction from Alexey Barkovoy, I have added -# better TMT Pascal support and under instruction -# from Prof. Abimbola Olowofoyeku (The African Chief), -# I have added better Gnu Pascal support -# -# April 30 2003 - DL : under instruction from David Mears AKA -# Jason Siletto, I have added FPC Linux support. -# This was compiled with fpc 1.1, so remember to set -# include file path. ie. -Fi/usr/share/fpcsrc/rtl/* -# -# -# -# Revision 1.31 2007/05/29 21:30:48 savage -# Changes as suggested by Almindor for 64bit compatibility. -# -# Revision 1.30 2007/05/29 19:31:03 savage -# Fix to TSDL_Overlay structure - thanks David Pethes (aka imcold) -# -# Revision 1.29 2007/05/20 20:29:11 savage -# Initial Changes to Handle 64 Bits -# -# Revision 1.26 2007/02/11 13:38:04 savage -# Added Nintendo DS support - Thanks Dean. -# -# Revision 1.25 2006/12/02 00:12:52 savage -# Updated to latest version -# -# Revision 1.24 2006/05/18 21:10:04 savage -# Added 1.2.10 Changes -# -# Revision 1.23 2005/12/04 23:17:52 drellis -# Added declaration of SInt8 and PSInt8 -# -# Revision 1.22 2005/05/24 21:59:03 savage -# Re-arranged uses clause to work on Win32 and Linux, Thanks again Michalis. -# -# Revision 1.21 2005/05/22 18:42:31 savage -# Changes as suggested by Michalis Kamburelis. Thanks again. -# -# Revision 1.20 2005/04/10 11:48:33 savage -# Changes as suggested by Michalis, thanks. -# -# Revision 1.19 2005/01/05 01:47:06 savage -# Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively. -# -# Revision 1.18 2005/01/04 23:14:41 savage -# Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively. -# -# Revision 1.17 2005/01/03 18:40:59 savage -# Updated Version number to reflect latest one -# -# Revision 1.16 2005/01/01 02:02:06 savage -# Updated to v1.2.8 -# -# Revision 1.15 2004/12/24 18:57:11 savage -# forgot to apply Michalis Kamburelis' patch to the implementation section. now fixed -# -# Revision 1.14 2004/12/23 23:42:18 savage -# Applied Patches supplied by Michalis Kamburelis ( THANKS! ), for greater FreePascal compatability. -# -# Revision 1.13 2004/09/30 22:31:59 savage -# Updated with slightly different header comments -# -# Revision 1.12 2004/09/12 21:52:58 savage -# Slight changes to fix some issues with the sdl classes. -# -# Revision 1.11 2004/08/14 22:54:30 savage -# Updated so that Library name defines are correctly defined for MacOS X. -# -# Revision 1.10 2004/07/20 23:57:33 savage -# Thanks to Paul Toth for spotting an error in the SDL Audio Convertion structures. -# In TSDL_AudioCVT the filters variable should point to and array of pointers and not what I had there previously. -# -# Revision 1.9 2004/07/03 22:07:22 savage -# Added Bitwise Manipulation Functions for TSDL_VideoInfo struct. -# -# Revision 1.8 2004/05/10 14:10:03 savage -# Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ). -# -# Revision 1.7 2004/04/13 09:32:08 savage -# 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. -# -# Revision 1.6 2004/04/01 20:53:23 savage -# Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site. -# -# Revision 1.5 2004/02/22 15:32:10 savage -# SDL_GetEnv Fix so it also works on FPC/Linux. Thanks to Rodrigo for pointing this out. -# -# Revision 1.4 2004/02/21 23:24:29 savage -# SDL_GetEnv Fix so that it is not define twice for FPC. Thanks to Rene Hugentobler for pointing out this bug, -# -# Revision 1.3 2004/02/18 22:35:51 savage -# Brought sdl.pas up to 1.2.7 compatability -# Thus... -# Added SDL_GL_STEREO, -# SDL_GL_MULTISAMPLEBUFFERS, -# SDL_GL_MULTISAMPLESAMPLES -# -# Add DLL/Shared object functions -# function SDL_LoadObject( const sofile : PChar ) : Pointer; -# -# function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer; -# -# procedure SDL_UnloadObject( handle : Pointer ); -# -# Added function to create RWops from const memory: SDL_RWFromConstMem() -# function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops; -# -# Ported SDL_cpuinfo.h so Now you can test for Specific CPU types. -# -# Revision 1.2 2004/02/17 21:37:12 savage -# Tidying up of units -# -# Revision 1.1 2004/02/05 00:08:20 savage -# Module 1.0 release -# -# - -{.deadCodeElim: on.} - -when defined(windows): - const SDLLibName = "SDL.dll" -elif defined(macosx): - const SDLLibName = "libSDL-1.2.0.dylib" -else: - const SDLLibName = "libSDL.so" - -const - SDL_MAJOR_VERSION* = 1'i8 - SDL_MINOR_VERSION* = 2'i8 - SDL_PATCHLEVEL* = 11'i8 # SDL.h constants - SDL_INIT_TIMER* = 0x00000001 - SDL_INIT_AUDIO* = 0x00000010 - SDL_INIT_VIDEO* = 0x00000020 - SDL_INIT_CDROM* = 0x00000100 - SDL_INIT_JOYSTICK* = 0x00000200 - SDL_INIT_NOPARACHUTE* = 0x00100000 # Don't catch fatal signals - SDL_INIT_EVENTTHREAD* = 0x01000000 # Not supported on all OS's - SDL_INIT_EVERYTHING* = 0x0000FFFF # SDL_error.h constants - ERR_MAX_STRLEN* = 128 - ERR_MAX_ARGS* = 5 # SDL_types.h constants - SDL_PRESSED* = 0x00000001 - SDL_RELEASED* = 0x00000000 # SDL_timer.h constants - # This is the OS scheduler timeslice, in milliseconds - SDL_TIMESLICE* = 10 # This is the maximum resolution of the SDL timer on all platforms - TIMER_RESOLUTION* = 10 # Experimentally determined - # SDL_audio.h constants - AUDIO_U8* = 0x00000008 # Unsigned 8-bit samples - AUDIO_S8* = 0x00008008 # Signed 8-bit samples - AUDIO_U16LSB* = 0x00000010 # Unsigned 16-bit samples - AUDIO_S16LSB* = 0x00008010 # Signed 16-bit samples - AUDIO_U16MSB* = 0x00001010 # As above, but big-endian byte order - AUDIO_S16MSB* = 0x00009010 # As above, but big-endian byte order - AUDIO_U16* = AUDIO_U16LSB - AUDIO_S16* = AUDIO_S16LSB # SDL_cdrom.h constants - # The maximum number of CD-ROM tracks on a disk - SDL_MAX_TRACKS* = 99 # The types of CD-ROM track possible - SDL_AUDIO_TRACK* = 0x00000000 - SDL_DATA_TRACK* = 0x00000004 # Conversion functions from frames to Minute/Second/Frames and vice versa - CD_FPS* = 75 # SDL_byteorder.h constants - # The two types of endianness - SDL_LIL_ENDIAN* = 1234 - SDL_BIG_ENDIAN* = 4321 - -when cpuEndian == littleEndian: - const - SDL_BYTEORDER* = SDL_LIL_ENDIAN # Native audio byte ordering - AUDIO_U16SYS* = AUDIO_U16LSB - AUDIO_S16SYS* = AUDIO_S16LSB -else: - const - SDL_BYTEORDER* = SDL_BIG_ENDIAN # Native audio byte ordering - AUDIO_U16SYS* = AUDIO_U16MSB - AUDIO_S16SYS* = AUDIO_S16MSB -const - SDL_MIX_MAXVOLUME* = 128 # SDL_joystick.h constants - MAX_JOYSTICKS* = 2 # only 2 are supported in the multimedia API - MAX_AXES* = 6 # each joystick can have up to 6 axes - MAX_BUTTONS* = 32 # and 32 buttons - AXIS_MIN* = - 32768 # minimum value for axis coordinate - AXIS_MAX* = 32767 # maximum value for axis coordinate - JOY_AXIS_THRESHOLD* = (toFloat((AXIS_MAX) - (AXIS_MIN)) / 100.0) # 1% motion - SDL_HAT_CENTERED* = 0x00000000 - SDL_HAT_UP* = 0x00000001 - SDL_HAT_RIGHT* = 0x00000002 - SDL_HAT_DOWN* = 0x00000004 - SDL_HAT_LEFT* = 0x00000008 - SDL_HAT_RIGHTUP* = SDL_HAT_RIGHT or SDL_HAT_UP - SDL_HAT_RIGHTDOWN* = SDL_HAT_RIGHT or SDL_HAT_DOWN - SDL_HAT_LEFTUP* = SDL_HAT_LEFT or SDL_HAT_UP - SDL_HAT_LEFTDOWN* = SDL_HAT_LEFT or SDL_HAT_DOWN # SDL_events.h constants - -type - TSDL_EventKind* = enum # kind of an SDL event - SDL_NOEVENT = 0, # Unused (do not remove) - SDL_ACTIVEEVENT = 1, # Application loses/gains visibility - SDL_KEYDOWN = 2, # Keys pressed - SDL_KEYUP = 3, # Keys released - SDL_MOUSEMOTION = 4, # Mouse moved - SDL_MOUSEBUTTONDOWN = 5, # Mouse button pressed - SDL_MOUSEBUTTONUP = 6, # Mouse button released - SDL_JOYAXISMOTION = 7, # Joystick axis motion - SDL_JOYBALLMOTION = 8, # Joystick trackball motion - SDL_JOYHATMOTION = 9, # Joystick hat position change - SDL_JOYBUTTONDOWN = 10, # Joystick button pressed - SDL_JOYBUTTONUP = 11, # Joystick button released - SDL_QUITEV = 12, # User-requested quit ( Changed due to procedure conflict ) - SDL_SYSWMEVENT = 13, # System specific event - SDL_EVENT_RESERVEDA = 14, # Reserved for future use.. - SDL_EVENT_RESERVED = 15, # Reserved for future use.. - SDL_VIDEORESIZE = 16, # User resized video mode - SDL_VIDEOEXPOSE = 17, # Screen needs to be redrawn - SDL_EVENT_RESERVED2 = 18, # Reserved for future use.. - SDL_EVENT_RESERVED3 = 19, # Reserved for future use.. - SDL_EVENT_RESERVED4 = 20, # Reserved for future use.. - SDL_EVENT_RESERVED5 = 21, # Reserved for future use.. - SDL_EVENT_RESERVED6 = 22, # Reserved for future use.. - SDL_EVENT_RESERVED7 = 23, # Reserved for future use.. - # Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use - SDL_USEREVENT = 24 # This last event is only for bounding internal arrays - # It is the number of bits in the event mask datatype -- UInt32 - -const - SDL_NUMEVENTS* = 32 - SDL_ALLEVENTS* = 0xFFFFFFFF - SDL_ACTIVEEVENTMASK* = 1 shl ord(SDL_ACTIVEEVENT) - SDL_KEYDOWNMASK* = 1 shl ord(SDL_KEYDOWN) - SDL_KEYUPMASK* = 1 shl ord(SDL_KEYUP) - SDL_MOUSEMOTIONMASK* = 1 shl ord(SDL_MOUSEMOTION) - SDL_MOUSEBUTTONDOWNMASK* = 1 shl ord(SDL_MOUSEBUTTONDOWN) - SDL_MOUSEBUTTONUPMASK* = 1 shl ord(SDL_MOUSEBUTTONUP) - SDL_MOUSEEVENTMASK* = 1 shl ord(SDL_MOUSEMOTION) or 1 shl ord(SDL_MOUSEBUTTONDOWN) or - 1 shl ord(SDL_MOUSEBUTTONUP) - SDL_JOYAXISMOTIONMASK* = 1 shl ord(SDL_JOYAXISMOTION) - SDL_JOYBALLMOTIONMASK* = 1 shl ord(SDL_JOYBALLMOTION) - SDL_JOYHATMOTIONMASK* = 1 shl ord(SDL_JOYHATMOTION) - SDL_JOYBUTTONDOWNMASK* = 1 shl ord(SDL_JOYBUTTONDOWN) - SDL_JOYBUTTONUPMASK* = 1 shl ord(SDL_JOYBUTTONUP) - SDL_JOYEVENTMASK* = 1 shl ord(SDL_JOYAXISMOTION) or 1 shl ord(SDL_JOYBALLMOTION) or - 1 shl ord(SDL_JOYHATMOTION) or 1 shl ord(SDL_JOYBUTTONDOWN) or - 1 shl ord(SDL_JOYBUTTONUP) - SDL_VIDEORESIZEMASK* = 1 shl ord(SDL_VIDEORESIZE) - SDL_QUITMASK* = 1 shl ord(SDL_QUITEV) - SDL_SYSWMEVENTMASK* = 1 shl ord(SDL_SYSWMEVENT) - SDL_QUERY* = - 1 - SDL_IGNORE* = 0 - SDL_DISABLE* = 0 - SDL_ENABLE* = 1 #SDL_keyboard.h constants - # This is the mask which refers to all hotkey bindings - SDL_ALL_HOTKEYS* = 0xFFFFFFFF # Enable/Disable keyboard repeat. Keyboard repeat defaults to off. - # 'delay' is the initial delay in ms between the time when a key is - # pressed, and keyboard repeat begins. - # 'interval' is the time in ms between keyboard repeat events. - SDL_DEFAULT_REPEAT_DELAY* = 500 - SDL_DEFAULT_REPEAT_INTERVAL* = 30 # The keyboard syms have been cleverly chosen to map to ASCII - SDLK_UNKNOWN* = 0 - SDLK_FIRST* = 0 - SDLK_BACKSPACE* = 8 - SDLK_TAB* = 9 - SDLK_CLEAR* = 12 - SDLK_RETURN* = 13 - SDLK_PAUSE* = 19 - SDLK_ESCAPE* = 27 - SDLK_SPACE* = 32 - SDLK_EXCLAIM* = 33 - SDLK_QUOTEDBL* = 34 - SDLK_HASH* = 35 - SDLK_DOLLAR* = 36 - SDLK_AMPERSAND* = 38 - SDLK_QUOTE* = 39 - SDLK_LEFTPAREN* = 40 - SDLK_RIGHTPAREN* = 41 - SDLK_ASTERISK* = 42 - SDLK_PLUS* = 43 - SDLK_COMMA* = 44 - SDLK_MINUS* = 45 - SDLK_PERIOD* = 46 - SDLK_SLASH* = 47 - SDLK_0* = 48 - SDLK_1* = 49 - SDLK_2* = 50 - SDLK_3* = 51 - SDLK_4* = 52 - SDLK_5* = 53 - SDLK_6* = 54 - SDLK_7* = 55 - SDLK_8* = 56 - SDLK_9* = 57 - SDLK_COLON* = 58 - SDLK_SEMICOLON* = 59 - SDLK_LESS* = 60 - SDLK_EQUALS* = 61 - SDLK_GREATER* = 62 - SDLK_QUESTION* = 63 - SDLK_AT* = 64 # Skip uppercase letters - SDLK_LEFTBRACKET* = 91 - SDLK_BACKSLASH* = 92 - SDLK_RIGHTBRACKET* = 93 - SDLK_CARET* = 94 - SDLK_UNDERSCORE* = 95 - SDLK_BACKQUOTE* = 96 - SDLK_a* = 97 - SDLK_b* = 98 - SDLK_c* = 99 - SDLK_d* = 100 - SDLK_e* = 101 - SDLK_f* = 102 - SDLK_g* = 103 - SDLK_h* = 104 - SDLK_i* = 105 - SDLK_j* = 106 - SDLK_k* = 107 - SDLK_l* = 108 - SDLK_m* = 109 - SDLK_n* = 110 - SDLK_o* = 111 - SDLK_p* = 112 - SDLK_q* = 113 - SDLK_r* = 114 - SDLK_s* = 115 - SDLK_t* = 116 - SDLK_u* = 117 - SDLK_v* = 118 - SDLK_w* = 119 - SDLK_x* = 120 - SDLK_y* = 121 - SDLK_z* = 122 - SDLK_DELETE* = 127 # End of ASCII mapped keysyms - # International keyboard syms - SDLK_WORLD_0* = 160 # 0xA0 - SDLK_WORLD_1* = 161 - SDLK_WORLD_2* = 162 - SDLK_WORLD_3* = 163 - SDLK_WORLD_4* = 164 - SDLK_WORLD_5* = 165 - SDLK_WORLD_6* = 166 - SDLK_WORLD_7* = 167 - SDLK_WORLD_8* = 168 - SDLK_WORLD_9* = 169 - SDLK_WORLD_10* = 170 - SDLK_WORLD_11* = 171 - SDLK_WORLD_12* = 172 - SDLK_WORLD_13* = 173 - SDLK_WORLD_14* = 174 - SDLK_WORLD_15* = 175 - SDLK_WORLD_16* = 176 - SDLK_WORLD_17* = 177 - SDLK_WORLD_18* = 178 - SDLK_WORLD_19* = 179 - SDLK_WORLD_20* = 180 - SDLK_WORLD_21* = 181 - SDLK_WORLD_22* = 182 - SDLK_WORLD_23* = 183 - SDLK_WORLD_24* = 184 - SDLK_WORLD_25* = 185 - SDLK_WORLD_26* = 186 - SDLK_WORLD_27* = 187 - SDLK_WORLD_28* = 188 - SDLK_WORLD_29* = 189 - SDLK_WORLD_30* = 190 - SDLK_WORLD_31* = 191 - SDLK_WORLD_32* = 192 - SDLK_WORLD_33* = 193 - SDLK_WORLD_34* = 194 - SDLK_WORLD_35* = 195 - SDLK_WORLD_36* = 196 - SDLK_WORLD_37* = 197 - SDLK_WORLD_38* = 198 - SDLK_WORLD_39* = 199 - SDLK_WORLD_40* = 200 - SDLK_WORLD_41* = 201 - SDLK_WORLD_42* = 202 - SDLK_WORLD_43* = 203 - SDLK_WORLD_44* = 204 - SDLK_WORLD_45* = 205 - SDLK_WORLD_46* = 206 - SDLK_WORLD_47* = 207 - SDLK_WORLD_48* = 208 - SDLK_WORLD_49* = 209 - SDLK_WORLD_50* = 210 - SDLK_WORLD_51* = 211 - SDLK_WORLD_52* = 212 - SDLK_WORLD_53* = 213 - SDLK_WORLD_54* = 214 - SDLK_WORLD_55* = 215 - SDLK_WORLD_56* = 216 - SDLK_WORLD_57* = 217 - SDLK_WORLD_58* = 218 - SDLK_WORLD_59* = 219 - SDLK_WORLD_60* = 220 - SDLK_WORLD_61* = 221 - SDLK_WORLD_62* = 222 - SDLK_WORLD_63* = 223 - SDLK_WORLD_64* = 224 - SDLK_WORLD_65* = 225 - SDLK_WORLD_66* = 226 - SDLK_WORLD_67* = 227 - SDLK_WORLD_68* = 228 - SDLK_WORLD_69* = 229 - SDLK_WORLD_70* = 230 - SDLK_WORLD_71* = 231 - SDLK_WORLD_72* = 232 - SDLK_WORLD_73* = 233 - SDLK_WORLD_74* = 234 - SDLK_WORLD_75* = 235 - SDLK_WORLD_76* = 236 - SDLK_WORLD_77* = 237 - SDLK_WORLD_78* = 238 - SDLK_WORLD_79* = 239 - SDLK_WORLD_80* = 240 - SDLK_WORLD_81* = 241 - SDLK_WORLD_82* = 242 - SDLK_WORLD_83* = 243 - SDLK_WORLD_84* = 244 - SDLK_WORLD_85* = 245 - SDLK_WORLD_86* = 246 - SDLK_WORLD_87* = 247 - SDLK_WORLD_88* = 248 - SDLK_WORLD_89* = 249 - SDLK_WORLD_90* = 250 - SDLK_WORLD_91* = 251 - SDLK_WORLD_92* = 252 - SDLK_WORLD_93* = 253 - SDLK_WORLD_94* = 254 - SDLK_WORLD_95* = 255 # 0xFF - # Numeric keypad - SDLK_KP0* = 256 - SDLK_KP1* = 257 - SDLK_KP2* = 258 - SDLK_KP3* = 259 - SDLK_KP4* = 260 - SDLK_KP5* = 261 - SDLK_KP6* = 262 - SDLK_KP7* = 263 - SDLK_KP8* = 264 - SDLK_KP9* = 265 - SDLK_KP_PERIOD* = 266 - SDLK_KP_DIVIDE* = 267 - SDLK_KP_MULTIPLY* = 268 - SDLK_KP_MINUS* = 269 - SDLK_KP_PLUS* = 270 - SDLK_KP_ENTER* = 271 - SDLK_KP_EQUALS* = 272 # Arrows + Home/End pad - SDLK_UP* = 273 - SDLK_DOWN* = 274 - SDLK_RIGHT* = 275 - SDLK_LEFT* = 276 - SDLK_INSERT* = 277 - SDLK_HOME* = 278 - SDLK_END* = 279 - SDLK_PAGEUP* = 280 - SDLK_PAGEDOWN* = 281 # Function keys - SDLK_F1* = 282 - SDLK_F2* = 283 - SDLK_F3* = 284 - SDLK_F4* = 285 - SDLK_F5* = 286 - SDLK_F6* = 287 - SDLK_F7* = 288 - SDLK_F8* = 289 - SDLK_F9* = 290 - SDLK_F10* = 291 - SDLK_F11* = 292 - SDLK_F12* = 293 - SDLK_F13* = 294 - SDLK_F14* = 295 - SDLK_F15* = 296 # Key state modifier keys - SDLK_NUMLOCK* = 300 - SDLK_CAPSLOCK* = 301 - SDLK_SCROLLOCK* = 302 - SDLK_RSHIFT* = 303 - SDLK_LSHIFT* = 304 - SDLK_RCTRL* = 305 - SDLK_LCTRL* = 306 - SDLK_RALT* = 307 - SDLK_LALT* = 308 - SDLK_RMETA* = 309 - SDLK_LMETA* = 310 - SDLK_LSUPER* = 311 # Left "Windows" key - SDLK_RSUPER* = 312 # Right "Windows" key - SDLK_MODE* = 313 # "Alt Gr" key - SDLK_COMPOSE* = 314 # Multi-key compose key - # Miscellaneous function keys - SDLK_HELP* = 315 - SDLK_PRINT* = 316 - SDLK_SYSREQ* = 317 - SDLK_BREAK* = 318 - SDLK_MENU* = 319 - SDLK_POWER* = 320 # Power Macintosh power key - SDLK_EURO* = 321 # Some european keyboards - SDLK_GP2X_UP* = 0 - SDLK_GP2X_UPLEFT* = 1 - SDLK_GP2X_LEFT* = 2 - SDLK_GP2X_DOWNLEFT* = 3 - SDLK_GP2X_DOWN* = 4 - SDLK_GP2X_DOWNRIGHT* = 5 - SDLK_GP2X_RIGHT* = 6 - SDLK_GP2X_UPRIGHT* = 7 - SDLK_GP2X_START* = 8 - SDLK_GP2X_SELECT* = 9 - SDLK_GP2X_L* = 10 - SDLK_GP2X_R* = 11 - SDLK_GP2X_A* = 12 - SDLK_GP2X_B* = 13 - SDLK_GP2X_Y* = 14 - SDLK_GP2X_X* = 15 - SDLK_GP2X_VOLUP* = 16 - SDLK_GP2X_VOLDOWN* = 17 - SDLK_GP2X_CLICK* = 18 - -const # Enumeration of valid key mods (possibly OR'd together) - KMOD_NONE* = 0x00000000 - KMOD_LSHIFT* = 0x00000001 - KMOD_RSHIFT* = 0x00000002 - KMOD_LCTRL* = 0x00000040 - KMOD_RCTRL* = 0x00000080 - KMOD_LALT* = 0x00000100 - KMOD_RALT* = 0x00000200 - KMOD_LMETA* = 0x00000400 - KMOD_RMETA* = 0x00000800 - KMOD_NUM* = 0x00001000 - KMOD_CAPS* = 0x00002000 - KMOD_MODE* = 44000 - KMOD_RESERVED* = 0x00008000 - KMOD_CTRL* = (KMOD_LCTRL or KMOD_RCTRL) - KMOD_SHIFT* = (KMOD_LSHIFT or KMOD_RSHIFT) - KMOD_ALT* = (KMOD_LALT or KMOD_RALT) - KMOD_META* = (KMOD_LMETA or KMOD_RMETA) #SDL_video.h constants - # Transparency definitions: These define alpha as the opacity of a surface */ - SDL_ALPHA_OPAQUE* = 255 - SDL_ALPHA_TRANSPARENT* = 0 # These are the currently supported flags for the SDL_surface - # Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() - SDL_SWSURFACE* = 0x00000000 # Surface is in system memory - SDL_HWSURFACE* = 0x00000001 # Surface is in video memory - SDL_ASYNCBLIT* = 0x00000004 # Use asynchronous blits if possible - # Available for SDL_SetVideoMode() - SDL_ANYFORMAT* = 0x10000000 # Allow any video depth/pixel-format - SDL_HWPALETTE* = 0x20000000 # Surface has exclusive palette - SDL_DOUBLEBUF* = 0x40000000 # Set up double-buffered video mode - SDL_FULLSCREEN* = 0x80000000 # Surface is a full screen display - SDL_OPENGL* = 0x00000002 # Create an OpenGL rendering context - SDL_OPENGLBLIT* = 0x00000002 # Create an OpenGL rendering context - SDL_RESIZABLE* = 0x00000010 # This video mode may be resized - SDL_NOFRAME* = 0x00000020 # No window caption or edge frame - # Used internally (read-only) - SDL_HWACCEL* = 0x00000100 # Blit uses hardware acceleration - SDL_SRCCOLORKEY* = 0x00001000 # Blit uses a source color key - SDL_RLEACCELOK* = 0x00002000 # Private flag - SDL_RLEACCEL* = 0x00004000 # Colorkey blit is RLE accelerated - SDL_SRCALPHA* = 0x00010000 # Blit uses source alpha blending - SDL_SRCCLIPPING* = 0x00100000 # Blit uses source clipping - SDL_PREALLOC* = 0x01000000 # Surface uses preallocated memory - # The most common video overlay formats. - # For an explanation of these pixel formats, see: - # http://www.webartz.com/fourcc/indexyuv.htm - # - # For information on the relationship between color spaces, see: - # - # http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html - SDL_YV12_OVERLAY* = 0x32315659 # Planar mode: Y + V + U (3 planes) - SDL_IYUV_OVERLAY* = 0x56555949 # Planar mode: Y + U + V (3 planes) - SDL_YUY2_OVERLAY* = 0x32595559 # Packed mode: Y0+U0+Y1+V0 (1 plane) - SDL_UYVY_OVERLAY* = 0x59565955 # Packed mode: U0+Y0+V0+Y1 (1 plane) - SDL_YVYU_OVERLAY* = 0x55595659 # Packed mode: Y0+V0+Y1+U0 (1 plane) - # flags for SDL_SetPalette() - SDL_LOGPAL* = 0x00000001 - SDL_PHYSPAL* = 0x00000002 #SDL_mouse.h constants - # Used as a mask when testing buttons in buttonstate - # Button 1: Left mouse button - # Button 2: Middle mouse button - # Button 3: Right mouse button - # Button 4: Mouse Wheel Up - # Button 5: Mouse Wheel Down - # - SDL_BUTTON_LEFT* = 1 - SDL_BUTTON_MIDDLE* = 2 - SDL_BUTTON_RIGHT* = 3 - SDL_BUTTON_WHEELUP* = 4 - SDL_BUTTON_WHEELDOWN* = 5 - SDL_BUTTON_LMASK* = SDL_PRESSED shl (SDL_BUTTON_LEFT - 1) - SDL_BUTTON_MMASK* = SDL_PRESSED shl (SDL_BUTTON_MIDDLE - 1) - SDL_BUTTON_RMask* = SDL_PRESSED shl (SDL_BUTTON_RIGHT - 1) # SDL_active.h constants - # The available application states - SDL_APPMOUSEFOCUS* = 0x00000001 # The app has mouse coverage - SDL_APPINPUTFOCUS* = 0x00000002 # The app has input focus - SDL_APPACTIVE* = 0x00000004 # The application is active - # SDL_mutex.h constants - # Synchronization functions which can time out return this value - # they time out. - SDL_MUTEX_TIMEDOUT* = 1 # This is the timeout value which corresponds to never time out - SDL_MUTEX_MAXWAIT* = not int(0) - SDL_GRAB_QUERY* = - 1 - SDL_GRAB_OFF* = 0 - SDL_GRAB_ON* = 1 #SDL_GRAB_FULLSCREEN // Used internally - -type - THandle* = int #SDL_types.h types - # Basic data types - TSDL_Bool* = enum - SDL_FALSE, SDL_TRUE - PUInt8Array* = ptr TUInt8Array - PUInt8* = ptr UInt8 - PPUInt8* = ptr PUInt8 - UInt8* = int8 - TUInt8Array* = array[0..high(int) shr 1, UInt8] - PUInt16* = ptr UInt16 - UInt16* = int16 - PSInt8* = ptr SInt8 - SInt8* = int8 - PSInt16* = ptr SInt16 - SInt16* = int16 - PUInt32* = ptr UInt32 - UInt32* = int - SInt32* = int - PInt* = ptr int - PShortInt* = ptr int8 - PUInt64* = ptr UInt64 - UInt64*{.final.} = object - hi*: UInt32 - lo*: UInt32 - - PSInt64* = ptr SInt64 - SInt64*{.final.} = object - hi*: UInt32 - lo*: UInt32 - - TSDL_GrabMode* = int # SDL_error.h types - TSDL_errorcode* = enum - SDL_ENOMEM, SDL_EFREAD, SDL_EFWRITE, SDL_EFSEEK, SDL_LASTERROR - SDL_errorcode* = TSDL_errorcode - TArg*{.final.} = object - buf*: array[0..ERR_MAX_STRLEN - 1, int8] - - PSDL_error* = ptr TSDL_error - TSDL_error*{.final.} = object # This is a numeric value corresponding to the current error - # SDL_rwops.h types - # This is the read/write operation structure -- very basic - # some helper types to handle the unions - # "packed" is only guessed - error*: int # This is a key used to index into a language hashtable containing - # internationalized versions of the SDL error messages. If the key - # is not in the hashtable, or no hashtable is available, the key is - # used directly as an error message format string. - key*: array[0..ERR_MAX_STRLEN - 1, int8] # These are the arguments for the error functions - argc*: int - args*: array[0..ERR_MAX_ARGS - 1, TArg] - - TStdio*{.final.} = object - autoclose*: int # FILE * is only defined in Kylix so we use a simple Pointer - fp*: Pointer - - TMem*{.final.} = object - base*: PUInt8 - here*: PUInt8 - stop*: PUInt8 - - TUnknown*{.final.} = object # first declare the pointer type - data1*: Pointer - - PSDL_RWops* = ptr TSDL_RWops # now the pointer to function types - TSeek* = proc (context: PSDL_RWops, offset: int, whence: int): int{.cdecl.} - TRead* = proc (context: PSDL_RWops, thePtr: Pointer, size: int, maxnum: int): int{. - cdecl.} - TWrite* = proc (context: PSDL_RWops, thePtr: Pointer, size: int, num: int): int{. - cdecl.} - TClose* = proc (context: PSDL_RWops): int{.cdecl.} # the variant record itself - trange010 = range[0..2] - TSDL_RWops*{.final.} = object - seek*: TSeek - read*: TRead - write*: TWrite - closeFile*: TClose # a keyword as name is not allowed - # be warned! structure alignment may arise at this point - case theType*: trange010 - of trange010(0): - stdio*: TStdio - of trange010(1): - mem*: TMem - of trange010(2): - unknown*: TUnknown - - - SDL_RWops* = TSDL_RWops # SDL_timer.h types - # Function prototype for the timer callback function - TSDL_TimerCallback* = proc (interval: UInt32): UInt32{.cdecl.} # New timer API, supports multiple timers - # Written by Stephane Peter - # <megastep@lokigames.com> - # Function prototype for the new timer callback function. - # The callback function is passed the current timer interval and returns - # the next timer interval. If the returned value is the same as the one - # passed in, the periodic alarm continues, otherwise a new alarm is - # scheduled. If the callback returns 0, the periodic alarm is cancelled. - TSDL_NewTimerCallback* = proc (interval: UInt32, param: Pointer): UInt32{. - cdecl.} # Definition of the timer ID type - PSDL_TimerID* = ptr TSDL_TimerID - TSDL_TimerID*{.final.} = object - interval*: UInt32 - callback*: TSDL_NewTimerCallback - param*: Pointer - last_alarm*: UInt32 - next*: PSDL_TimerID - - TSDL_AudioSpecCallback* = proc (userdata: Pointer, stream: PUInt8, length: int){. - cdecl.} # SDL_audio.h types - # The calculated values in this structure are calculated by SDL_OpenAudio() - PSDL_AudioSpec* = ptr TSDL_AudioSpec - TSDL_AudioSpec*{.final.} = object # A structure to hold a set of audio conversion filters and buffers - freq*: int # DSP frequency -- samples per second - format*: UInt16 # Audio data format - channels*: UInt8 # Number of channels: 1 mono, 2 stereo - silence*: UInt8 # Audio buffer silence value (calculated) - samples*: UInt16 # Audio buffer size in samples - padding*: UInt16 # Necessary for some compile environments - size*: UInt32 # Audio buffer size in bytes (calculated) - # This function is called when the audio device needs more data. - # 'stream' is a pointer to the audio data buffer - # 'len' is the length of that buffer in bytes. - # Once the callback returns, the buffer will no longer be valid. - # Stereo samples are stored in a LRLRLR ordering. - callback*: TSDL_AudioSpecCallback - userdata*: Pointer - - PSDL_AudioCVT* = ptr TSDL_AudioCVT - PSDL_AudioCVTFilter* = ptr TSDL_AudioCVTFilter - TSDL_AudioCVTFilter*{.final.} = object - cvt*: PSDL_AudioCVT - format*: UInt16 - - PSDL_AudioCVTFilterArray* = ptr TSDL_AudioCVTFilterArray - TSDL_AudioCVTFilterArray* = array[0..9, PSDL_AudioCVTFilter] - TSDL_AudioCVT*{.final.} = object - needed*: int # Set to 1 if conversion possible - src_format*: UInt16 # Source audio format - dst_format*: UInt16 # Target audio format - rate_incr*: float64 # Rate conversion increment - buf*: PUInt8 # Buffer to hold entire audio data - length*: int # Length of original audio buffer - len_cvt*: int # Length of converted audio buffer - len_mult*: int # buffer must be len*len_mult big - len_ratio*: float64 # Given len, final size is len*len_ratio - filters*: TSDL_AudioCVTFilterArray - filter_index*: int # Current audio conversion function - - TSDL_Audiostatus* = enum # SDL_cdrom.h types - SDL_AUDIO_STOPPED, SDL_AUDIO_PLAYING, SDL_AUDIO_PAUSED - TSDL_CDStatus* = enum - CD_ERROR, CD_TRAYEMPTY, CD_STOPPED, CD_PLAYING, CD_PAUSED - PSDL_CDTrack* = ptr TSDL_CDTrack - TSDL_CDTrack*{.final.} = object # This structure is only current as of the last call to SDL_CDStatus() - id*: UInt8 # Track number - theType*: UInt8 # Data or audio track - unused*: UInt16 - len*: UInt32 # Length, in frames, of this track - offset*: UInt32 # Offset, in frames, from start of disk - - PSDL_CD* = ptr TSDL_CD - TSDL_CD*{.final.} = object #SDL_joystick.h types - id*: int # Private drive identifier - status*: TSDL_CDStatus # Current drive status - # The rest of this structure is only valid if there's a CD in drive - numtracks*: int # Number of tracks on disk - cur_track*: int # Current track position - cur_frame*: int # Current frame offset within current track - track*: array[0..SDL_MAX_TRACKS, TSDL_CDTrack] - - PTransAxis* = ptr TTransAxis - TTransAxis*{.final.} = object # The private structure used to keep track of a joystick - offset*: int - scale*: float32 - - PJoystick_hwdata* = ptr TJoystick_hwdata - TJoystick_hwdata*{.final.} = object # joystick ID - id*: int # values used to translate device-specific coordinates into SDL-standard ranges - transaxis*: array[0..5, TTransAxis] - - PBallDelta* = ptr TBallDelta - TBallDelta*{.final.} = object # Current ball motion deltas - # The SDL joystick structure - dx*: int - dy*: int - - PSDL_Joystick* = ptr TSDL_Joystick - TSDL_Joystick*{.final.} = object # SDL_verion.h types - index*: UInt8 # Device index - name*: cstring # Joystick name - system dependent - naxes*: int # Number of axis controls on the joystick - axes*: PUInt16 # Current axis states - nhats*: int # Number of hats on the joystick - hats*: PUInt8 # Current hat states - nballs*: int # Number of trackballs on the joystick - balls*: PBallDelta # Current ball motion deltas - nbuttons*: int # Number of buttons on the joystick - buttons*: PUInt8 # Current button states - hwdata*: PJoystick_hwdata # Driver dependent information - ref_count*: int # Reference count for multiple opens - - PSDL_version* = ptr TSDL_version - TSDL_version*{.final.} = object # SDL_keyboard.h types - major*: UInt8 - minor*: UInt8 - patch*: UInt8 - - TSDLKey* = int32 - TSDLMod* = int32 - PSDL_KeySym* = ptr TSDL_KeySym - TSDL_KeySym*{.final.} = object # SDL_events.h types - #Checks the event queue for messages and optionally returns them. - # If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to - # the back of the event queue. - # If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front - # of the event queue, matching 'mask', will be returned and will not - # be removed from the queue. - # If 'action' is SDL_GETEVENT, up to 'numevents' events at the front - # of the event queue, matching 'mask', will be returned and will be - # removed from the queue. - # This function returns the number of events actually stored, or -1 - # if there was an error. This function is thread-safe. - scancode*: UInt8 # hardware specific scancode - sym*: TSDLKey # SDL virtual keysym - modifier*: TSDLMod # current key modifiers - unicode*: UInt16 # translated character - - TSDL_EventAction* = enum # Application visibility event structure - SDL_ADDEVENT, SDL_PEEKEVENT, SDL_GETEVENT - TSDL_ActiveEvent*{.final.} = object # SDL_ACTIVEEVENT - # Keyboard event structure - gain*: UInt8 # Whether given states were gained or lost (1/0) - state*: UInt8 # A mask of the focus states - - TSDL_KeyboardEvent*{.final.} = object # SDL_KEYDOWN or SDL_KEYUP - # Mouse motion event structure - which*: UInt8 # The keyboard device index - state*: UInt8 # SDL_PRESSED or SDL_RELEASED - keysym*: TSDL_KeySym - - TSDL_MouseMotionEvent*{.final.} = object # SDL_MOUSEMOTION - # Mouse button event structure - which*: UInt8 # The mouse device index - state*: UInt8 # The current button state - x*, y*: UInt16 # The X/Y coordinates of the mouse - xrel*: SInt16 # The relative motion in the X direction - yrel*: SInt16 # The relative motion in the Y direction - - TSDL_MouseButtonEvent*{.final.} = object # SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP - # Joystick axis motion event structure - which*: UInt8 # The mouse device index - button*: UInt8 # The mouse button index - state*: UInt8 # SDL_PRESSED or SDL_RELEASED - x*: UInt16 # The X coordinates of the mouse at press time - y*: UInt16 # The Y coordinates of the mouse at press time - - TSDL_JoyAxisEvent*{.final.} = object # SDL_JOYAXISMOTION - # Joystick trackball motion event structure - which*: UInt8 # The joystick device index - axis*: UInt8 # The joystick axis index - value*: SInt16 # The axis value (range: -32768 to 32767) - - TSDL_JoyBallEvent*{.final.} = object # SDL_JOYAVBALLMOTION - # Joystick hat position change event structure - which*: UInt8 # The joystick device index - ball*: UInt8 # The joystick trackball index - xrel*: SInt16 # The relative motion in the X direction - yrel*: SInt16 # The relative motion in the Y direction - - TSDL_JoyHatEvent*{.final.} = object # SDL_JOYHATMOTION */ - # Joystick button event structure - which*: UInt8 # The joystick device index */ - hat*: UInt8 # The joystick hat index */ - value*: UInt8 # The hat position value: - # 8 1 2 - # 7 0 3 - # 6 5 4 - # Note that zero means the POV is centered. - - TSDL_JoyButtonEvent*{.final.} = object # SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP - # The "window resized" event - # When you get this event, you are responsible for setting a new video - # mode with the new width and height. - which*: UInt8 # The joystick device index - button*: UInt8 # The joystick button index - state*: UInt8 # SDL_PRESSED or SDL_RELEASED - - TSDL_ResizeEvent*{.final.} = object # SDL_VIDEORESIZE - # A user-defined event type - w*: int # New width - h*: int # New height - - PSDL_UserEvent* = ptr TSDL_UserEvent - TSDL_UserEvent*{.final.} = object # SDL_USEREVENT through SDL_NUMEVENTS-1 - code*: int # User defined event code */ - data1*: Pointer # User defined data pointer */ - data2*: Pointer # User defined data pointer */ - - -when defined(Unix): - type #These are the various supported subsystems under UNIX - TSDL_SysWm* = enum - SDL_SYSWM_X11 -# The windows custom event structure - -when defined(WINDOWS): - type - PSDL_SysWMmsg* = ptr TSDL_SysWMmsg - TSDL_SysWMmsg*{.final.} = object - version*: TSDL_version - hwnd*: THandle # The window for the message - msg*: int # The type of message - w_Param*: int32 # WORD message parameter - lParam*: int32 # LONG message parameter - -elif defined(Unix): - type # The Linux custom event structure - PSDL_SysWMmsg* = ptr TSDL_SysWMmsg - TSDL_SysWMmsg*{.final.} = object - version*: TSDL_version - subsystem*: TSDL_SysWm - when false: - event*: TXEvent -else: - type # The generic custom event structure - PSDL_SysWMmsg* = ptr TSDL_SysWMmsg - TSDL_SysWMmsg*{.final.} = object - version*: TSDL_version - data*: int - -# The Windows custom window manager information structure - -when defined(WINDOWS): - type - PSDL_SysWMinfo* = ptr TSDL_SysWMinfo - TSDL_SysWMinfo*{.final.} = object - version*: TSDL_version - window*: THandle # The display window - -elif defined(Unix): - type - TX11*{.final.} = object - when false: - display*: PDisplay # The X11 display - window*: TWindow # The X11 display window - # These locking functions should be called around - # any X11 functions using the display variable. - # They lock the event thread, so should not be - # called around event functions or from event filters. - lock_func*: Pointer - unlock_func*: Pointer # Introduced in SDL 1.0.2 - fswindow*: TWindow # The X11 fullscreen window - wmwindow*: TWindow # The X11 managed input window - - type - PSDL_SysWMinfo* = ptr TSDL_SysWMinfo - TSDL_SysWMinfo*{.final.} = object - version*: TSDL_version - subsystem*: TSDL_SysWm - X11*: TX11 -else: - type # The generic custom window manager information structure - PSDL_SysWMinfo* = ptr TSDL_SysWMinfo - TSDL_SysWMinfo*{.final.} = object - version*: TSDL_version - data*: int - -type - PSDL_SysWMEvent* = ptr TSDL_SysWMEvent - TSDL_SysWMEvent*{.final.} = object - msg*: PSDL_SysWMmsg - - PSDL_Event* = ptr TSDL_Event - TSDL_Event*{.final.} = object # This function sets up a filter to process all events before they - # change internal state and are posted to the internal event queue. - # - # The filter is protypted as: - case theType*: TSDL_EventKind # SDL_NOEVENT, SDL_QUITEV: (); - of SDL_ACTIVEEVENT: - active*: TSDL_ActiveEvent - of SDL_KEYDOWN, SDL_KEYUP: - key*: TSDL_KeyboardEvent - of SDL_MOUSEMOTION: - motion*: TSDL_MouseMotionEvent - of SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP: - button*: TSDL_MouseButtonEvent - of SDL_JOYAXISMOTION: - jaxis*: TSDL_JoyAxisEvent - of SDL_JOYBALLMOTION: - jball*: TSDL_JoyBallEvent - of SDL_JOYHATMOTION: - jhat*: TSDL_JoyHatEvent - of SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP: - jbutton*: TSDL_JoyButtonEvent - of SDL_VIDEORESIZE: - resize*: TSDL_ResizeEvent - of SDL_USEREVENT: - user*: TSDL_UserEvent - of SDL_SYSWMEVENT: - syswm*: TSDL_SysWMEvent - else: - nil - - TSDL_EventFilter* = proc (event: PSDL_Event): int{.cdecl.} # SDL_video.h types - # Useful data types - PPSDL_Rect* = ptr PSDL_Rect - PSDL_Rect* = ptr TSDL_Rect - TSDL_Rect*{.final.} = object - x*, y*: SInt16 - w*, h*: UInt16 - - SDL_Rect* = TSDL_Rect - PSDL_Color* = ptr TSDL_Color - TSDL_Color*{.final.} = object - r*: UInt8 - g*: UInt8 - b*: UInt8 - unused*: UInt8 - - PSDL_ColorArray* = ptr TSDL_ColorArray - TSDL_ColorArray* = array[0..65000, TSDL_Color] - PSDL_Palette* = ptr TSDL_Palette - TSDL_Palette*{.final.} = object # Everything in the pixel format structure is read-only - ncolors*: int - colors*: PSDL_ColorArray - - PSDL_PixelFormat* = ptr TSDL_PixelFormat - TSDL_PixelFormat*{.final.} = object # The structure passed to the low level blit functions - palette*: PSDL_Palette - BitsPerPixel*: UInt8 - BytesPerPixel*: UInt8 - Rloss*: UInt8 - Gloss*: UInt8 - Bloss*: UInt8 - Aloss*: UInt8 - Rshift*: UInt8 - Gshift*: UInt8 - Bshift*: UInt8 - Ashift*: UInt8 - RMask*: UInt32 - GMask*: UInt32 - BMask*: UInt32 - AMask*: UInt32 - colorkey*: UInt32 # RGB color key information - alpha*: UInt8 # Alpha value information (per-surface alpha) - - PSDL_BlitInfo* = ptr TSDL_BlitInfo - TSDL_BlitInfo*{.final.} = object # typedef for private surface blitting functions - s_pixels*: PUInt8 - s_width*: int - s_height*: int - s_skip*: int - d_pixels*: PUInt8 - d_width*: int - d_height*: int - d_skip*: int - aux_data*: Pointer - src*: PSDL_PixelFormat - table*: PUInt8 - dst*: PSDL_PixelFormat - - PSDL_Surface* = ptr TSDL_Surface - TSDL_Blit* = proc (src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface, - dstrect: PSDL_Rect): int{.cdecl.} - TSDL_Surface*{.final.} = object # Useful for determining the video hardware capabilities - flags*: UInt32 # Read-only - format*: PSDL_PixelFormat # Read-only - w*, h*: int # Read-only - pitch*: UInt16 # Read-only - pixels*: Pointer # Read-write - offset*: int # Private - hwdata*: Pointer #TPrivate_hwdata; Hardware-specific surface info - # clipping information: - clip_rect*: TSDL_Rect # Read-only - unused1*: UInt32 # for binary compatibility - # Allow recursive locks - locked*: UInt32 # Private - # info for fast blit mapping to other surfaces - Blitmap*: Pointer # PSDL_BlitMap; // Private - # format version, bumped at every change to invalidate blit maps - format_version*: int # Private - refcount*: int - - PSDL_VideoInfo* = ptr TSDL_VideoInfo - TSDL_VideoInfo*{.final.} = object # The YUV hardware video overlay - hw_available*: UInt8 # Hardware and WindowManager flags in first 2 bits ( see below ) - #hw_available: 1; // Can you create hardware surfaces - # wm_available: 1; // Can you talk to a window manager? - # UnusedBits1: 6; - blit_hw*: UInt8 # Blit Hardware flags. See below for which bits do what - #UnusedBits2: 1; - # blit_hw: 1; // Flag:UInt32 Accelerated blits HW --> HW - # blit_hw_CC: 1; // Flag:UInt32 Accelerated blits with Colorkey - # blit_hw_A: 1; // Flag:UInt32 Accelerated blits with Alpha - # blit_sw: 1; // Flag:UInt32 Accelerated blits SW --> HW - # blit_sw_CC: 1; // Flag:UInt32 Accelerated blits with Colorkey - # blit_sw_A: 1; // Flag:UInt32 Accelerated blits with Alpha - # blit_fill: 1; // Flag:UInt32 Accelerated color fill - UnusedBits3*: UInt8 # Unused at this point - video_mem*: UInt32 # The total amount of video memory (in K) - vfmt*: PSDL_PixelFormat # Value: The format of the video surface - current_w*: SInt32 # Value: The current video mode width - current_h*: SInt32 # Value: The current video mode height - - PSDL_Overlay* = ptr TSDL_Overlay - TSDL_Overlay*{.final.} = object # Public enumeration for setting the OpenGL window attributes. - format*: UInt32 # Overlay format - w*, h*: int # Width and height of overlay - planes*: int # Number of planes in the overlay. Usually either 1 or 3 - pitches*: PUInt16 # An array of pitches, one for each plane. Pitch is the length of a row in bytes. - pixels*: PPUInt8 # An array of pointers to the data of each plane. The overlay should be locked before these pointers are used. - hw_overlay*: UInt32 # This will be set to 1 if the overlay is hardware accelerated. - - TSDL_GLAttr* = enum - SDL_GL_RED_SIZE, SDL_GL_GREEN_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_ALPHA_SIZE, - SDL_GL_BUFFER_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_DEPTH_SIZE, - SDL_GL_STENCIL_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ACCUM_GREEN_SIZE, - SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_STEREO, - SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES, - SDL_GL_ACCELERATED_VISUAL, SDL_GL_SWAP_CONTROL - PSDL_Cursor* = ptr TSDL_Cursor - TSDL_Cursor*{.final.} = object # SDL_mutex.h types - area*: TSDL_Rect # The area of the mouse cursor - hot_x*, hot_y*: SInt16 # The "tip" of the cursor - data*: PUInt8 # B/W cursor data - mask*: PUInt8 # B/W cursor mask - save*: array[1..2, PUInt8] # Place to save cursor area - wm_cursor*: Pointer # Window-manager cursor - - -type - PSDL_Mutex* = ptr TSDL_Mutex - TSDL_Mutex*{.final.} = object - PSDL_semaphore* = ptr TSDL_semaphore - TSDL_semaphore*{.final.} = object - PSDL_Sem* = ptr TSDL_Sem - TSDL_Sem* = TSDL_Semaphore - PSDL_Cond* = ptr TSDL_Cond - TSDL_Cond*{.final.} = object # SDL_thread.h types - -when defined(WINDOWS): - type - TSYS_ThreadHandle* = THandle -when defined(Unix): - type - TSYS_ThreadHandle* = pointer -type # This is the system-independent thread info structure - PSDL_Thread* = ptr TSDL_Thread - TSDL_Thread*{.final.} = object # Helper Types - # Keyboard State Array ( See demos for how to use ) - threadid*: UInt32 - handle*: TSYS_ThreadHandle - status*: int - errbuf*: TSDL_Error - data*: Pointer - - PKeyStateArr* = ptr TKeyStateArr - TKeyStateArr* = array[0..65000, UInt8] # Types required so we don't need to use Windows.pas - PInteger* = ptr int - PByte* = ptr int8 - PWord* = ptr int16 - PLongWord* = ptr int32 # General arrays - PByteArray* = ptr TByteArray - TByteArray* = array[0..32767, int8] - PWordArray* = ptr TWordArray - TWordArray* = array[0..16383, int16] # Generic procedure pointer - TProcedure* = proc () #------------------------------------------------------------------------------ - # initialization - #------------------------------------------------------------------------------ - # This function loads the SDL dynamically linked library and initializes - # the subsystems specified by 'flags' (and those satisfying dependencies) - # Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup - # signal handlers for some commonly ignored fatal signals (like SIGSEGV) - -proc SDL_Init*(flags: UInt32): int{.cdecl, importc, dynlib: SDLLibName.} - # This function initializes specific SDL subsystems -proc SDL_InitSubSystem*(flags: UInt32): int{.cdecl, importc, dynlib: SDLLibName.} - # This function cleans up specific SDL subsystems -proc SDL_QuitSubSystem*(flags: UInt32){.cdecl, importc, dynlib: SDLLibName.} - # This function returns mask of the specified subsystems which have - # been initialized. - # If 'flags' is 0, it returns a mask of all initialized subsystems. -proc SDL_WasInit*(flags: UInt32): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # This function cleans up all initialized subsystems and unloads the - # dynamically linked library. You should call it upon all exit conditions. -proc SDL_Quit*(){.cdecl, importc, dynlib: SDLLibName.} -when defined(WINDOWS): - # This should be called from your WinMain() function, if any - proc SDL_RegisterApp*(name: cstring, style: UInt32, h_Inst: Pointer): int{. - cdecl, importc, dynlib: SDLLibName.} -#------------------------------------------------------------------------------ -# types -#------------------------------------------------------------------------------ -# The number of elements in a table - -proc SDL_TableSize*(table: cstring): int - #------------------------------------------------------------------------------ - # error-handling - #------------------------------------------------------------------------------ - # Public functions -proc SDL_GetError*(): cstring{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_SetError*(fmt: cstring){.cdecl, importc, dynlib: SDLLibName.} -proc SDL_ClearError*(){.cdecl, importc, dynlib: SDLLibName.} -when not(defined(WINDOWS)): - proc SDL_Error*(Code: TSDL_errorcode){.cdecl, importc, dynlib: SDLLibName.} -# Private error message function - used internally - -proc SDL_OutOfMemory*() - #------------------------------------------------------------------------------ - # io handling - #------------------------------------------------------------------------------ - # Functions to create SDL_RWops structures from various data sources -proc SDL_RWFromFile*(filename, mode: cstring): PSDL_RWops{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_FreeRW*(area: PSDL_RWops){.cdecl, importc, dynlib: SDLLibName.} - #fp is FILE *fp ??? -proc SDL_RWFromFP*(fp: Pointer, autoclose: int): PSDL_RWops{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_RWFromMem*(mem: Pointer, size: int): PSDL_RWops{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_RWFromConstMem*(mem: Pointer, size: int): PSDL_RWops{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_AllocRW*(): PSDL_RWops{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_RWSeek*(context: PSDL_RWops, offset: int, whence: int): int -proc SDL_RWTell*(context: PSDL_RWops): int -proc SDL_RWRead*(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int -proc SDL_RWWrite*(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int -proc SDL_RWClose*(context: PSDL_RWops): int - #------------------------------------------------------------------------------ - # time-handling - #------------------------------------------------------------------------------ - # Get the number of milliseconds since the SDL library initialization. - # Note that this value wraps if the program runs for more than ~49 days. -proc SDL_GetTicks*(): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # Wait a specified number of milliseconds before returning -proc SDL_Delay*(msec: UInt32){.cdecl, importc, dynlib: SDLLibName.} - # Add a new timer to the pool of timers already running. - # Returns a timer ID, or NULL when an error occurs. -proc SDL_AddTimer*(interval: UInt32, callback: TSDL_NewTimerCallback, - param: Pointer): PSDL_TimerID{.cdecl, importc, dynlib: SDLLibName.} - # Remove one of the multiple timers knowing its ID. - # Returns a boolean value indicating success. -proc SDL_RemoveTimer*(t: PSDL_TimerID): TSDL_Bool{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_SetTimer*(interval: UInt32, callback: TSDL_TimerCallback): int{.cdecl, - importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # audio-routines - #------------------------------------------------------------------------------ - # These functions are used internally, and should not be used unless you - # have a specific need to specify the audio driver you want to use. - # You should normally use SDL_Init() or SDL_InitSubSystem(). -proc SDL_AudioInit*(driver_name: cstring): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_AudioQuit*(){.cdecl, importc, dynlib: SDLLibName.} - # This function fills the given character buffer with the name of the - # current audio driver, and returns a Pointer to it if the audio driver has - # been initialized. It returns NULL if no driver has been initialized. -proc SDL_AudioDriverName*(namebuf: cstring, maxlen: int): cstring{.cdecl, - importc, dynlib: SDLLibName.} - # This function opens the audio device with the desired parameters, and - # returns 0 if successful, placing the actual hardware parameters in the - # structure pointed to by 'obtained'. If 'obtained' is NULL, the audio - # data passed to the callback function will be guaranteed to be in the - # requested format, and will be automatically converted to the hardware - # audio format if necessary. This function returns -1 if it failed - # to open the audio device, or couldn't set up the audio thread. - # - # When filling in the desired audio spec structure, - # 'desired->freq' should be the desired audio frequency in samples-per-second. - # 'desired->format' should be the desired audio format. - # 'desired->samples' is the desired size of the audio buffer, in samples. - # This number should be a power of two, and may be adjusted by the audio - # driver to a value more suitable for the hardware. Good values seem to - # range between 512 and 8096 inclusive, depending on the application and - # CPU speed. Smaller values yield faster response time, but can lead - # to underflow if the application is doing heavy processing and cannot - # fill the audio buffer in time. A stereo sample consists of both right - # and left channels in LR ordering. - # Note that the number of samples is directly related to time by the - # following formula: ms = (samples*1000)/freq - # 'desired->size' is the size in bytes of the audio buffer, and is - # calculated by SDL_OpenAudio(). - # 'desired->silence' is the value used to set the buffer to silence, - # and is calculated by SDL_OpenAudio(). - # 'desired->callback' should be set to a function that will be called - # when the audio device is ready for more data. It is passed a pointer - # to the audio buffer, and the length in bytes of the audio buffer. - # This function usually runs in a separate thread, and so you should - # protect data structures that it accesses by calling SDL_LockAudio() - # and SDL_UnlockAudio() in your code. - # 'desired->userdata' is passed as the first parameter to your callback - # function. - # - # The audio device starts out playing silence when it's opened, and should - # be enabled for playing by calling SDL_PauseAudio(0) when you are ready - # for your audio callback function to be called. Since the audio driver - # may modify the requested size of the audio buffer, you should allocate - # any local mixing buffers after you open the audio device. -proc SDL_OpenAudio*(desired, obtained: PSDL_AudioSpec): int{.cdecl, - importc, dynlib: SDLLibName.} - # Get the current audio state: -proc SDL_GetAudioStatus*(): TSDL_Audiostatus{.cdecl, importc, dynlib: SDLLibName.} - # This function pauses and unpauses the audio callback processing. - # It should be called with a parameter of 0 after opening the audio - # device to start playing sound. This is so you can safely initialize - # data for your callback function after opening the audio device. - # Silence will be written to the audio device during the pause. -proc SDL_PauseAudio*(pause_on: int){.cdecl, importc, dynlib: SDLLibName.} - # This function loads a WAVE from the data source, automatically freeing - # that source if 'freesrc' is non-zero. For example, to load a WAVE file, - # you could do: - # SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...); - # - # If this function succeeds, it returns the given SDL_AudioSpec, - # filled with the audio data format of the wave data, and sets - # 'audio_buf' to a malloc()'d buffer containing the audio data, - # and sets 'audio_len' to the length of that audio buffer, in bytes. - # You need to free the audio buffer with SDL_FreeWAV() when you are - # done with it. - # - # This function returns NULL and sets the SDL error message if the - # wave file cannot be opened, uses an unknown data format, or is - # corrupt. Currently raw and MS-ADPCM WAVE files are supported. -proc SDL_LoadWAV_RW*(src: PSDL_RWops, freesrc: int, spec: PSDL_AudioSpec, - audio_buf: PUInt8, audiolen: PUInt32): PSDL_AudioSpec{. - cdecl, importc, dynlib: SDLLibName.} - # Compatibility convenience function -- loads a WAV from a file -proc SDL_LoadWAV*(filename: cstring, spec: PSDL_AudioSpec, audio_buf: PUInt8, - audiolen: PUInt32): PSDL_AudioSpec - # This function frees data previously allocated with SDL_LoadWAV_RW() -proc SDL_FreeWAV*(audio_buf: PUInt8){.cdecl, importc, dynlib: SDLLibName.} - # This function takes a source format and rate and a destination format - # and rate, and initializes the 'cvt' structure with information needed - # by SDL_ConvertAudio() to convert a buffer of audio data from one format - # to the other. - # This function returns 0, or -1 if there was an error. -proc SDL_BuildAudioCVT*(cvt: PSDL_AudioCVT, src_format: UInt16, - src_channels: UInt8, src_rate: int, dst_format: UInt16, - dst_channels: UInt8, dst_rate: int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(), - # created an audio buffer cvt->buf, and filled it with cvt->len bytes of - # audio data in the source format, this function will convert it in-place - # to the desired format. - # The data conversion may expand the size of the audio data, so the buffer - # cvt->buf should be allocated after the cvt structure is initialized by - # SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long. -proc SDL_ConvertAudio*(cvt: PSDL_AudioCVT): int{.cdecl, importc, dynlib: SDLLibName.} - # This takes two audio buffers of the playing audio format and mixes - # them, performing addition, volume adjustment, and overflow clipping. - # The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME - # for full audio volume. Note this does not change hardware volume. - # This is provided for convenience -- you can mix your own audio data. -proc SDL_MixAudio*(dst, src: PUInt8, length: UInt32, volume: int){.cdecl, - importc, dynlib: SDLLibName.} - # The lock manipulated by these functions protects the callback function. - # During a LockAudio/UnlockAudio pair, you can be guaranteed that the - # callback function is not running. Do not call these from the callback - # function or you will cause deadlock. -proc SDL_LockAudio*(){.cdecl, importc, dynlib: SDLLibName.} -proc SDL_UnlockAudio*(){.cdecl, importc, dynlib: SDLLibName.} - # This function shuts down audio processing and closes the audio device. -proc SDL_CloseAudio*(){.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # CD-routines - #------------------------------------------------------------------------------ - # Returns the number of CD-ROM drives on the system, or -1 if - # SDL_Init() has not been called with the SDL_INIT_CDROM flag. -proc SDL_CDNumDrives*(): int{.cdecl, importc, dynlib: SDLLibName.} - # Returns a human-readable, system-dependent identifier for the CD-ROM. - # Example: - # "/dev/cdrom" - # "E:" - # "/dev/disk/ide/1/master" -proc SDL_CDName*(drive: int): cstring{.cdecl, importc, dynlib: SDLLibName.} - # Opens a CD-ROM drive for access. It returns a drive handle on success, - # or NULL if the drive was invalid or busy. This newly opened CD-ROM - # becomes the default CD used when other CD functions are passed a NULL - # CD-ROM handle. - # Drives are numbered starting with 0. Drive 0 is the system default CD-ROM. -proc SDL_CDOpen*(drive: int): PSDL_CD{.cdecl, importc, dynlib: SDLLibName.} - # This function returns the current status of the given drive. - # If the drive has a CD in it, the table of contents of the CD and current - # play position of the CD will be stored in the SDL_CD structure. -proc SDL_CDStatus*(cdrom: PSDL_CD): TSDL_CDStatus{.cdecl, importc, dynlib: SDLLibName.} - # Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks' - # tracks and 'nframes' frames. If both 'ntrack' and 'nframe' are 0, play - # until the end of the CD. This function will skip data tracks. - # This function should only be called after calling SDL_CDStatus() to - # get track information about the CD. - # - # For example: - # // Play entire CD: - # if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then - # SDL_CDPlayTracks(cdrom, 0, 0, 0, 0); - # // Play last track: - # if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then - # begin - # SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0); - # end; - # - # // Play first and second track and 10 seconds of third track: - # if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) - # SDL_CDPlayTracks(cdrom, 0, 0, 2, 10); - # - # This function returns 0, or -1 if there was an error. -proc SDL_CDPlayTracks*(cdrom: PSDL_CD, start_track: int, start_frame: int, - ntracks: int, nframes: int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Play the given CD starting at 'start' frame for 'length' frames. - # It returns 0, or -1 if there was an error. -proc SDL_CDPlay*(cdrom: PSDL_CD, start: int, len: int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Pause play -- returns 0, or -1 on error -proc SDL_CDPause*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.} - # Resume play -- returns 0, or -1 on error -proc SDL_CDResume*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.} - # Stop play -- returns 0, or -1 on error -proc SDL_CDStop*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.} - # Eject CD-ROM -- returns 0, or -1 on error -proc SDL_CDEject*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.} - # Closes the handle for the CD-ROM drive -proc SDL_CDClose*(cdrom: PSDL_CD){.cdecl, importc, dynlib: SDLLibName.} - # Given a status, returns true if there's a disk in the drive -proc SDL_CDInDrive*(status: TSDL_CDStatus): bool - # Conversion functions from frames to Minute/Second/Frames and vice versa -proc FRAMES_TO_MSF*(frames: int, M: var int, S: var int, F: var int) -proc MSF_TO_FRAMES*(M: int, S: int, F: int): int - #------------------------------------------------------------------------------ - # JoyStick-routines - #------------------------------------------------------------------------------ - # Count the number of joysticks attached to the system -proc SDL_NumJoysticks*(): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the implementation dependent name of a joystick. - # This can be called before any joysticks are opened. - # If no name can be found, this function returns NULL. -proc SDL_JoystickName*(index: int): cstring{.cdecl, importc, dynlib: SDLLibName.} - # Open a joystick for use - the index passed as an argument refers to - # the N'th joystick on the system. This index is the value which will - # identify this joystick in future joystick events. - # - # This function returns a joystick identifier, or NULL if an error occurred. -proc SDL_JoystickOpen*(index: int): PSDL_Joystick{.cdecl, importc, dynlib: SDLLibName.} - # Returns 1 if the joystick has been opened, or 0 if it has not. -proc SDL_JoystickOpened*(index: int): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the device index of an opened joystick. -proc SDL_JoystickIndex*(joystick: PSDL_Joystick): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the number of general axis controls on a joystick -proc SDL_JoystickNumAxes*(joystick: PSDL_Joystick): int{.cdecl, - importc, dynlib: SDLLibName.} - # Get the number of trackballs on a joystick - # Joystick trackballs have only relative motion events associated - # with them and their state cannot be polled. -proc SDL_JoystickNumBalls*(joystick: PSDL_Joystick): int{.cdecl, - importc, dynlib: SDLLibName.} - # Get the number of POV hats on a joystick -proc SDL_JoystickNumHats*(joystick: PSDL_Joystick): int{.cdecl, - importc, dynlib: SDLLibName.} - # Get the number of buttons on a joystick -proc SDL_JoystickNumButtons*(joystick: PSDL_Joystick): int{.cdecl, - importc, dynlib: SDLLibName.} - # Update the current state of the open joysticks. - # This is called automatically by the event loop if any joystick - # events are enabled. -proc SDL_JoystickUpdate*(){.cdecl, importc, dynlib: SDLLibName.} - # Enable/disable joystick event polling. - # If joystick events are disabled, you must call SDL_JoystickUpdate() - # yourself and check the state of the joystick when you want joystick - # information. - # The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE. -proc SDL_JoystickEventState*(state: int): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the current state of an axis control on a joystick - # The state is a value ranging from -32768 to 32767. - # The axis indices start at index 0. -proc SDL_JoystickGetAxis*(joystick: PSDL_Joystick, axis: int): SInt16{.cdecl, - importc, dynlib: SDLLibName.} - # The hat indices start at index 0. -proc SDL_JoystickGetHat*(joystick: PSDL_Joystick, hat: int): UInt8{.cdecl, - importc, dynlib: SDLLibName.} - # Get the ball axis change since the last poll - # This returns 0, or -1 if you passed it invalid parameters. - # The ball indices start at index 0. -proc SDL_JoystickGetBall*(joystick: PSDL_Joystick, ball: int, dx: var int, - dy: var int): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the current state of a button on a joystick - # The button indices start at index 0. -proc SDL_JoystickGetButton*(joystick: PSDL_Joystick, Button: int): UInt8{.cdecl, - importc, dynlib: SDLLibName.} - # Close a joystick previously opened with SDL_JoystickOpen() -proc SDL_JoystickClose*(joystick: PSDL_Joystick){.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # event-handling - #------------------------------------------------------------------------------ - # Pumps the event loop, gathering events from the input devices. - # This function updates the event queue and internal input device state. - # This should only be run in the thread that sets the video mode. -proc SDL_PumpEvents*(){.cdecl, importc, dynlib: SDLLibName.} - # Checks the event queue for messages and optionally returns them. - # If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to - # the back of the event queue. - # If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front - # of the event queue, matching 'mask', will be returned and will not - # be removed from the queue. - # If 'action' is SDL_GETEVENT, up to 'numevents' events at the front - # of the event queue, matching 'mask', will be returned and will be - # removed from the queue. - # This function returns the number of events actually stored, or -1 - # if there was an error. This function is thread-safe. -proc SDL_PeepEvents*(events: PSDL_Event, numevents: int, - action: TSDL_eventaction, mask: UInt32): int{.cdecl, - importc, dynlib: SDLLibName.} - # Polls for currently pending events, and returns 1 if there are any pending - # events, or 0 if there are none available. If 'event' is not NULL, the next - # event is removed from the queue and stored in that area. -proc SDL_PollEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.} - # Waits indefinitely for the next available event, returning 1, or 0 if there - # was an error while waiting for events. If 'event' is not NULL, the next - # event is removed from the queue and stored in that area. -proc SDL_WaitEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_PushEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.} - # If the filter returns 1, then the event will be added to the internal queue. - # If it returns 0, then the event will be dropped from the queue, but the - # internal state will still be updated. This allows selective filtering of - # dynamically arriving events. - # - # WARNING: Be very careful of what you do in the event filter function, as - # it may run in a different thread! - # - # There is one caveat when dealing with the SDL_QUITEVENT event type. The - # event filter is only called when the window manager desires to close the - # application window. If the event filter returns 1, then the window will - # be closed, otherwise the window will remain open if possible. - # If the quit event is generated by an interrupt signal, it will bypass the - # internal queue and be delivered to the application at the next event poll. -proc SDL_SetEventFilter*(filter: TSDL_EventFilter){.cdecl, importc, dynlib: SDLLibName.} - # Return the current event filter - can be used to "chain" filters. - # If there is no event filter set, this function returns NULL. -proc SDL_GetEventFilter*(): TSDL_EventFilter{.cdecl, importc, dynlib: SDLLibName.} - # This function allows you to set the state of processing certain events. - # If 'state' is set to SDL_IGNORE, that event will be automatically dropped - # from the event queue and will not event be filtered. - # If 'state' is set to SDL_ENABLE, that event will be processed normally. - # If 'state' is set to SDL_QUERY, SDL_EventState() will return the - # current processing state of the specified event. -proc SDL_EventState*(theType: UInt8, state: int): UInt8{.cdecl, - importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # Version Routines - #------------------------------------------------------------------------------ - # This macro can be used to fill a version structure with the compile-time - # version of the SDL library. -proc SDL_VERSION*(X: var TSDL_Version) - # This macro turns the version numbers into a numeric value: - # (1,2,3) -> (1203) - # This assumes that there will never be more than 100 patchlevels -proc SDL_VERSIONNUM*(X, Y, Z: int): int - # This is the version number macro for the current SDL version -proc SDL_COMPILEDVERSION*(): int - # This macro will evaluate to true if compiled with SDL at least X.Y.Z -proc SDL_VERSION_ATLEAST*(X: int, Y: int, Z: int): bool - # This function gets the version of the dynamically linked SDL library. - # it should NOT be used to fill a version structure, instead you should - # use the SDL_Version() macro. -proc SDL_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # video - #------------------------------------------------------------------------------ - # These functions are used internally, and should not be used unless you - # have a specific need to specify the video driver you want to use. - # You should normally use SDL_Init() or SDL_InitSubSystem(). - # - # SDL_VideoInit() initializes the video subsystem -- sets up a connection - # to the window manager, etc, and determines the current video mode and - # pixel format, but does not initialize a window or graphics mode. - # Note that event handling is activated by this routine. - # - # If you use both sound and video in your application, you need to call - # SDL_Init() before opening the sound device, otherwise under Win32 DirectX, - # you won't be able to set full-screen display modes. -proc SDL_VideoInit*(driver_name: cstring, flags: UInt32): int{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_VideoQuit*(){.cdecl, importc, dynlib: SDLLibName.} - # This function fills the given character buffer with the name of the - # video driver, and returns a pointer to it if the video driver has - # been initialized. It returns NULL if no driver has been initialized. -proc SDL_VideoDriverName*(namebuf: cstring, maxlen: int): cstring{.cdecl, - importc, dynlib: SDLLibName.} - # This function returns a pointer to the current display surface. - # If SDL is doing format conversion on the display surface, this - # function returns the publicly visible surface, not the real video - # surface. -proc SDL_GetVideoSurface*(): PSDL_Surface{.cdecl, importc, dynlib: SDLLibName.} - # This function returns a read-only pointer to information about the - # video hardware. If this is called before SDL_SetVideoMode(), the 'vfmt' - # member of the returned structure will contain the pixel format of the - # "best" video mode. -proc SDL_GetVideoInfo*(): PSDL_VideoInfo{.cdecl, importc, dynlib: SDLLibName.} - # Check to see if a particular video mode is supported. - # It returns 0 if the requested mode is not supported under any bit depth, - # or returns the bits-per-pixel of the closest available mode with the - # given width and height. If this bits-per-pixel is different from the - # one used when setting the video mode, SDL_SetVideoMode() will succeed, - # but will emulate the requested bits-per-pixel with a shadow surface. - # - # The arguments to SDL_VideoModeOK() are the same ones you would pass to - # SDL_SetVideoMode() -proc SDL_VideoModeOK*(width, height, bpp: int, flags: UInt32): int{.cdecl, - importc, importc, dynlib: SDLLibName.} - # Return a pointer to an array of available screen dimensions for the - # given format and video flags, sorted largest to smallest. Returns - # NULL if there are no dimensions available for a particular format, - # or (SDL_Rect **)-1 if any dimension is okay for the given format. - # - # if 'format' is NULL, the mode list will be for the format given - # by SDL_GetVideoInfo( ) - > vfmt -proc SDL_ListModes*(format: PSDL_PixelFormat, flags: UInt32): PPSDL_Rect{.cdecl, - importc, dynlib: SDLLibName.} - # Set up a video mode with the specified width, height and bits-per-pixel. - # - # If 'bpp' is 0, it is treated as the current display bits per pixel. - # - # If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the - # requested bits-per-pixel, but will return whatever video pixel format is - # available. The default is to emulate the requested pixel format if it - # is not natively available. - # - # If SDL_HWSURFACE is set in 'flags', the video surface will be placed in - # video memory, if possible, and you may have to call SDL_LockSurface() - # in order to access the raw framebuffer. Otherwise, the video surface - # will be created in system memory. - # - # If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle - # updates asynchronously, but you must always lock before accessing pixels. - # SDL will wait for updates to complete before returning from the lock. - # - # If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee - # that the colors set by SDL_SetColors() will be the colors you get. - # Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all - # of the colors exactly the way they are requested, and you should look - # at the video surface structure to determine the actual palette. - # If SDL cannot guarantee that the colors you request can be set, - # i.e. if the colormap is shared, then the video surface may be created - # under emulation in system memory, overriding the SDL_HWSURFACE flag. - # - # If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set - # a fullscreen video mode. The default is to create a windowed mode - # if the current graphics system has a window manager. - # If the SDL library is able to set a fullscreen video mode, this flag - # will be set in the surface that is returned. - # - # If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up - # two surfaces in video memory and swap between them when you call - # SDL_Flip(). This is usually slower than the normal single-buffering - # scheme, but prevents "tearing" artifacts caused by modifying video - # memory while the monitor is refreshing. It should only be used by - # applications that redraw the entire screen on every update. - # - # This function returns the video framebuffer surface, or NULL if it fails. -proc SDL_SetVideoMode*(width, height, bpp: int, flags: UInt32): PSDL_Surface{. - cdecl, importc, dynlib: SDLLibName.} - # Makes sure the given list of rectangles is updated on the given screen. - # If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire - # screen. - # These functions should not be called while 'screen' is locked. -proc SDL_UpdateRects*(screen: PSDL_Surface, numrects: int, rects: PSDL_Rect){. - cdecl, importc, dynlib: SDLLibName.} -proc SDL_UpdateRect*(screen: PSDL_Surface, x, y: SInt32, w, h: UInt32){.cdecl, - importc, dynlib: SDLLibName.} - # On hardware that supports double-buffering, this function sets up a flip - # and returns. The hardware will wait for vertical retrace, and then swap - # video buffers before the next video surface blit or lock will return. - # On hardware that doesn not support double-buffering, this is equivalent - # to calling SDL_UpdateRect(screen, 0, 0, 0, 0); - # The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when - # setting the video mode for this function to perform hardware flipping. - # This function returns 0 if successful, or -1 if there was an error. -proc SDL_Flip*(screen: PSDL_Surface): int{.cdecl, importc, dynlib: SDLLibName.} - # Set the gamma correction for each of the color channels. - # The gamma values range (approximately) between 0.1 and 10.0 - # - # If this function isn't supported directly by the hardware, it will - # be emulated using gamma ramps, if available. If successful, this - # function returns 0, otherwise it returns -1. -proc SDL_SetGamma*(redgamma: float32, greengamma: float32, bluegamma: float32): int{. - cdecl, importc, dynlib: SDLLibName.} - # Set the gamma translation table for the red, green, and blue channels - # of the video hardware. Each table is an array of 256 16-bit quantities, - # representing a mapping between the input and output for that channel. - # The input is the index into the array, and the output is the 16-bit - # gamma value at that index, scaled to the output color precision. - # - # You may pass NULL for any of the channels to leave it unchanged. - # If the call succeeds, it will return 0. If the display driver or - # hardware does not support gamma translation, or otherwise fails, - # this function will return -1. -proc SDL_SetGammaRamp*(redtable: PUInt16, greentable: PUInt16, - bluetable: PUInt16): int{.cdecl, importc, dynlib: SDLLibName.} - # Retrieve the current values of the gamma translation tables. - # - # You must pass in valid pointers to arrays of 256 16-bit quantities. - # Any of the pointers may be NULL to ignore that channel. - # If the call succeeds, it will return 0. If the display driver or - # hardware does not support gamma translation, or otherwise fails, - # this function will return -1. -proc SDL_GetGammaRamp*(redtable: PUInt16, greentable: PUInt16, - bluetable: PUInt16): int{.cdecl, importc, dynlib: SDLLibName.} - # Sets a portion of the colormap for the given 8-bit surface. If 'surface' - # is not a palettized surface, this function does nothing, returning 0. - # If all of the colors were set as passed to SDL_SetColors(), it will - # return 1. If not all the color entries were set exactly as given, - # it will return 0, and you should look at the surface palette to - # determine the actual color palette. - # - # When 'surface' is the surface associated with the current display, the - # display colormap will be updated with the requested colors. If - # SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors() - # will always return 1, and the palette is guaranteed to be set the way - # you desire, even if the window colormap has to be warped or run under - # emulation. -proc SDL_SetColors*(surface: PSDL_Surface, colors: PSDL_Color, firstcolor: int, - ncolors: int): int{.cdecl, importc, dynlib: SDLLibName.} - # Sets a portion of the colormap for a given 8-bit surface. - # 'flags' is one or both of: - # SDL_LOGPAL -- set logical palette, which controls how blits are mapped - # to/from the surface, - # SDL_PHYSPAL -- set physical palette, which controls how pixels look on - # the screen - # Only screens have physical palettes. Separate change of physical/logical - # palettes is only possible if the screen has SDL_HWPALETTE set. - # - # The return value is 1 if all colours could be set as requested, and 0 - # otherwise. - # - # SDL_SetColors() is equivalent to calling this function with - # flags = (SDL_LOGPAL or SDL_PHYSPAL). -proc SDL_SetPalette*(surface: PSDL_Surface, flags: int, colors: PSDL_Color, - firstcolor: int, ncolors: int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Maps an RGB triple to an opaque pixel value for a given pixel format -proc SDL_MapRGB*(format: PSDL_PixelFormat, r: UInt8, g: UInt8, b: UInt8): UInt32{. - cdecl, importc, dynlib: SDLLibName.} - # Maps an RGBA quadruple to a pixel value for a given pixel format -proc SDL_MapRGBA*(format: PSDL_PixelFormat, r: UInt8, g: UInt8, b: UInt8, - a: UInt8): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # Maps a pixel value into the RGB components for a given pixel format -proc SDL_GetRGB*(pixel: UInt32, fmt: PSDL_PixelFormat, r: PUInt8, g: PUInt8, - b: PUInt8){.cdecl, importc, dynlib: SDLLibName.} - # Maps a pixel value into the RGBA components for a given pixel format -proc SDL_GetRGBA*(pixel: UInt32, fmt: PSDL_PixelFormat, r: PUInt8, g: PUInt8, - b: PUInt8, a: PUInt8){.cdecl, importc, dynlib: SDLLibName.} - # Allocate and free an RGB surface (must be called after SDL_SetVideoMode) - # If the depth is 4 or 8 bits, an empty palette is allocated for the surface. - # If the depth is greater than 8 bits, the pixel format is set using the - # flags '[RGB]mask'. - # If the function runs out of memory, it will return NULL. - # - # The 'flags' tell what kind of surface to create. - # SDL_SWSURFACE means that the surface should be created in system memory. - # SDL_HWSURFACE means that the surface should be created in video memory, - # with the same format as the display surface. This is useful for surfaces - # that will not change much, to take advantage of hardware acceleration - # when being blitted to the display surface. - # SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with - # this surface, but you must always lock it before accessing the pixels. - # SDL will wait for current blits to finish before returning from the lock. - # SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits. - # If the hardware supports acceleration of colorkey blits between - # two surfaces in video memory, SDL will try to place the surface in - # video memory. If this isn't possible or if there is no hardware - # acceleration available, the surface will be placed in system memory. - # SDL_SRCALPHA means that the surface will be used for alpha blits and - # if the hardware supports hardware acceleration of alpha blits between - # two surfaces in video memory, to place the surface in video memory - # if possible, otherwise it will be placed in system memory. - # If the surface is created in video memory, blits will be _much_ faster, - # but the surface format must be identical to the video surface format, - # and the only way to access the pixels member of the surface is to use - # the SDL_LockSurface() and SDL_UnlockSurface() calls. - # If the requested surface actually resides in video memory, SDL_HWSURFACE - # will be set in the flags member of the returned surface. If for some - # reason the surface could not be placed in video memory, it will not have - # the SDL_HWSURFACE flag set, and will be created in system memory instead. -proc SDL_AllocSurface*(flags: UInt32, width, height, depth: int, - RMask, GMask, BMask, AMask: UInt32): PSDL_Surface -proc SDL_CreateRGBSurface*(flags: UInt32, width, height, depth: int, - RMask, GMask, BMask, AMask: UInt32): PSDL_Surface{. - cdecl, importc, dynlib: SDLLibName.} -proc SDL_CreateRGBSurfaceFrom*(pixels: Pointer, - width, height, depth, pitch: int, - RMask, GMask, BMask, AMask: UInt32): PSDL_Surface{. - cdecl, importc, dynlib: SDLLibName.} -proc SDL_FreeSurface*(surface: PSDL_Surface){.cdecl, importc, dynlib: SDLLibName.} -proc SDL_MustLock*(Surface: PSDL_Surface): bool - # SDL_LockSurface() sets up a surface for directly accessing the pixels. - # Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write - # to and read from 'surface->pixels', using the pixel format stored in - # 'surface->format'. Once you are done accessing the surface, you should - # use SDL_UnlockSurface() to release it. - # - # Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates - # to 0, then you can read and write to the surface at any time, and the - # pixel format of the surface will not change. In particular, if the - # SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you - # will not need to lock the display surface before accessing it. - # - # No operating system or library calls should be made between lock/unlock - # pairs, as critical system locks may be held during this time. - # - # SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked. -proc SDL_LockSurface*(surface: PSDL_Surface): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_UnlockSurface*(surface: PSDL_Surface){.cdecl, importc, dynlib: SDLLibName.} - # Load a surface from a seekable SDL data source (memory or file.) - # If 'freesrc' is non-zero, the source will be closed after being read. - # Returns the new surface, or NULL if there was an error. - # The new surface should be freed with SDL_FreeSurface(). -proc SDL_LoadBMP_RW*(src: PSDL_RWops, freesrc: int): PSDL_Surface{.cdecl, - importc, dynlib: SDLLibName.} - # Convenience macro -- load a surface from a file -proc SDL_LoadBMP*(filename: cstring): PSDL_Surface - # Save a surface to a seekable SDL data source (memory or file.) - # If 'freedst' is non-zero, the source will be closed after being written. - # Returns 0 if successful or -1 if there was an error. -proc SDL_SaveBMP_RW*(surface: PSDL_Surface, dst: PSDL_RWops, freedst: int): int{. - cdecl, importc, dynlib: SDLLibName.} - # Convenience macro -- save a surface to a file -proc SDL_SaveBMP*(surface: PSDL_Surface, filename: cstring): int - # Sets the color key (transparent pixel) in a blittable surface. - # If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL), - # 'key' will be the transparent pixel in the source image of a blit. - # SDL_RLEACCEL requests RLE acceleration for the surface if present, - # and removes RLE acceleration if absent. - # If 'flag' is 0, this function clears any current color key. - # This function returns 0, or -1 if there was an error. -proc SDL_SetColorKey*(surface: PSDL_Surface, flag, key: UInt32): int{.cdecl, - importc, dynlib: SDLLibName.} - # This function sets the alpha value for the entire surface, as opposed to - # using the alpha component of each pixel. This value measures the range - # of transparency of the surface, 0 being completely transparent to 255 - # being completely opaque. An 'alpha' value of 255 causes blits to be - # opaque, the source pixels copied to the destination (the default). Note - # that per-surface alpha can be combined with colorkey transparency. - # - # If 'flag' is 0, alpha blending is disabled for the surface. - # If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface. - # OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the - # surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed. -proc SDL_SetAlpha*(surface: PSDL_Surface, flag: UInt32, alpha: UInt8): int{. - cdecl, importc, dynlib: SDLLibName.} - # Sets the clipping rectangle for the destination surface in a blit. - # - # If the clip rectangle is NULL, clipping will be disabled. - # If the clip rectangle doesn't intersect the surface, the function will - # return SDL_FALSE and blits will be completely clipped. Otherwise the - # function returns SDL_TRUE and blits to the surface will be clipped to - # the intersection of the surface area and the clipping rectangle. - # - # Note that blits are automatically clipped to the edges of the source - # and destination surfaces. -proc SDL_SetClipRect*(surface: PSDL_Surface, rect: PSDL_Rect){.cdecl, - importc, dynlib: SDLLibName.} - # Gets the clipping rectangle for the destination surface in a blit. - # 'rect' must be a pointer to a valid rectangle which will be filled - # with the correct values. -proc SDL_GetClipRect*(surface: PSDL_Surface, rect: PSDL_Rect){.cdecl, - importc, dynlib: SDLLibName.} - # Creates a new surface of the specified format, and then copies and maps - # the given surface to it so the blit of the converted surface will be as - # fast as possible. If this function fails, it returns NULL. - # - # The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those - # semantics. You can also pass SDL_RLEACCEL in the flags parameter and - # SDL will try to RLE accelerate colorkey and alpha blits in the resulting - # surface. - # - # This function is used internally by SDL_DisplayFormat(). -proc SDL_ConvertSurface*(src: PSDL_Surface, fmt: PSDL_PixelFormat, flags: UInt32): PSDL_Surface{. - cdecl, importc, dynlib: SDLLibName.} - # - # This performs a fast blit from the source surface to the destination - # surface. It assumes that the source and destination rectangles are - # the same size. If either 'srcrect' or 'dstrect' are NULL, the entire - # surface (src or dst) is copied. The final blit rectangles are saved - # in 'srcrect' and 'dstrect' after all clipping is performed. - # If the blit is successful, it returns 0, otherwise it returns -1. - # - # The blit function should not be called on a locked surface. - # - # The blit semantics for surfaces with and without alpha and colorkey - # are defined as follows: - # - # RGBA->RGB: - # SDL_SRCALPHA set: - # alpha-blend (using alpha-channel). - # SDL_SRCCOLORKEY ignored. - # SDL_SRCALPHA not set: - # copy RGB. - # if SDL_SRCCOLORKEY set, only copy the pixels matching the - # RGB values of the source colour key, ignoring alpha in the - # comparison. - # - # RGB->RGBA: - # SDL_SRCALPHA set: - # alpha-blend (using the source per-surface alpha value); - # set destination alpha to opaque. - # SDL_SRCALPHA not set: - # copy RGB, set destination alpha to opaque. - # both: - # if SDL_SRCCOLORKEY set, only copy the pixels matching the - # source colour key. - # - # RGBA->RGBA: - # SDL_SRCALPHA set: - # alpha-blend (using the source alpha channel) the RGB values; - # leave destination alpha untouched. [Note: is this correct?] - # SDL_SRCCOLORKEY ignored. - # SDL_SRCALPHA not set: - # copy all of RGBA to the destination. - # if SDL_SRCCOLORKEY set, only copy the pixels matching the - # RGB values of the source colour key, ignoring alpha in the - # comparison. - # - # RGB->RGB: - # SDL_SRCALPHA set: - # alpha-blend (using the source per-surface alpha value). - # SDL_SRCALPHA not set: - # copy RGB. - # both: - # if SDL_SRCCOLORKEY set, only copy the pixels matching the - # source colour key. - # - # If either of the surfaces were in video memory, and the blit returns -2, - # the video memory was lost, so it should be reloaded with artwork and - # re-blitted: - # while ( SDL_BlitSurface(image, imgrect, screen, dstrect) = -2 ) do - # begin - # while ( SDL_LockSurface(image) < 0 ) do - # Sleep(10); - # -- Write image pixels to image->pixels -- - # SDL_UnlockSurface(image); - # end; - # - # This happens under DirectX 5.0 when the system switches away from your - # fullscreen application. The lock will also fail until you have access - # to the video memory again. - # You should call SDL_BlitSurface() unless you know exactly how SDL - # blitting works internally and how to use the other blit functions. -proc SDL_BlitSurface*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface, - dstrect: PSDL_Rect): int - # This is the public blit function, SDL_BlitSurface(), and it performs - # rectangle validation and clipping before passing it to SDL_LowerBlit() -proc SDL_UpperBlit*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface, - dstrect: PSDL_Rect): int{.cdecl, importc, dynlib: SDLLibName.} - # This is a semi-private blit function and it performs low-level surface - # blitting only. -proc SDL_LowerBlit*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface, - dstrect: PSDL_Rect): int{.cdecl, importc, dynlib: SDLLibName.} - # This function performs a fast fill of the given rectangle with 'color' - # The given rectangle is clipped to the destination surface clip area - # and the final fill rectangle is saved in the passed in pointer. - # If 'dstrect' is NULL, the whole surface will be filled with 'color' - # The color should be a pixel of the format used by the surface, and - # can be generated by the SDL_MapRGB() function. - # This function returns 0 on success, or -1 on error. -proc SDL_FillRect*(dst: PSDL_Surface, dstrect: PSDL_Rect, color: UInt32): int{. - cdecl, importc, dynlib: SDLLibName.} - # This function takes a surface and copies it to a new surface of the - # pixel format and colors of the video framebuffer, suitable for fast - # blitting onto the display surface. It calls SDL_ConvertSurface() - # - # If you want to take advantage of hardware colorkey or alpha blit - # acceleration, you should set the colorkey and alpha value before - # calling this function. - # - # If the conversion fails or runs out of memory, it returns NULL -proc SDL_DisplayFormat*(surface: PSDL_Surface): PSDL_Surface{.cdecl, - importc, dynlib: SDLLibName.} - # This function takes a surface and copies it to a new surface of the - # pixel format and colors of the video framebuffer (if possible), - # suitable for fast alpha blitting onto the display surface. - # The new surface will always have an alpha channel. - # - # If you want to take advantage of hardware colorkey or alpha blit - # acceleration, you should set the colorkey and alpha value before - # calling this function. - # - # If the conversion fails or runs out of memory, it returns NULL -proc SDL_DisplayFormatAlpha*(surface: PSDL_Surface): PSDL_Surface{.cdecl, - importc, dynlib: SDLLibName.} - #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ - #* YUV video surface overlay functions */ - #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ - # This function creates a video output overlay - # Calling the returned surface an overlay is something of a misnomer because - # the contents of the display surface underneath the area where the overlay - # is shown is undefined - it may be overwritten with the converted YUV data. -proc SDL_CreateYUVOverlay*(width: int, height: int, format: UInt32, - display: PSDL_Surface): PSDL_Overlay{.cdecl, - importc, dynlib: SDLLibName.} - # Lock an overlay for direct access, and unlock it when you are done -proc SDL_LockYUVOverlay*(Overlay: PSDL_Overlay): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_UnlockYUVOverlay*(Overlay: PSDL_Overlay){.cdecl, importc, dynlib: SDLLibName.} - # Blit a video overlay to the display surface. - # The contents of the video surface underneath the blit destination are - # not defined. - # The width and height of the destination rectangle may be different from - # that of the overlay, but currently only 2x scaling is supported. -proc SDL_DisplayYUVOverlay*(Overlay: PSDL_Overlay, dstrect: PSDL_Rect): int{. - cdecl, importc, dynlib: SDLLibName.} - # Free a video overlay -proc SDL_FreeYUVOverlay*(Overlay: PSDL_Overlay){.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # OpenGL Routines - #------------------------------------------------------------------------------ - # Dynamically load a GL driver, if SDL is built with dynamic GL. - # - # SDL links normally with the OpenGL library on your system by default, - # but you can compile it to dynamically load the GL driver at runtime. - # If you do this, you need to retrieve all of the GL functions used in - # your program from the dynamic library using SDL_GL_GetProcAddress(). - # - # This is disabled in default builds of SDL. -proc SDL_GL_LoadLibrary*(filename: cstring): int{.cdecl, importc, dynlib: SDLLibName.} - # Get the address of a GL function (for extension functions) -proc SDL_GL_GetProcAddress*(procname: cstring): Pointer{.cdecl, - importc, dynlib: SDLLibName.} - # Set an attribute of the OpenGL subsystem before intialization. -proc SDL_GL_SetAttribute*(attr: TSDL_GLAttr, value: int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Get an attribute of the OpenGL subsystem from the windowing - # interface, such as glX. This is of course different from getting - # the values from SDL's internal OpenGL subsystem, which only - # stores the values you request before initialization. - # - # Developers should track the values they pass into SDL_GL_SetAttribute - # themselves if they want to retrieve these values. -proc SDL_GL_GetAttribute*(attr: TSDL_GLAttr, value: var int): int{.cdecl, - importc, dynlib: SDLLibName.} - # Swap the OpenGL buffers, if double-buffering is supported. -proc SDL_GL_SwapBuffers*(){.cdecl, importc, dynlib: SDLLibName.} - # Internal functions that should not be called unless you have read - # and understood the source code for these functions. -proc SDL_GL_UpdateRects*(numrects: int, rects: PSDL_Rect){.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_GL_Lock*(){.cdecl, importc, dynlib: SDLLibName.} -proc SDL_GL_Unlock*(){.cdecl, importc, dynlib: SDLLibName.} - #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - #* These functions allow interaction with the window manager, if any. * - #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Sets/Gets the title and icon text of the display window -proc SDL_WM_GetCaption*(title: var cstring, icon: var cstring){.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_WM_SetCaption*(title: cstring, icon: cstring){.cdecl, - importc, dynlib: SDLLibName.} - # Sets the icon for the display window. - # This function must be called before the first call to SDL_SetVideoMode(). - # It takes an icon surface, and a mask in MSB format. - # If 'mask' is NULL, the entire icon surface will be used as the icon. -proc SDL_WM_SetIcon*(icon: PSDL_Surface, mask: UInt8){.cdecl, importc, dynlib: SDLLibName.} - # This function iconifies the window, and returns 1 if it succeeded. - # If the function succeeds, it generates an SDL_APPACTIVE loss event. - # This function is a noop and returns 0 in non-windowed environments. -proc SDL_WM_IconifyWindow*(): int{.cdecl, importc, dynlib: SDLLibName.} - # Toggle fullscreen mode without changing the contents of the screen. - # If the display surface does not require locking before accessing - # the pixel information, then the memory pointers will not change. - # - # If this function was able to toggle fullscreen mode (change from - # running in a window to fullscreen, or vice-versa), it will return 1. - # If it is not implemented, or fails, it returns 0. - # - # The next call to SDL_SetVideoMode() will set the mode fullscreen - # attribute based on the flags parameter - if SDL_FULLSCREEN is not - # set, then the display will be windowed by default where supported. - # - # This is currently only implemented in the X11 video driver. -proc SDL_WM_ToggleFullScreen*(surface: PSDL_Surface): int{.cdecl, - importc, dynlib: SDLLibName.} - # Grabbing means that the mouse is confined to the application window, - # and nearly all keyboard input is passed directly to the application, - # and not interpreted by a window manager, if any. -proc SDL_WM_GrabInput*(mode: TSDL_GrabMode): TSDL_GrabMode{.cdecl, - importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # mouse-routines - #------------------------------------------------------------------------------ - # Retrieve the current state of the mouse. - # The current button state is returned as a button bitmask, which can - # be tested using the SDL_BUTTON(X) macros, and x and y are set to the - # current mouse cursor position. You can pass NULL for either x or y. -proc SDL_GetMouseState*(x: var int, y: var int): UInt8{.cdecl, - importc, dynlib: SDLLibName.} - # Retrieve the current state of the mouse. - # The current button state is returned as a button bitmask, which can - # be tested using the SDL_BUTTON(X) macros, and x and y are set to the - # mouse deltas since the last call to SDL_GetRelativeMouseState(). -proc SDL_GetRelativeMouseState*(x: var int, y: var int): UInt8{.cdecl, - importc, dynlib: SDLLibName.} - # Set the position of the mouse cursor (generates a mouse motion event) -proc SDL_WarpMouse*(x, y: UInt16){.cdecl, importc, dynlib: SDLLibName.} - # Create a cursor using the specified data and mask (in MSB format). - # The cursor width must be a multiple of 8 bits. - # - # The cursor is created in black and white according to the following: - # data mask resulting pixel on screen - # 0 1 White - # 1 1 Black - # 0 0 Transparent - # 1 0 Inverted color if possible, black if not. - # - # Cursors created with this function must be freed with SDL_FreeCursor(). -proc SDL_CreateCursor*(data, mask: PUInt8, w, h, hot_x, hot_y: int): PSDL_Cursor{. - cdecl, importc, dynlib: SDLLibName.} - # Set the currently active cursor to the specified one. - # If the cursor is currently visible, the change will be immediately - # represented on the display. -proc SDL_SetCursor*(cursor: PSDL_Cursor){.cdecl, importc, dynlib: SDLLibName.} - # Returns the currently active cursor. -proc SDL_GetCursor*(): PSDL_Cursor{.cdecl, importc, dynlib: SDLLibName.} - # Deallocates a cursor created with SDL_CreateCursor(). -proc SDL_FreeCursor*(cursor: PSDL_Cursor){.cdecl, importc, dynlib: SDLLibName.} - # Toggle whether or not the cursor is shown on the screen. - # The cursor start off displayed, but can be turned off. - # SDL_ShowCursor() returns 1 if the cursor was being displayed - # before the call, or 0 if it was not. You can query the current - # state by passing a 'toggle' value of -1. -proc SDL_ShowCursor*(toggle: int): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_BUTTON*(Button: int): int - #------------------------------------------------------------------------------ - # Keyboard-routines - #------------------------------------------------------------------------------ - # Enable/Disable UNICODE translation of keyboard input. - # This translation has some overhead, so translation defaults off. - # If 'enable' is 1, translation is enabled. - # If 'enable' is 0, translation is disabled. - # If 'enable' is -1, the translation state is not changed. - # It returns the previous state of keyboard translation. -proc SDL_EnableUNICODE*(enable: int): int{.cdecl, importc, dynlib: SDLLibName.} - # If 'delay' is set to 0, keyboard repeat is disabled. -proc SDL_EnableKeyRepeat*(delay: int, interval: int): int{.cdecl, - importc, dynlib: SDLLibName.} -proc SDL_GetKeyRepeat*(delay: PInteger, interval: PInteger){.cdecl, - importc, dynlib: SDLLibName.} - # Get a snapshot of the current state of the keyboard. - # Returns an array of keystates, indexed by the SDLK_* syms. - # Used: - # - # UInt8 *keystate = SDL_GetKeyState(NULL); - # if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed -proc SDL_GetKeyState*(numkeys: PInt): PUInt8{.cdecl, importc, dynlib: SDLLibName.} - # Get the current key modifier state -proc SDL_GetModState*(): TSDLMod{.cdecl, importc, dynlib: SDLLibName.} - # Set the current key modifier state - # This does not change the keyboard state, only the key modifier flags. -proc SDL_SetModState*(modstate: TSDLMod){.cdecl, importc, dynlib: SDLLibName.} - # Get the name of an SDL virtual keysym -proc SDL_GetKeyName*(key: TSDLKey): cstring{.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # Active Routines - #------------------------------------------------------------------------------ - # This function returns the current state of the application, which is a - # bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and - # SDL_APPACTIVE. If SDL_APPACTIVE is set, then the user is able to - # see your application, otherwise it has been iconified or disabled. -proc SDL_GetAppState*(): UInt8{.cdecl, importc, dynlib: SDLLibName.} - # Mutex functions - # Create a mutex, initialized unlocked -proc SDL_CreateMutex*(): PSDL_Mutex{.cdecl, importc, dynlib: SDLLibName.} - # Lock the mutex (Returns 0, or -1 on error) -proc SDL_mutexP*(mutex: PSDL_mutex): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_LockMutex*(mutex: PSDL_mutex): int - # Unlock the mutex (Returns 0, or -1 on error) -proc SDL_mutexV*(mutex: PSDL_mutex): int{.cdecl, importc, dynlib: SDLLibName.} -proc SDL_UnlockMutex*(mutex: PSDL_mutex): int - # Destroy a mutex -proc SDL_DestroyMutex*(mutex: PSDL_mutex){.cdecl, importc, dynlib: SDLLibName.} - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Semaphore functions - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Create a semaphore, initialized with value, returns NULL on failure. -proc SDL_CreateSemaphore*(initial_value: UInt32): PSDL_Sem{.cdecl, - importc, dynlib: SDLLibName.} - # Destroy a semaphore -proc SDL_DestroySemaphore*(sem: PSDL_sem){.cdecl, importc, dynlib: SDLLibName.} - # This function suspends the calling thread until the semaphore pointed - # to by sem has a positive count. It then atomically decreases the semaphore - # count. -proc SDL_SemWait*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.} - # Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds, - # SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error. -proc SDL_SemTryWait*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.} - # Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if - # the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in - # the allotted time, and -1 on error. - # On some platforms this function is implemented by looping with a delay - # of 1 ms, and so should be avoided if possible. -proc SDL_SemWaitTimeout*(sem: PSDL_sem, ms: UInt32): int{.cdecl, - importc, dynlib: SDLLibName.} - # Atomically increases the semaphore's count (not blocking), returns 0, - # or -1 on error. -proc SDL_SemPost*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.} - # Returns the current count of the semaphore -proc SDL_SemValue*(sem: PSDL_sem): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Condition variable functions - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Create a condition variable -proc SDL_CreateCond*(): PSDL_Cond{.cdecl, importc, dynlib: SDLLibName.} - # Destroy a condition variable -proc SDL_DestroyCond*(cond: PSDL_Cond){.cdecl, importc, dynlib: SDLLibName.} - # Restart one of the threads that are waiting on the condition variable, - # returns 0 or -1 on error. -proc SDL_CondSignal*(cond: PSDL_cond): int{.cdecl, importc, dynlib: SDLLibName.} - # Restart all threads that are waiting on the condition variable, - # returns 0 or -1 on error. -proc SDL_CondBroadcast*(cond: PSDL_cond): int{.cdecl, importc, dynlib: SDLLibName.} - # Wait on the condition variable, unlocking the provided mutex. - # The mutex must be locked before entering this function! - # Returns 0 when it is signaled, or -1 on error. -proc SDL_CondWait*(cond: PSDL_cond, mut: PSDL_mutex): int{.cdecl, - importc, dynlib: SDLLibName.} - # Waits for at most 'ms' milliseconds, and returns 0 if the condition - # variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not - # signaled in the allotted time, and -1 on error. - # On some platforms this function is implemented by looping with a delay - # of 1 ms, and so should be avoided if possible. -proc SDL_CondWaitTimeout*(cond: PSDL_cond, mut: PSDL_mutex, ms: UInt32): int{. - cdecl, importc, dynlib: SDLLibName.} - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Condition variable functions - # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - # Create a thread -proc SDL_CreateThread*(fn: PInt, data: Pointer): PSDL_Thread{.cdecl, - importc, dynlib: SDLLibName.} - # Get the 32-bit thread identifier for the current thread -proc SDL_ThreadID*(): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # Get the 32-bit thread identifier for the specified thread, - # equivalent to SDL_ThreadID() if the specified thread is NULL. -proc SDL_GetThreadID*(thread: PSDL_Thread): UInt32{.cdecl, importc, dynlib: SDLLibName.} - # Wait for a thread to finish. - # The return code for the thread function is placed in the area - # pointed to by 'status', if 'status' is not NULL. -proc SDL_WaitThread*(thread: PSDL_Thread, status: var int){.cdecl, - importc, dynlib: SDLLibName.} - # Forcefully kill a thread without worrying about its state -proc SDL_KillThread*(thread: PSDL_Thread){.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - # Get Environment Routines - #------------------------------------------------------------------------------ - #* - # * This function gives you custom hooks into the window manager information. - # * It fills the structure pointed to by 'info' with custom information and - # * returns 1 if the function is implemented. If it's not implemented, or - # * the version member of the 'info' structure is invalid, it returns 0. - # * -proc SDL_GetWMInfo*(info: PSDL_SysWMinfo): int{.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ - #SDL_loadso.h - #* This function dynamically loads a shared object and returns a pointer - # * to the object handle (or NULL if there was an error). - # * The 'sofile' parameter is a system dependent name of the object file. - # * -proc SDL_LoadObject*(sofile: cstring): Pointer{.cdecl, importc, dynlib: SDLLibName.} - #* Given an object handle, this function looks up the address of the - # * named function in the shared object and returns it. This address - # * is no longer valid after calling SDL_UnloadObject(). - # * -proc SDL_LoadFunction*(handle: Pointer, name: cstring): Pointer{.cdecl, - importc, dynlib: SDLLibName.} - #* Unload a shared object from memory * -proc SDL_UnloadObject*(handle: Pointer){.cdecl, importc, dynlib: SDLLibName.} - #------------------------------------------------------------------------------ -proc SDL_Swap32*(D: Uint32): Uint32 - # Bitwise Checking functions -proc IsBitOn*(value: int, bit: int8): bool -proc TurnBitOn*(value: int, bit: int8): int -proc TurnBitOff*(value: int, bit: int8): int -# implementation - -proc SDL_TABLESIZE(table: cstring): int = - Result = SizeOf(table) div SizeOf(table[0]) - -proc SDL_OutOfMemory() = - when not(defined(WINDOWS)): SDL_Error(SDL_ENOMEM) - -proc SDL_RWSeek(context: PSDL_RWops, offset: int, whence: int): int = - Result = context.seek(context, offset, whence) - -proc SDL_RWTell(context: PSDL_RWops): int = - Result = context.seek(context, 0, 1) - -proc SDL_RWRead(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int = - Result = context.read(context, theptr, size, n) - -proc SDL_RWWrite(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int = - Result = context.write(context, theptr, size, n) - -proc SDL_RWClose(context: PSDL_RWops): int = - Result = context.closeFile(context) - -proc SDL_LoadWAV(filename: cstring, spec: PSDL_AudioSpec, audio_buf: PUInt8, - audiolen: PUInt32): PSDL_AudioSpec = - Result = SDL_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1, spec, audio_buf, - audiolen) - -proc SDL_CDInDrive(status: TSDL_CDStatus): bool = - Result = ord(status) > ord(CD_ERROR) - -proc FRAMES_TO_MSF(frames: int, M: var int, S: var int, F: var int) = - var value: int - value = frames - F = value mod CD_FPS - value = value div CD_FPS - S = value mod 60 - value = value div 60 - M = value - -proc MSF_TO_FRAMES(M: int, S: int, F: int): int = - Result = M * 60 * CD_FPS + S * CD_FPS + F - -proc SDL_VERSION(X: var TSDL_Version) = - X.major = SDL_MAJOR_VERSION - X.minor = SDL_MINOR_VERSION - X.patch = SDL_PATCHLEVEL - -proc SDL_VERSIONNUM(X, Y, Z: int): int = - Result = X * 1000 + Y * 100 + Z - -proc SDL_COMPILEDVERSION(): int = - Result = SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) - -proc SDL_VERSION_ATLEAST(X, Y, Z: int): bool = - Result = (SDL_COMPILEDVERSION() >= SDL_VERSIONNUM(X, Y, Z)) - -proc SDL_LoadBMP(filename: cstring): PSDL_Surface = - Result = SDL_LoadBMP_RW(SDL_RWFromFile(filename, "rb"), 1) - -proc SDL_SaveBMP(surface: PSDL_Surface, filename: cstring): int = - Result = SDL_SaveBMP_RW(surface, SDL_RWFromFile(filename, "wb"), 1) - -proc SDL_BlitSurface(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface, - dstrect: PSDL_Rect): int = - Result = SDL_UpperBlit(src, srcrect, dst, dstrect) - -proc SDL_AllocSurface(flags: UInt32, width, height, depth: int, - RMask, GMask, BMask, AMask: UInt32): PSDL_Surface = - Result = SDL_CreateRGBSurface(flags, width, height, depth, RMask, GMask, - BMask, AMask) - -proc SDL_MustLock(Surface: PSDL_Surface): bool = - Result = ((surface^ .offset != 0) or - ((surface^ .flags and (SDL_HWSURFACE or SDL_ASYNCBLIT or SDL_RLEACCEL)) != - 0)) - -proc SDL_LockMutex(mutex: PSDL_mutex): int = - Result = SDL_mutexP(mutex) - -proc SDL_UnlockMutex(mutex: PSDL_mutex): int = - Result = SDL_mutexV(mutex) - -proc SDL_BUTTON(Button: int): int = - Result = SDL_PRESSED shl (Button - 1) - -proc SDL_Swap32(D: Uint32): Uint32 = - Result = ((D shl 24) or ((D shl 8) and 0x00FF0000) or - ((D shr 8) and 0x0000FF00) or (D shr 24)) - -proc IsBitOn(value: int, bit: int8): bool = - result = ((value and (1 shl ze(bit))) != 0) - -proc TurnBitOn(value: int, bit: int8): int = - result = (value or (1 shl ze(bit))) - -proc TurnBitOff(value: int, bit: int8): int = - result = (value and not (1 shl ze(bit))) |