--- /dev/null
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
\ No newline at end of file
--- /dev/null
+Pascal-SDL-2-Headers
+====================
+
+This are the Pascal SDL 2 Headers.
\ No newline at end of file
--- /dev/null
+unit sdl2_image;
+
+{*
+ SDL_image: An example image loading library for use with SDL
+ Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+ Pascal-Header-Translation 2013 by Tim Blume
+
+ Both, header translation and sdl_image, under following license:
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ ChangeLog (Header-Translation):
+ -------------------------------
+
+ v.1.72-stable; 29.09.2013: fixed bug with procedure without parameters
+ (they must have brackets)
+ v.1.70-stable; 11.09.2013: MacOS compatibility (with Delphi)
+ v.1.33-Alpha; 31.07.2013: Initial Commit
+
+*}
+
+{$DEFINE SDL_IMAGE}
+
+{$I jedi.inc}
+
+interface
+
+uses
+ SDL2;
+
+const
+ {$IFDEF WINDOWS}
+ IMG_LibName = 'SDL2_image.dll';
+ {$ENDIF}
+
+ {$IFDEF UNIX}
+ {$IFDEF DARWIN}
+ IMG_LibName = 'libSDL_image.dylib';
+ {$ELSE}
+ {$IFDEF FPC}
+ IMG_LibName = 'libSDL_image.so';
+ {$ELSE}
+ IMG_LibName = 'libSDL_image.so.0';
+ {$ENDIF}
+ {$ENDIF}
+ {$ENDIF}
+
+ {$IFDEF MACOS}
+ IMG_LibName = 'SDL2_image';
+ {$IFDEF FPC}
+ {$linklib libSDL2_image}
+ {$ENDIF}
+ {$ENDIF}
+
+ {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+ SDL_IMAGE_MAJOR_VERSION = 2;
+ SDL_IMAGE_MINOR_VERSION = 0;
+ SDL_IMAGE_PATCHLEVEL = 0;
+
+ {* This macro can be used to fill a version structure with the compile-time
+ * version of the SDL_image library.
+ *}
+
+procedure SDL_IMAGE_VERSION(var X: TSDL_Version);
+
+ {* This function gets the version of the dynamically linked SDL_image library.
+ it should NOT be used to fill a version structure, instead you should
+ use the SDL_IMAGE_VERSION() macro.
+ *}
+function IMG_Linked_Version: TSDL_Version cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Linked_Version' {$ENDIF} {$ENDIF};
+
+const
+ IMG_INIT_JPG = $00000001;
+ IMG_INIT_PNG = $00000002;
+ IMG_INIT_TIF = $00000004;
+ IMG_INIT_WEBP = $00000008;
+
+type
+ TIMG_InitFlags = DWord;
+
+ {* Loads dynamic libraries and prepares them for use. Flags should be
+ one or more flags from IMG_InitFlags OR'd together.
+ It returns the flags successfully initialized, or 0 on failure.
+ *}
+function IMG_Init(flags: SInt32): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Init' {$ENDIF} {$ENDIF};
+
+ {* Unloads libraries loaded with IMG_Init *}
+procedure IMG_Quit() cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Quit' {$ENDIF} {$ENDIF};
+
+ {* Load an image from an SDL data source.
+ The 'type' may be one of: "BMP", "GIF", "PNG", etc.
+
+ If the image format supports a transparent pixel, SDL will set the
+ colorkey for the surface. You can enable RLE acceleration on the
+ surface afterwards by calling:
+ SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+ *}
+function IMG_LoadTyped_RW(src: PSDL_RWops; freesrc: SInt32; _type: PAnsiChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTyped_RW' {$ENDIF} {$ENDIF};
+ {* Convenience functions *}
+function IMG_Load(_file: PAnsiChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load' {$ENDIF} {$ENDIF};
+function IMG_Load_RW(src: PSDL_RWops; freesrc: SInt32): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_Load_RW' {$ENDIF} {$ENDIF};
+
+ {* Load an image directly into a render texture. *}
+function IMG_LoadTexture(renderer: PSDL_Renderer; _file: PAnsiChar): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture' {$ENDIF} {$ENDIF};
+function IMG_LoadTexture_RW(renderer: PSDL_Renderer; src: PSDL_RWops; freesrc: SInt32): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTexture_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTextureTyped_RW(renderer: PSDL_Renderer; src: PSDL_RWops; freesrc: SInt32; _type: PAnsiChar): PSDL_Texture cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTextureTyped_RW' {$ENDIF} {$ENDIF};
+
+ {* Functions to detect a file type, given a seekable source *}
+function IMG_isICO(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isICO' {$ENDIF} {$ENDIF};
+function IMG_isCUR(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isCUR' {$ENDIF} {$ENDIF};
+function IMG_isBMP(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isBMP' {$ENDIF} {$ENDIF};
+function IMG_isGIF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isGIF' {$ENDIF} {$ENDIF};
+function IMG_isJPG(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isJPG' {$ENDIF} {$ENDIF};
+function IMG_isLBM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isLBM' {$ENDIF} {$ENDIF};
+function IMG_isPCX(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPCX' {$ENDIF} {$ENDIF};
+function IMG_isPNG(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNG' {$ENDIF} {$ENDIF};
+function IMG_isPNM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isPNM' {$ENDIF} {$ENDIF};
+function IMG_isTIF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isTIF' {$ENDIF} {$ENDIF};
+function IMG_isXCF(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '-IMG_isXCF' {$ENDIF} {$ENDIF};
+function IMG_isXPM(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXPM' {$ENDIF} {$ENDIF};
+function IMG_isXV(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isXV' {$ENDIF} {$ENDIF};
+function IMG_isWEBP(src: PSDL_RWops): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_isWEBP' {$ENDIF} {$ENDIF};
+
+ {* Individual loading functions *}
+function IMG_LoadICO_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadICO_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadCUR_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadCUR_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadBMP_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadBMP_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadGIF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadGIF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadJPG_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadJPG_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadLBM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadLBM_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPCX_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPCX_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPNG_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNG_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadPNM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadPNM_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTGA_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTGA_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadTIF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadTIF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXCF_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXCF_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXPM_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXMP_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadXV_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadXV_RW' {$ENDIF} {$ENDIF};
+function IMG_LoadWEBP_RW(src: PSDL_RWops): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_LoadWEBP_RW' {$ENDIF} {$ENDIF};
+
+function IMG_ReadXPMFromArray(xpm: PPChar): PSDL_Surface cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_ReadXPMFromArray' {$ENDIF} {$ENDIF};
+
+ {* Individual saving functions *}
+function IMG_SavePNG(surface: PSDL_Surface; const _file: PAnsiChar): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG' {$ENDIF} {$ENDIF};
+function IMG_SavePNG_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: SInt32): SInt32 cdecl; external IMG_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_IMG_SavePNG_RW' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function IMG_SetError(fmt: PAnsiChar): SInt32;
+function IMG_GetError: PAnsiChar;
+
+implementation
+
+procedure SDL_IMAGE_VERSION(var X: TSDL_Version);
+begin
+ X.major := SDL_IMAGE_MAJOR_VERSION;
+ X.minor := SDL_IMAGE_MINOR_VERSION;
+ X.patch := SDL_IMAGE_PATCHLEVEL;
+end;
+
+function IMG_SetError(fmt: PAnsiChar): SInt32;
+begin
+ Result := SDL_SetError(fmt);
+end;
+
+function IMG_GetError: PAnsiChar;
+begin
+ Result := SDL_GetError;
+end;
+
+end.
--- /dev/null
+unit SDL2_mixer;
+
+{*
+ SDL_mixer: An audio mixer library based on the SDL library
+ Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+*}
+
+{* ChangeLog: (Header Translation)
+ ----------
+
+ v.1.74-stable; 16.11.2013: fixed bug, found by Cybermonkey. thx
+ v.1.72-stable; 29.09.2013: fixed bug with procedures without parameters
+ (they must have brackets)
+ v.1.70-stable; 16.09.2013: Initial Commit
+
+*}
+
+interface
+
+{$I jedi.inc}
+
+uses
+ SDL2;
+
+const
+ {$IFDEF WINDOWS}
+ MIX_LibName = 'SDL2_mixer.dll';
+ {$ENDIF}
+
+ {$IFDEF UNIX}
+ {$IFDEF DARWIN}
+ MIX_LibName = 'libSDL2_mixer.dylib';
+ {$ELSE}
+ {$IFDEF FPC}
+ MIX_LibName = 'libSDL2_mixer.so';
+ {$ELSE}
+ MIX_LibName = 'libSDL2_mixer.so.0';
+ {$ENDIF}
+ {$ENDIF}
+ {$ENDIF}
+
+ {$IFDEF MACOS}
+ MIX_LibName = 'SDL2_mixer';
+ {$IFDEF FPC}
+ {$linklib libSDL2_mixer}
+ {$ENDIF}
+ {$ENDIF}
+
+ {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+const
+ SDL_MIXER_MAJOR_VERSION = 2;
+ SDL_MIXER_MINOR_VERSION = 0;
+ SDL_MIXER_PATCHLEVEL = 0;
+
+ {* This macro can be used to fill a version structure with the compile-time
+ * version of the SDL_mixer library.
+ *}
+procedure SDL_MIXER_VERSION(X: PSDL_Version);
+
+ {* Backwards compatibility *}
+const
+ MIX_MAJOR_VERSION = SDL_MIXER_MAJOR_VERSION;
+ MIX_MINOR_VERSION = SDL_MIXER_MINOR_VERSION;
+ MIX_PATCHLEVEL = SDL_MIXER_PATCHLEVEL;
+
+procedure MIX_VERSION(X: PSDL_Version);
+
+ {* This function gets the version of the dynamically linked SDL_mixer library.
+ it should NOT be used to fill a version structure, instead you should
+ use the SDL_MIXER_VERSION() macro.
+ *}
+function Mix_Linked_Version: PSDL_Version cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Linked_Version' {$ENDIF} {$ENDIF};
+
+const
+ MIX_INIT_FLAC = $00000001;
+ MIX_INIT_MOD = $00000002;
+ MIX_INIT_MODPLUG = $00000004;
+ MIX_INIT_MP3 = $00000008;
+ MIX_INIT_OGG = $00000010;
+ MIX_INIT_FLUIDSYNTH = $00000020;
+type
+ TMIX_InitFlags = Byte;
+
+ {* Loads dynamic libraries and prepares them for use. Flags should be
+ one or more flags from MIX_InitFlags OR'd together.
+ It returns the flags successfully initialized, or 0 on failure.
+ *}
+function Mix_Init(flags: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Init' {$ENDIF} {$ENDIF};
+
+ {* Unloads libraries loaded with Mix_Init *}
+procedure Mix_Quit() cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Quit' {$ENDIF} {$ENDIF};
+
+
+ {* The default mixer has 8 simultaneous mixing channels *}
+{$IFNDEF MIX_CHANNELS}
+const
+ MIX_CHANNELS = 8;
+{$ENDIF}
+
+ {* Good default values for a PC soundcard *}
+const
+ MIX_DEFAULT_FREQUENCY = 22050;
+ {$IFDEF ENDIAN_LITTLE}
+ MIX_DEFAULT_FORMAT = AUDIO_S16LSB;
+ {$ELSE}
+ MIX_DEFAULT_FORMAT = AUDIO_S16MSB;
+ {$ENDIF}
+ MIX_DEFAULT_CHANNELS = 2;
+ MIX_MAX_VOLUME = 128; {* Volume of a chunk *}
+
+ {* The internal format for an audio chunk *}
+type
+ PMix_Chunk = ^TMix_Chunk;
+ TMix_Chunk = record
+ allocated: Integer;
+ abuf: PUInt8;
+ alen: UInt32;
+ volume: UInt8; {* Per-sample volume, 0-128 *}
+ end;
+
+ {* The different fading types supported *}
+type
+ TMix_Fading = (MIX_NO_FADING, MIX_FADING_OUT, MIX_FADING_IN);
+
+ TMix_MusicType = (MUS_NONE,
+ MUS_CMD,
+ MUS_WAV,
+ MUS_MOD,
+ MUS_MID,
+ MUS_OGG,
+ MUS_MP3,
+ MUS_MP3_MAD,
+ MUS_FLAC,
+ MUS_MODPLUG);
+
+ {* The internal format for a music chunk interpreted via mikmod *}
+ PMix_Music = ^TMix_Music;
+ TMix_Music = record end;
+
+ {* Open the mixer with a certain audio format *}
+function Mix_OpenAudio(frequency: Integer; format: UInt16; channels: Integer; chunksize: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_OpenAudio' {$ENDIF} {$ENDIF};
+
+ {* Dynamically change the number of channels managed by the mixer.
+ If decreasing the number of channels, the upper channels are
+ stopped.
+ This function returns the new number of allocated channels.
+ *}
+function Mix_AllocateChannels(numchans: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_AllocateChannels' {$ENDIF} {$ENDIF};
+
+ {* Find out what the actual audio device parameters are.
+ This function returns 1 if the audio has been opened, 0 otherwise.
+ *}
+function Mix_QuerySpec(frequency: PInt; format: PUInt16; channels: PInt): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuerySpec' {$ENDIF} {$ENDIF};
+
+ {* Load a wave file or a music (.mod .s3m .it .xm) file *}
+function Mix_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadWAV_RW' {$ENDIF} {$ENDIF};
+function Mix_LoadWAV(_file: PAnsiChar): PMix_Chunk;
+function Mix_LoadMUS(_file: PAnsiChar): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUS' {$ENDIF} {$ENDIF};
+
+ {* Load a music file from an SDL_RWop object (Ogg and MikMod specific currently)
+ Matt Campbell (matt@campbellhome.dhs.org) April 2000 *}
+function Mix_LoadMUS_RW(src: PSDL_RWops; freesrc: Integer): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUS_RW' {$ENDIF} {$ENDIF};
+
+ {* Load a music file from an SDL_RWop object assuming a specific format *}
+function Mix_LoadMUSType_RW(src: PSDL_RWops; _type: TMix_MusicType; freesrc: Integer): PMix_Music cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_LoadMUSType_RW' {$ENDIF} {$ENDIF};
+
+ {* Load a wave file of the mixer format from a memory buffer *}
+function Mix_QuickLoad_WAV(mem: PUInt8): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuickLoad_WAV' {$ENDIF} {$ENDIF};
+
+ {* Load raw audio data of the mixer format from a memory buffer *}
+function Mix_QuickLoad_RAW(mem: PUInt8; len: UInt32): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_QuickLoad_RAW' {$ENDIF} {$ENDIF};
+
+ {* Free an audio chunk previously loaded *}
+procedure Mix_FreeChunk(chunk: PMix_Chunk) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FreeChunk' {$ENDIF} {$ENDIF};
+procedure Mix_FreeMusic(music: PMix_Music) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FreeMusic' {$ENDIF} {$ENDIF};
+
+ {* Get a list of chunk/music decoders that this build of SDL_mixer provides.
+ This list can change between builds AND runs of the program, if external
+ libraries that add functionality become available.
+ You must successfully call Mix_OpenAudio() before calling these functions.
+ This API is only available in SDL_mixer 1.2.9 and later.
+
+ // usage...
+ int i;
+ const int total = Mix_GetNumChunkDecoders();
+ for (i = 0; i < total; i++)
+ printf("Supported chunk decoder: [%s]\n", Mix_GetChunkDecoder(i));
+
+ Appearing in this list doesn't promise your specific audio file will
+ decode...but it's handy to know if you have, say, a functioning Timidity
+ install.
+
+ These return values are static, read-only data; do not modify or free it.
+ The pointers remain valid until you call Mix_CloseAudio().
+ *}
+function Mix_GetNumChunkDecoders: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetNumChunkDecoders' {$ENDIF} {$ENDIF};
+function Mix_GetChunkDecoder(index: Integer): PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetChunkDecoder' {$ENDIF} {$ENDIF};
+function Mix_GetNumMusicDecoders: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetNumMusicDecoders' {$ENDIF} {$ENDIF};
+function Mix_GetMusicDecoder(index: Integer): PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicDecoder' {$ENDIF} {$ENDIF};
+
+ {* Find out the music format of a mixer music, or the currently playing
+ music, if 'music' is NULL.
+ *}
+function Mix_GetMusicType(music: TMix_Music): TMix_MusicType cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicType' {$ENDIF} {$ENDIF};
+
+ {* Set a function that is called after all mixing is performed.
+ This can be used to provide real-time visual display of the audio stream
+ or add a custom mixer filter for the stream data.
+ *}
+type
+ TMix_Func = procedure(udata: Pointer; stream: PUInt8; len: Integer);
+
+procedure Mix_SetPostMix(func: TMix_Func; arg: Pointer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPostMix' {$ENDIF} {$ENDIF};
+
+ {* Add your own music player or additional mixer function.
+ If 'mix_func' is NULL, the default music player is re-enabled.
+ *}
+procedure Mix_HookMusic(func: TMix_Func; arg: Pointer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HookMusic' {$ENDIF} {$ENDIF};
+
+ {* Add your own callback when the music has finished playing.
+ This callback is only called if the music finishes naturally.
+ *}
+type
+ PMix_Music_Finished = ^TMix_Music_Finished;
+ TMix_Music_Finished = procedure();
+procedure Mix_HookMusicFinished(music_finished: PMix_Music_Finished) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HookMusicFinished' {$ENDIF} {$ENDIF};
+
+ {* Get a pointer to the user data for the current music hook *}
+function Mix_GetMusicHookData: Pointer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetMusicHookData' {$ENDIF} {$ENDIF};
+
+ {*
+ * Add your own callback when a channel has finished playing. NULL
+ * to disable callback. The callback may be called from the mixer's audio
+ * callback or it could be called as a result of Mix_HaltChannel(), etc.
+ * do not call SDL_LockAudio() from this callback; you will either be
+ * inside the audio callback, or SDL_mixer will explicitly lock the audio
+ * before calling your callback.
+ *}
+type
+ TMix_Channel_Finished = procedure(channel: Integer);
+procedure Mix_ChannelFinished(channel_finished: TMix_Channel_Finished) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ChannelFinished' {$ENDIF} {$ENDIF};
+
+ {* Special Effects API by ryan c. gordon. (icculus@icculus.org) *}
+const
+ MIX_CHANNEL_POST = -2;
+
+ {* This is the format of a special effect callback:
+ *
+ * myeffect(int chan, void *stream, int len, void *udata);
+ *
+ * (chan) is the channel number that your effect is affecting. (stream) is
+ * the buffer of data to work upon. (len) is the size of (stream), and
+ * (udata) is a user-defined bit of data, which you pass as the last arg of
+ * Mix_RegisterEffect(), and is passed back unmolested to your callback.
+ * Your effect changes the contents of (stream) based on whatever parameters
+ * are significant, or just leaves it be, if you prefer. You can do whatever
+ * you like to the buffer, though, and it will continue in its changed state
+ * down the mixing pipeline, through any other effect functions, then finally
+ * to be mixed with the rest of the channels and music for the final output
+ * stream.
+ *
+ * DO NOT EVER call SDL_LockAudio() from your callback function!
+ *}
+type
+ TMix_EffectFunc_t = procedure(chan: Integer; stream: Pointer; len: Integer; udata: Pointer);
+
+ {*
+ * This is a callback that signifies that a channel has finished all its
+ * loops and has completed playback. This gets called if the buffer
+ * plays out normally, or if you call Mix_HaltChannel(), implicitly stop
+ * a channel via Mix_AllocateChannels(), or unregister a callback while
+ * it's still playing.
+ *
+ * DO NOT EVER call SDL_LockAudio() from your callback function!
+ *}
+type
+ TMix_EffectDone_t = procedure(chan: Integer; udata: Pointer);
+
+ {* Register a special effect function. At mixing time, the channel data is
+ * copied into a buffer and passed through each registered effect function.
+ * After it passes through all the functions, it is mixed into the final
+ * output stream. The copy to buffer is performed once, then each effect
+ * function performs on the output of the previous effect. Understand that
+ * this extra copy to a buffer is not performed if there are no effects
+ * registered for a given chunk, which saves CPU cycles, and any given
+ * effect will be extra cycles, too, so it is crucial that your code run
+ * fast. Also note that the data that your function is given is in the
+ * format of the sound device, and not the format you gave to Mix_OpenAudio(),
+ * although they may in reality be the same. This is an unfortunate but
+ * necessary speed concern. Use Mix_QuerySpec() to determine if you can
+ * handle the data before you register your effect, and take appropriate
+ * actions.
+ * You may also specify a callback (Mix_EffectDone_t) that is called when
+ * the channel finishes playing. This gives you a more fine-grained control
+ * than Mix_ChannelFinished(), in case you need to free effect-specific
+ * resources, etc. If you don't need this, you can specify NULL.
+ * You may set the callbacks before or after calling Mix_PlayChannel().
+ * Things like Mix_SetPanning() are just internal special effect functions,
+ * so if you are using that, you've already incurred the overhead of a copy
+ * to a separate buffer, and that these effects will be in the queue with
+ * any functions you've registered. The list of registered effects for a
+ * channel is reset when a chunk finishes playing, so you need to explicitly
+ * set them with each call to Mix_PlayChannel*().
+ * You may also register a special effect function that is to be run after
+ * final mixing occurs. The rules for these callbacks are identical to those
+ * in Mix_RegisterEffect, but they are run after all the channels and the
+ * music have been mixed into a single stream, whereas channel-specific
+ * effects run on a given channel before any other mixing occurs. These
+ * global effect callbacks are call "posteffects". Posteffects only have
+ * their Mix_EffectDone_t function called when they are unregistered (since
+ * the main output stream is never "done" in the same sense as a channel).
+ * You must unregister them manually when you've had enough. Your callback
+ * will be told that the channel being mixed is (MIX_CHANNEL_POST) if the
+ * processing is considered a posteffect.
+ *
+ * After all these effects have finished processing, the callback registered
+ * through Mix_SetPostMix() runs, and then the stream goes to the audio
+ * device.
+ *
+ * DO NOT EVER call SDL_LockAudio() from your callback function!
+ *
+ * returns zero if error (no such channel), nonzero if added.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_RegisterEffect(chan: Integer; f: TMix_EffectFunc_t; d: TMix_EffectDone_t; arg: Pointer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_RegisterEffect' {$ENDIF} {$ENDIF};
+
+ {* You may not need to call this explicitly, unless you need to stop an
+ * effect from processing in the middle of a chunk's playback.
+ * Posteffects are never implicitly unregistered as they are for channels,
+ * but they may be explicitly unregistered through this function by
+ * specifying MIX_CHANNEL_POST for a channel.
+ * returns zero if error (no such channel or effect), nonzero if removed.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_UnregisterEffect(channel: Integer; f: TMix_EffectFunc_t): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_UnregisterEffect' {$ENDIF} {$ENDIF};
+
+ {* You may not need to call this explicitly, unless you need to stop all
+ * effects from processing in the middle of a chunk's playback. Note that
+ * this will also shut off some internal effect processing, since
+ * Mix_SetPanning() and others may use this API under the hood. This is
+ * called internally when a channel completes playback.
+ * Posteffects are never implicitly unregistered as they are for channels,
+ * but they may be explicitly unregistered through this function by
+ * specifying MIX_CHANNEL_POST for a channel.
+ * returns zero if error (no such channel), nonzero if all effects removed.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_UnregisterAllEffects(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_UnregisterEffects' {$ENDIF} {$ENDIF};
+
+const
+ MIX_EFFECTSMAXSPEED = 'MIX_EFFECTSMAXSPEED';
+
+ {*
+ * These are the internally-defined mixing effects. They use the same API that
+ * effects defined in the application use, but are provided here as a
+ * convenience. Some effects can reduce their quality or use more memory in
+ * the name of speed; to enable this, make sure the environment variable
+ * MIX_EFFECTSMAXSPEED (see above) is defined before you call
+ * Mix_OpenAudio().
+ *}
+
+ {* Set the panning of a channel. The left and right channels are specified
+ * as integers between 0 and 255, quietest to loudest, respectively.
+ *
+ * Technically, this is just individual volume control for a sample with
+ * two (stereo) channels, so it can be used for more than just panning.
+ * If you want real panning, call it like this:
+ *
+ * Mix_SetPanning(channel, left, 255 - left);
+ *
+ * ...which isn't so hard.
+ *
+ * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+ * the panning will be done to the final mixed stream before passing it on
+ * to the audio device.
+ *
+ * This uses the Mix_RegisterEffect() API internally, and returns without
+ * registering the effect function if the audio device is not configured
+ * for stereo output. Setting both (left) and (right) to 255 causes this
+ * effect to be unregistered, since that is the data's normal state.
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ * nonzero if panning effect enabled. Note that an audio device in mono
+ * mode is a no-op, but this call will return successful in that case.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_SetPanning(channel: Integer; left: UInt8; right: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPanning' {$ENDIF} {$ENDIF};
+
+ {* Set the position of a channel. (angle) is an integer from 0 to 360, that
+ * specifies the location of the sound in relation to the listener. (angle)
+ * will be reduced as neccesary (540 becomes 180 degrees, -100 becomes 260).
+ * Angle 0 is due north, and rotates clockwise as the value increases.
+ * For efficiency, the precision of this effect may be limited (angles 1
+ * through 7 might all produce the same effect, 8 through 15 are equal, etc).
+ * (distance) is an integer between 0 and 255 that specifies the space
+ * between the sound and the listener. The larger the number, the further
+ * away the sound is. Using 255 does not guarantee that the channel will be
+ * culled from the mixing process or be completely silent. For efficiency,
+ * the precision of this effect may be limited (distance 0 through 5 might
+ * all produce the same effect, 6 through 10 are equal, etc). Setting (angle)
+ * and (distance) to 0 unregisters this effect, since the data would be
+ * unchanged.
+ *
+ * If you need more precise positional audio, consider using OpenAL for
+ * spatialized effects instead of SDL_mixer. This is only meant to be a
+ * basic effect for simple "3D" games.
+ *
+ * If the audio device is configured for mono output, then you won't get
+ * any effectiveness from the angle; however, distance attenuation on the
+ * channel will still occur. While this effect will function with stereo
+ * voices, it makes more sense to use voices with only one channel of sound,
+ * so when they are mixed through this effect, the positioning will sound
+ * correct. You can convert them to mono through SDL before giving them to
+ * the mixer in the first place if you like.
+ *
+ * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+ * the positioning will be done to the final mixed stream before passing it
+ * on to the audio device.
+ *
+ * This is a convenience wrapper over Mix_SetDistance() and Mix_SetPanning().
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ * nonzero if position effect is enabled.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_SetPosition(channel: Integer; angle: SInt16; distance: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetPosition' {$ENDIF} {$ENDIF};
+
+ {* Set the "distance" of a channel. (distance) is an integer from 0 to 255
+ * that specifies the location of the sound in relation to the listener.
+ * Distance 0 is overlapping the listener, and 255 is as far away as possible
+ * A distance of 255 does not guarantee silence; in such a case, you might
+ * want to try changing the chunk's volume, or just cull the sample from the
+ * mixing process with Mix_HaltChannel().
+ * For efficiency, the precision of this effect may be limited (distances 1
+ * through 7 might all produce the same effect, 8 through 15 are equal, etc).
+ * (distance) is an integer between 0 and 255 that specifies the space
+ * between the sound and the listener. The larger the number, the further
+ * away the sound is.
+ * Setting (distance) to 0 unregisters this effect, since the data would be
+ * unchanged.
+ * If you need more precise positional audio, consider using OpenAL for
+ * spatialized effects instead of SDL_mixer. This is only meant to be a
+ * basic effect for simple "3D" games.
+ *
+ * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+ * the distance attenuation will be done to the final mixed stream before
+ * passing it on to the audio device.
+ *
+ * This uses the Mix_RegisterEffect() API internally.
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ * nonzero if position effect is enabled.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_SetDistance(channel: Integer; distance: UInt8): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetDistance' {$ENDIF} {$ENDIF};
+
+{*
+ * !!! FIXME : Haven't implemented, since the effect goes past the
+ * end of the sound buffer. Will have to think about this.
+ * --ryan.
+ *}
+//#if 0
+{* Causes an echo effect to be mixed into a sound. (echo) is the amount
+ * of echo to mix. 0 is no echo, 255 is infinite (and probably not
+ * what you want).
+ *
+ * Setting (channel) to MIX_CHANNEL_POST registers this as a posteffect, and
+ * the reverbing will be done to the final mixed stream before passing it on
+ * to the audio device.
+ *
+ * This uses the Mix_RegisterEffect() API internally. If you specify an echo
+ * of zero, the effect is unregistered, as the data is already in that state.
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ * nonzero if reversing effect is enabled.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+//extern no_parse_DECLSPEC int SDLCALL Mix_SetReverb(int channel, Uint8 echo);
+//#endif
+
+ {* Causes a channel to reverse its stereo. This is handy if the user has his
+ * speakers hooked up backwards, or you would like to have a minor bit of
+ * psychedelia in your sound code. :) Calling this function with (flip)
+ * set to non-zero reverses the chunks's usual channels. If (flip) is zero,
+ * the effect is unregistered.
+ *
+ * This uses the Mix_RegisterEffect() API internally, and thus is probably
+ * more CPU intensive than having the user just plug in his speakers
+ * correctly. Mix_SetReverseStereo() returns without registering the effect
+ * function if the audio device is not configured for stereo output.
+ *
+ * If you specify MIX_CHANNEL_POST for (channel), then this the effect is used
+ * on the final mixed stream before sending it on to the audio device (a
+ * posteffect).
+ *
+ * returns zero if error (no such channel or Mix_RegisterEffect() fails),
+ * nonzero if reversing effect is enabled. Note that an audio device in mono
+ * mode is a no-op, but this call will return successful in that case.
+ * Error messages can be retrieved from Mix_GetError().
+ *}
+function Mix_SetReverseStereo(channel: Integer; flip: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetReverseStereo' {$ENDIF} {$ENDIF};
+
+ {* end of effects API. --ryan. *}
+
+ {* Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+ them dynamically to the next sample if requested with a -1 value below.
+ Returns the number of reserved channels.
+ *}
+function Mix_ReserveChannels(num: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ReverseChannels' {$ENDIF} {$ENDIF};
+
+ {* Channel grouping functions *}
+
+ {* Attach a tag to a channel. A tag can be assigned to several mixer
+ channels, to form groups of channels.
+ If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+ represent the group of all the channels).
+ Returns true if everything was OK.
+ *}
+function Mix_GroupChannel(which: Integer; tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupChannel' {$ENDIF} {$ENDIF};
+ {* Assign several consecutive channels to a group *}
+function Mix_GroupChannels(from: Integer; _to: Integer; tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupChannels' {$ENDIF} {$ENDIF};
+ {* Finds the first available channel in a group of channels,
+ returning -1 if none are available.
+ *}
+function Mix_GroupAvailable(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupAvailable' {$ENDIF} {$ENDIF};
+ {* Returns the number of channels in a group. This is also a subtle
+ way to get the total number of channels when 'tag' is -1
+ *}
+function Mix_GroupCount(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupCount' {$ENDIF} {$ENDIF};
+ {* Finds the "oldest" sample playing in a group of channels *}
+function Mix_GroupOldest(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupOldest' {$ENDIF} {$ENDIF};
+ {* Finds the "most recent" (i.e. last) sample playing in a group of channels *}
+function Mix_GroupNewer(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GroupNewer' {$ENDIF} {$ENDIF};
+
+ {* Play an audio chunk on a specific channel.
+ If the specified channel is -1, play on the first free channel.
+ If 'loops' is greater than zero, loop the sound that many times.
+ If 'loops' is -1, loop inifinitely (~65000 times).
+ Returns which channel was used to play the sound.
+ *}
+function Mix_PlayChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer): Integer;
+ {* The same as above, but the sound is played at most 'ticks' milliseconds *}
+function Mix_PlayChannelTimed(channel: Integer; chunk: PMix_Chunk; loops: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayChannelTimed' {$ENDIF} {$ENDIF};
+function Mix_PlayMusic(music: PMix_Music; loops: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayMusic' {$ENDIF} {$ENDIF};
+
+ {* Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions *}
+function Mix_FadeInMusic(music: PMix_Music; loops: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInMusic' {$ENDIF} {$ENDIF};
+function Mix_FadeInMusicPos(music: PMix_Music; loops: Integer; ms: Integer; position: Double): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInMusicPos' {$ENDIF} {$ENDIF};
+function Mix_FadeInChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer): Integer;
+function Mix_FadeInChannelTimed(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeInChannelTimed' {$ENDIF} {$ENDIF};
+
+ {* Set the volume in the range of 0-128 of a specific channel or chunk.
+ If the specified channel is -1, set volume for all channels.
+ Returns the original volume.
+ If the specified volume is -1, just return the current volume.
+ *}
+function Mix_Volume(channel: Integer; volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Volume' {$ENDIF} {$ENDIF};
+function Mix_VolumeChunk(chunk: PMix_Chunk; volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_VolumeChunk' {$ENDIF} {$ENDIF};
+function Mix_VolumeMusic(volume: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_VolumeMusic' {$ENDIF} {$ENDIF};
+
+ {* Halt playing of a particular channel *}
+function Mix_HaltChannel(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltChannel' {$ENDIF} {$ENDIF};
+function Mix_HaltGroup(tag: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltGroup' {$ENDIF} {$ENDIF};
+function Mix_HaltMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_HaltMusic' {$ENDIF} {$ENDIF};
+
+ {* Change the expiration delay for a particular channel.
+ The sample will stop playing after the 'ticks' milliseconds have elapsed,
+ or remove the expiration if 'ticks' is -1
+ *}
+function Mix_ExpireChannel(channel: Integer; ticks: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ExpireChannel' {$ENDIF} {$ENDIF};
+
+ {* Halt a channel, fading it out progressively till it's silent
+ The ms parameter indicates the number of milliseconds the fading
+ will take.
+ *}
+function Mix_FadeOutChannel(which: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutChannel' {$ENDIF} {$ENDIF};
+function Mix_FadeOutGroup(tag: Integer; ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutGroup' {$ENDIF} {$ENDIF};
+function Mix_FadeOutMusic(ms: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadeOutMusic' {$ENDIF} {$ENDIF};
+
+ {* Query the fading status of a channel *}
+function Mix_FadingMusic: TMix_Fading cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadingMusic' {$ENDIF} {$ENDIF};
+function Mix_FadingChannel(which: Integer): TMix_Fading cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_FadingChannel' {$ENDIF} {$ENDIF};
+
+ {* Pause/Resume a particular channel *}
+procedure Mix_Pause(channel: Integer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Pause' {$ENDIF} {$ENDIF};
+procedure Mix_Resume(channel: Integer) cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Resume' {$ENDIF} {$ENDIF};
+function Mix_Paused(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Paused' {$ENDIF} {$ENDIF};
+
+ {* Pause/Resume the music stream *}
+procedure Mix_PauseMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PauseMusic' {$ENDIF} {$ENDIF};
+procedure Mix_ResumeMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_ResumeMusic' {$ENDIF} {$ENDIF};
+procedure Mix_RewindMusic cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_RewindMusic' {$ENDIF} {$ENDIF};
+function Mix_PausedMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PausedMusic' {$ENDIF} {$ENDIF};
+
+ {* Set the current position in the music stream.
+ This returns 0 if successful, or -1 if it failed or isn't implemented.
+ This function is only implemented for MOD music formats (set pattern
+ order number) and for OGG, FLAC, MP3_MAD, and MODPLUG music (set
+ position in seconds), at the moment.
+ *}
+function Mix_SetMusicPosition(position: Double): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetMusicPosition' {$ENDIF} {$ENDIF};
+
+ {* Check the status of a specific channel.
+ If the specified channel is -1, check all channels.
+ *}
+function Mix_Playing(channel: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_Playing' {$ENDIF} {$ENDIF};
+function Mix_PlayingMusic: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_PlayingMusic' {$ENDIF} {$ENDIF};
+
+ {* Stop music and set external music playback command *}
+function Mix_SetMusicCMD(command: PAnsiChar): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetMusicCMD' {$ENDIF} {$ENDIF};
+
+ {* Synchro value is set by MikMod from modules while playing *}
+function Mix_SetSynchroValue(value: Integer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetSynchroValue' {$ENDIF} {$ENDIF};
+function Mix_GetSynchroValue: Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetSynchroValue' {$ENDIF} {$ENDIF};
+
+ {* Set/Get/Iterate SoundFonts paths to use by supported MIDI backends *}
+function Mix_SetSoundFonts(paths: PAnsiChar): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_SetSoundFonts' {$ENDIF} {$ENDIF};
+function Mix_GetSoundFonts: PAnsiChar cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetSoundFonts' {$ENDIF} {$ENDIF};
+
+type
+ TMix_SoundFunc = function(c: PAnsiChar; p: Pointer): Integer;
+
+function Mix_EachSoundFont(func: TMix_SoundFunc; data: Pointer): Integer cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_EachSoundFont' {$ENDIF} {$ENDIF};
+
+ {* Get the Mix_Chunk currently associated with a mixer channel
+ Returns NULL if it's an invalid channel, or there's no chunk associated.
+ *}
+function Mix_GetChunk(channel: Integer): PMix_Chunk cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_GetChunk' {$ENDIF} {$ENDIF};
+
+ {* Close the mixer, halting all playing audio *}
+procedure Mix_CloseAudio cdecl; external MIX_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_MIX_CloseAudio' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function Mix_SetError(const fmt: PAnsiChar): SInt32;
+function Mix_GetError: PAnsiChar;
+
+implementation
+
+procedure SDL_MIXER_VERSION(X: PSDL_Version);
+begin
+ X.major := SDL_MIXER_MAJOR_VERSION;
+ X.minor := SDL_MIXER_MINOR_VERSION;
+ X.patch := SDL_MIXER_PATCHLEVEL;
+end;
+
+procedure MIX_VERSION(X: PSDL_Version);
+begin
+ SDL_MIXER_VERSION(X);
+end;
+
+function Mix_FadeInChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer; ms: Integer): Integer;
+begin
+ Result := Mix_FadeInChannelTimed(channel, chunk, loops, ms, -1);
+end;
+
+function Mix_PlayChannel(channel: Integer; chunk: PMix_Chunk; loops: Integer): Integer;
+begin
+ Result := Mix_PlayChannelTimed(channel, chunk, loops, -1);
+end;
+
+function Mix_LoadWAV(_file: PAnsiChar): PMix_Chunk;
+begin
+ Result := Mix_LoadWAV_RW(SDL_RWFromFile(_file, 'rb'), 1);
+end;
+
+function Mix_SetError(const fmt: PAnsiChar): SInt32;
+begin
+ Result := SDL_SetError(fmt);
+end;
+
+function Mix_GetError: PAnsiChar;
+begin
+ Result := SDL_GetError;
+end;
+
+end.
--- /dev/null
+unit SDL2_net;
+
+{*
+ SDL_net: An example cross-platform network library for use with SDL
+ Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+ Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+*}
+
+{* $Id$ *}
+
+interface
+
+{$IFNDEF SDL}
+type
+ PUInt8 = ^UInt8;
+ Uint8 = Byte;
+ Uint16 = Word;
+ Uint32 = Cardinal;
+
+ uint8_t = Uint8;
+ uint16_t = Uint16;
+ uint32_t = Uint32;
+
+ PSDLNet_version = ^TSDLNet_version;
+ TSDLNet_version = record
+ major,
+ minor,
+ patch: UInt8;
+ end;
+
+{$ELSE} {* WITHOUT_SDL *}
+
+uses
+ SDL;
+
+type
+ PSDLNet_version = ^TSDLNet_version;
+ TSDLNet_version = TSDL_Version;
+
+{$ENDIF} {* WITHOUT_SDL *}
+
+ {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+const
+{$IFDEF WIN32}
+ NET_LibName = 'SDL2_net.dll';
+{$ELSE}
+ {$IFDEF WIN64}
+ NET_LibName = 'SDL2_net.dll';
+ {$ENDIF}
+{$ENDIF}
+
+{$IFDEF UNIX}
+ {$IFDEF DARWIN}
+ NET_LibName = 'libSDL2_net.dylib';
+ {$ELSE}
+ {$IFDEF FPC}
+ NET_LibName = 'libSDL2_net.so';
+ {$ELSE}
+ NET_LibName = 'libSDL2_net.so.0';
+ {$ENDIF}
+ {$ENDIF}
+{$ENDIF}
+
+{$IFDEF MACOS}
+ NET_LibName = 'SDL2_net';
+ {$IFDEF FPC}
+ {$linklib libSDL2_net}
+ {$ENDIF}
+{$ENDIF}
+
+ SDL_NET_MAJOR_VERSION = 2;
+ SDL_NET_MINOR_VERSION = 0;
+ SDL_NET_PATCHLEVEL = 0;
+
+ {* This macro can be used to fill a version structure with the compile-time
+ * version of the SDL_net library.
+ *}
+procedure SDL_NET_VERSION(var x: TSDLNet_Version);
+
+ {* This function gets the version of the dynamically linked SDL_net library.
+ it should NOT be used to fill a version structure, instead you should
+ use the SDL_NET_VERSION() macro.
+ *}
+function SDLNet_Linked_Version(): TSDLNET_Version cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Linked_Version' {$ENDIF} {$ENDIF};
+
+ {* Initialize/Cleanup the network API
+ SDL must be initialized before calls to functions in this library,
+ because this library uses utility functions from the SDL library.
+ *}
+function SDLNet_Init(): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Init' {$ENDIF} {$ENDIF};
+procedure SDLNet_Quit() cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_Quit' {$ENDIF} {$ENDIF};
+
+{***********************************************************************}
+{* IPv4 hostname resolution API *}
+{***********************************************************************}
+type
+ PIPAdress = ^TIPAdress;
+ TIPAdress = record
+ host: UInt32; {* 32-bit IPv4 host address *}
+ port: UInt16; {* 16-bit protocol port *}
+ end;
+
+ {* Resolve a host name and port to an IP address in network form.
+ If the function succeeds, it will return 0.
+ If the host couldn't be resolved, the host portion of the returned
+ address will be INADDR_NONE, and the function will return -1.
+ If 'host' is NULL, the resolved host will be set to INADDR_ANY.
+ *}
+const
+ INADDR_ANY = $00000000;
+ INADDR_NONE = $FFFFFFFF;
+ INADDR_LOOPBACK = $7f000001;
+ INADDR_BROADCAST = $FFFFFFFF;
+
+function SDLNet_ResolveHost(address: PIPAdress; host: PAnsiChar; port: UInt16): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResolveHost' {$ENDIF} {$ENDIF};
+
+ {* Resolve an ip address to a host name in canonical form.
+ If the ip couldn't be resolved, this function returns NULL,
+ otherwise a pointer to a static buffer containing the hostname
+ is returned. Note that this function is not thread-safe.
+ *}
+function SDLNet_ResolveIP(const ip: PIPAdress): PAnsiChar cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResolveIP' {$ENDIF} {$ENDIF};
+
+ {* Get the addresses of network interfaces on this system.
+ This returns the number of addresses saved in 'addresses'
+ *}
+function SDLNet_GetLocalAddresses(addresses: PIPAdress; maxcount: Integer): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_GetLocalAddresses' {$ENDIF} {$ENDIF};
+
+{***********************************************************************}
+{* TCP network API *}
+{***********************************************************************}
+type
+ PTCPsocket = ^TTCPsocket;
+ TTCPsocket = Pointer; //todo
+
+ {* Open a TCP network socket
+ If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server
+ socket on the given port, otherwise a TCP connection to the remote
+ host and port is attempted. The address passed in should already be
+ swapped to network byte order (addresses returned from
+ SDLNet_ResolveHost() are already in the correct form).
+ The newly created socket is returned, or NULL if there was an error.
+ *}
+function SDLNet_TCP_Open(ip: PIPAdress): TTCPsocket cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Open' {$ENDIF} {$ENDIF};
+
+ {* Accept an incoming connection on the given server socket.
+ The newly created socket is returned, or NULL if there was an error.
+ *}
+function SDLNet_TCP_Accept(server: TTCPsocket): TTCPsocket cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Accept' {$ENDIF} {$ENDIF};
+
+ {* Get the IP address of the remote system associated with the socket.
+ If the socket is a server socket, this function returns NULL.
+ *}
+function SDLNet_TCP_GetPeerAddress(sock: TTCPsocket): PIPAdress cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_GetPeerAddress' {$ENDIF} {$ENDIF};
+
+ {* Send 'len' bytes of 'data' over the non-server socket 'sock'
+ This function returns the actual amount of data sent. If the return value
+ is less than the amount of data sent, then either the remote connection was
+ closed, or an unknown socket error occurred.
+ *}
+function SDLNet_TCP_Send(sock: TTCPsocket; data: Pointer; len: Integer): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Send' {$ENDIF} {$ENDIF};
+
+ {* Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
+ and store them in the buffer pointed to by 'data'.
+ This function returns the actual amount of data received. If the return
+ value is less than or equal to zero, then either the remote connection was
+ closed, or an unknown socket error occurred.
+ *}
+function SDLNet_TCP_Recv(sock: TTCPsocket; data: Pointer; maxlen: Integer): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Recv' {$ENDIF} {$ENDIF};
+
+ {* Close a TCP network socket *}
+procedure SDLNet_TCP_Close(sock: TTCPsocket) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_TCP_Close' {$ENDIF} {$ENDIF};
+
+
+{***********************************************************************}
+{* UDP network API *}
+{***********************************************************************}
+
+const
+ {* The maximum channels on a a UDP socket *}
+ SDLNET_MAX_UDPCHANNELS = 32;
+ {* The maximum addresses bound to a single UDP socket channel *}
+ SDLNET_MAX_UDPADDRESSES = 4;
+
+type
+ PUDPsocket = ^TUDPsocket;
+ TUDPsocket = Pointer; //todo
+
+ PPUDPpacket = ^PUDPpacket;
+ PUDPpacket = ^TUDPpacket;
+ TUDPpacket = record
+ channel: Integer; {* The src/dst channel of the packet *}
+ data: PUInt8; {* The packet data *}
+ len: Integer; {* The length of the packet data *}
+ maxlen: Integer; {* The size of the data buffer *}
+ status: Integer; {* packet status after sending *}
+ address: TIPadress; {* The source/dest address of an incoming/outgoing packet *}
+ end;
+
+ {* Allocate/resize/free a single UDP packet 'size' bytes long.
+ The new packet is returned, or NULL if the function ran out of memory.
+ *}
+function SDLNet_AllocPacket(size: Integer): PUDPpacket cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocPacket' {$ENDIF} {$ENDIF};
+function SDLNet_ResizePacket(packet: PUDPpacket; newsize: Integer): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_ResizePacket' {$ENDIF} {$ENDIF};
+procedure SDLNet_FreePacket(packet: PUDPpacket) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreePacket' {$ENDIF} {$ENDIF};
+
+ {* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets,
+ each 'size' bytes long.
+ A pointer to the first packet in the array is returned, or NULL if the
+ function ran out of memory.
+ *}
+function SDLNet_AllocPacketV(howmany: Integer; size: Integer): PPUDPpacket cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocPacketV' {$ENDIF} {$ENDIF};
+procedure SDLNet_FreePacketV(packetV: PPUDPpacket) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreePacketV' {$ENDIF} {$ENDIF};
+
+ {* Open a UDP network socket
+ If 'port' is non-zero, the UDP socket is bound to a local port.
+ The 'port' should be given in native byte order, but is used
+ internally in network (big endian) byte order, in addresses, etc.
+ This allows other systems to send to this socket via a known port.
+ *}
+function SDLNet_UDP_Open(port: UInt16): TUDPsocket cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Open' {$ENDIF} {$ENDIF};
+
+ {* Set the percentage of simulated packet loss for packets sent on the socket.
+ *}
+procedure SDLNet_UDP_SetPacketLoss(sock: TUDPsocket; percent: Integer) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_SetPacketLoss' {$ENDIF} {$ENDIF};
+
+ {* Bind the address 'address' to the requested channel on the UDP socket.
+ If the channel is -1, then the first unbound channel that has not yet
+ been bound to the maximum number of addresses will be bound with
+ the given address as it's primary address.
+ If the channel is already bound, this new address will be added to the
+ list of valid source addresses for packets arriving on the channel.
+ If the channel is not already bound, then the address becomes the primary
+ address, to which all outbound packets on the channel are sent.
+ This function returns the channel which was bound, or -1 on error.
+ *}
+function SDLNet_UDP_Bind(sock: TUDPsocket; channel: Integer; address: PIPadress): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Bind' {$ENDIF} {$ENDIF};
+
+ {* Unbind all addresses from the given channel *}
+procedure SDLNet_UDP_Unbind(sock: TUDPsocket; channel: Integer) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Unbind' {$ENDIF} {$ENDIF};
+
+ {* Get the primary IP address of the remote system associated with the
+ socket and channel. If the channel is -1, then the primary IP port
+ of the UDP socket is returned -- this is only meaningful for sockets
+ opened with a specific port.
+ If the channel is not bound and not -1, this function returns NULL.
+ *}
+function SDLNet_UDP_GetPeerAddress(sock: TUDPsocket; channel: Integer): PIPadress cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_GetPeerAddress' {$ENDIF} {$ENDIF};
+
+ {* Send a vector of packets to the the channels specified within the packet.
+ If the channel specified in the packet is -1, the packet will be sent to
+ the address in the 'src' member of the packet.
+ Each packet will be updated with the status of the packet after it has
+ been sent, -1 if the packet send failed.
+ This function returns the number of packets sent.
+ *}
+function SDLNet_UDP_SendV(sock: TUDPsocket; packets: PPUDPpacket; npackets: Integer): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_SendV' {$ENDIF} {$ENDIF};
+
+ {* Send a single packet to the specified channel.
+ If the channel specified in the packet is -1, the packet will be sent to
+ the address in the 'src' member of the packet.
+ The packet will be updated with the status of the packet after it has
+ been sent.
+ This function returns 1 if the packet was sent, or 0 on error.
+
+ NOTE:
+ The maximum size of the packet is limited by the MTU (Maximum Transfer Unit)
+ of the transport medium. It can be as low as 250 bytes for some PPP links,
+ and as high as 1500 bytes for ethernet.
+ *}
+function SDLNet_UDP_Send(sock: TUDPsocket; channel: Integer; packet: PUDPpacket): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Send' {$ENDIF} {$ENDIF};
+
+ {* Receive a vector of pending packets from the UDP socket.
+ The returned packets contain the source address and the channel they arrived
+ on. If they did not arrive on a bound channel, the the channel will be set
+ to -1.
+ The channels are checked in highest to lowest order, so if an address is
+ bound to multiple channels, the highest channel with the source address
+ bound will be returned.
+ This function returns the number of packets read from the network, or -1
+ on error. This function does not block, so can return 0 packets pending.
+ *}
+function SDLNet_UDP_RecvV(sock: TUDPsocket; packets: PPUDPpacket): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_RecvV' {$ENDIF} {$ENDIF};
+
+ {* Receive a single packet from the UDP socket.
+ The returned packet contains the source address and the channel it arrived
+ on. If it did not arrive on a bound channel, the the channel will be set
+ to -1.
+ The channels are checked in highest to lowest order, so if an address is
+ bound to multiple channels, the highest channel with the source address
+ bound will be returned.
+ This function returns the number of packets read from the network, or -1
+ on error. This function does not block, so can return 0 packets pending.
+ *}
+function SDLNet_UDP_Recv(sock: TUDPsocket; packet: PUDPpacket): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Recv' {$ENDIF} {$ENDIF};
+
+ {* Close a UDP network socket *}
+procedure SDLNet_UDP_Close(sock: TUDPsocket) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_UDP_Close' {$ENDIF} {$ENDIF};
+
+
+{***********************************************************************}
+{* Hooks for checking sockets for available data *}
+{***********************************************************************}
+
+type
+ PSDLNet_SocketSet = ^TSDLNet_SocketSet;
+ TSDLNet_SocketSet = Pointer; //todo
+
+ {* Any network socket can be safely cast to this socket type *}
+ PSDLNet_GenericSocket = ^TSDLNet_GenericSocket;
+ TSDLNet_GenericSocket = record
+ ready: Integer;
+ end;
+
+ {* Allocate a socket set for use with SDLNet_CheckSockets()
+ This returns a socket set for up to 'maxsockets' sockets, or NULL if
+ the function ran out of memory.
+ *}
+function SDLNet_AllocSocketSet(maxsockets: Integer): TSDLNet_SocketSet cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AllocSocketSet' {$ENDIF} {$ENDIF};
+
+ {* Add a socket to a set of sockets to be checked for available data *}
+function SDLNet_AddSocket(_set: TSDLNet_SocketSet; sock: TSDLNet_GenericSocket): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_AddSocket' {$ENDIF} {$ENDIF};
+
+function SDLNet_TCP_AddSocket(_set: TSDLNet_SocketSet; sock: TTCPsocket): Integer;
+function SDLNet_UDP_AddSocket(_set: TSDLNet_SocketSet; sock: TUDPsocket): Integer;
+
+
+ {* Remove a socket from a set of sockets to be checked for available data *}
+function SDLNet_DelSocket(_set: TSDLNet_SocketSet; sock: TSDLNet_GenericSocket): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_DelSocket' {$ENDIF} {$ENDIF};
+
+function SDLNet_TCP_DelSocket(_set: TSDLNet_SocketSet; sock: TTCPsocket): Integer;
+function SDLNet_UDP_DelSocket(_set: TSDLNet_SocketSet; sock: TUDPsocket): Integer;
+
+ {* This function checks to see if data is available for reading on the
+ given set of sockets. If 'timeout' is 0, it performs a quick poll,
+ otherwise the function returns when either data is available for
+ reading, or the timeout in milliseconds has elapsed, which ever occurs
+ first. This function returns the number of sockets ready for reading,
+ or -1 if there was an error with the select() system call.
+ *}
+function SDLNet_CheckSockets(_set: TSDLNet_SocketSet; timeout: UInt32): Integer cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_CheckSockets' {$ENDIF} {$ENDIF};
+
+ {* After calling SDLNet_CheckSockets(), you can use this function on a
+ socket that was in the socket set, to find out if data is available
+ for reading.
+ *}
+function SDLNet_SocketReady(sock: TSDLNet_GenericSocket): Boolean;
+
+ {* Free a set of sockets allocated by SDL_NetAllocSocketSet() *}
+procedure SDLNet_FreeSocketSet(_set: TSDLNet_SocketSet) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_FreeSocketSet' {$ENDIF} {$ENDIF};
+
+{***********************************************************************}
+{* Error reporting functions *}
+{***********************************************************************}
+
+procedure SDLNet_SetError(fmt: PAnsiChar) cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_SetError' {$ENDIF} {$ENDIF};
+function SDLNet_GetError(): PAnsiChar cdecl; external NET_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDLNet_GetError' {$ENDIF} {$ENDIF};
+
+{***********************************************************************}
+{* Inline functions to read/write network data *}
+{***********************************************************************}
+
+ {* Warning, some systems have data access alignment restrictions *} {
+#if defined(sparc) || defined(mips) || defined(__arm__)
+#define SDL_DATA_ALIGNED 1
+#endif
+#ifndef SDL_DATA_ALIGNED
+#define SDL_DATA_ALIGNED 0
+#endif }
+
+ {* Write a 16/32-bit value to network packet buffer *} {
+#define SDLNet_Write16(value, areap) _SDLNet_Write16(value, areap)
+#define SDLNet_Write32(value, areap) _SDLNet_Write32(value, areap)
+ }
+ {* Read a 16/32-bit value from network packet buffer *} {
+#define SDLNet_Read16(areap) _SDLNet_Read16(areap)
+#define SDLNet_Read32(areap) _SDLNet_Read32(areap) }
+ {
+#if !defined(WITHOUT_SDL) && !SDL_DATA_ALIGNED
+
+SDL_FORCE_INLINE void _SDLNet_Write16(Uint16 value, void *areap)
+{
+ *(Uint16 *)areap = SDL_SwapBE16(value);
+} {
+
+SDL_FORCE_INLINE void _SDLNet_Write32(Uint32 value, void *areap)
+{
+ *(Uint32 *)areap = SDL_SwapBE32(value);
+}
+ {
+SDL_FORCE_INLINE Uint16 _SDLNet_Read16(const void *areap)
+{
+ return SDL_SwapBE16(*(const Uint16 *)areap);
+}
+ {
+SDL_FORCE_INLINE Uint32 _SDLNet_Read32(const void *areap)
+{
+ return SDL_SwapBE32(*(const Uint32 *)areap);
+}
+ {
+#else {* !defined(WITHOUT_SDL) && !SDL_DATA_ALIGNED *}
+ {
+SDL_FORCE_INLINE void _SDLNet_Write16(Uint16 value, void *areap)
+{
+ Uint8 *area = (Uint8*)areap;
+ area[0] = (value >> 8) & 0xFF;
+ area[1] = value & 0xFF;
+}
+ {
+SDL_FORCE_INLINE void _SDLNet_Write32(Uint32 value, void *areap)
+{
+ Uint8 *area = (Uint8*)areap;
+ area[0] = (value >> 24) & 0xFF;
+ area[1] = (value >> 16) & 0xFF;
+ area[2] = (value >> 8) & 0xFF;
+ area[3] = value & 0xFF;
+}
+ {
+SDL_FORCE_INLINE Uint16 _SDLNet_Read16(void *areap)
+{
+ Uint8 *area = (Uint8*)areap;
+ return ((Uint16)area[0]) << 8 | ((Uint16)area[1]);
+} {
+
+SDL_FORCE_INLINE Uint32 _SDLNet_Read32(const void *areap)
+{
+ const Uint8 *area = (const Uint8*)areap;
+ return ((Uint32)area[0]) << 24 | ((Uint32)area[1]) << 16 | ((Uint32)area[2]) << 8 | ((Uint32)area[3]);
+}
+
+implementation
+
+procedure SDL_NET_VERSION(var x: TSDLNet_Version);
+begin
+ x.major := SDL_NET_MAJOR_VERSION;
+ x.minor := SDL_NET_MINOR_VERSION;
+ x.patch := SDL_NET_PATCHLEVEL;
+end;
+
+function SDLNet_TCP_AddSocket(_set: TSDLNet_SocketSet; sock: TTCPsocket): Integer;
+begin
+ Result := SDLNet_AddSocket(_set, TSDLNet_GenericSocket(sock));
+end;
+
+function SDLNet_UDP_AddSocket(_set: TSDLNet_SocketSet; sock: TUDPsocket): Integer;
+begin
+ Result := SDLNet_AddSocket(_set, TSDLNet_GenericSocket(sock));
+end;
+
+function SDLNet_TCP_DelSocket(_set: TSDLNet_SocketSet; sock: TTCPsocket): Integer;
+begin
+ Result := SDLNet_DelSocket(_set, TSDLNet_GenericSocket(sock));
+end;
+
+function SDLNet_UDP_DelSocket(_set: TSDLNet_SocketSet; sock: TUDPsocket): Integer;
+begin
+ Result := SDLNet_DelSocket(_set, TSDLNet_GenericSocket(sock));
+end;
+
+function SDLNet_SocketReady(sock: TSDLNet_GenericSocket): Boolean;
+begin
+ Result := Boolean(sock.ready);
+end;
+
+end.
+
--- /dev/null
+unit sdl2_ttf;
+
+{*
+ SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts
+ Copyright (C) 2001-2013 Sam Lantinga <slouken@libsdl.org>
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgement in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+*}
+
+{* This library is a wrapper around the excellent FreeType 2.0 library,
+ available at:
+ http://www.freetype.org/
+*}
+
+{* ChangeLog: (Header Translation)
+ ----------
+
+ v.1.72-stable; 29.09.2013: fixed bug with procedures without parameters
+ (they must have brackets)
+ v.1.70-stable; 11.09.2013: Initial Commit
+
+*}
+
+interface
+
+{$I jedi.inc}
+
+uses
+ SDL2;
+
+const
+ {$IFDEF WINDOWS}
+ TTF_LibName = 'SDL2_ttf.dll';
+ {$ENDIF}
+
+ {$IFDEF UNIX}
+ {$IFDEF DARWIN}
+ TTF_LibName = 'libSDL_tff-2.dylib';
+ {$ELSE}
+ {$IFDEF FPC}
+ TTF_LibName = 'libSDL_ttf-2.so';
+ {$ELSE}
+ TTF_LibName = 'libSDL_ttf-2.so.0';
+ {$ENDIF}
+ {$ENDIF}
+ {$ENDIF}
+
+ {$IFDEF MACOS}
+ TTF_LibName = 'SDL2_ttf';
+ {$IFDEF FPC}
+ {$linklib libSDL2_ttf}
+ {$ENDIF}
+ {$ENDIF}
+
+{* Set up for C function definitions, even when using C++ *}
+
+{* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}
+const
+ SDL_TTF_MAJOR_VERSION = 2;
+ SDL_TTF_MINOR_VERSION = 0;
+ SDL_TTF_PATCHLEVEL = 12;
+
+{* Backwards compatibility *}
+const
+ TTF_MAJOR_VERSION = SDL_TTF_MAJOR_VERSION;
+ TTF_MINOR_VERSION = SDL_TTF_MINOR_VERSION;
+ TTF_PATCHLEVEL = SDL_TTF_PATCHLEVEL;
+ //TTF_VERSION(X) = SDL_TTF_VERSION(X);
+
+ {* This function gets the version of the dynamically linked SDL_ttf library.
+ it should NOT be used to fill a version structure, instead you should
+ use the SDL_TTF_VERSION() macro.
+ *}
+function TTF_Linked_Version: TSDL_Version cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Linked_Version' {$ENDIF} {$ENDIF};
+
+{* ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark) *}
+const
+ UNICODE_BOM_NATIVE = $FEFF;
+ UNICODE_BOM_SWAPPED = $FFFE;
+
+{* This function tells the library whether UNICODE text is generally
+ byteswapped. A UNICODE BOM character in a string will override
+ this setting for the remainder of that string.
+*}
+procedure TTF_ByteSwappedUNICODE(swapped: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_ByteSwappedUNICODE' {$ENDIF} {$ENDIF};
+
+{* The internal structure containing font information *}
+type
+ PTTF_Font = ^TTTF_Font;
+ TTTF_Font = record end; //todo?
+
+{* Initialize the TTF engine - returns 0 if successful, -1 on error *}
+function TTF_Init(): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Init' {$ENDIF} {$ENDIF};
+
+{* Open a font file and create a font of the specified point size.
+ * Some .fon fonts will have several sizes embedded in the file, so the
+ * point size becomes the index of choosing which size. If the value
+ * is too high, the last indexed size will be the default. *}
+function TTF_OpenFont(_file: PAnsiChar; ptsize: Integer): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFont' {$ENDIF} {$ENDIF};
+function TTF_OpenFontIndex(_file: PAnsiChar; ptsize: Integer; index: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontIndex' {$ENDIF} {$ENDIF};
+function TTF_OpenFontRW(src: PSDL_RWops; freesrc: Integer; ptsize: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontRW' {$ENDIF} {$ENDIF};
+function TTF_OpenFontIndexRW(src: PSDL_RWops; freesrc: Integer; ptsize: Integer; index: LongInt): PTTF_Font cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_OpenFontIndexRW' {$ENDIF} {$ENDIF};
+
+{* Set and retrieve the font style *}
+const
+ TTF_STYLE_NORMAL = $00;
+ TTF_STYLE_BOLD = $01;
+ TTF_STYLE_ITALIC = $02;
+ TTF_STYLE_UNDERLINE = $04;
+ TTF_STYLE_STRIKETHROUGH = $08;
+
+function TTF_GetFontStyle(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontStyle' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontStyle(font: PTTF_Font; style: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontStyle' {$ENDIF} {$ENDIF};
+function TTF_GetFontOutline(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontOutline' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontOutline(font: PTTF_Font; outline: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontOutline' {$ENDIF} {$ENDIF};
+
+{* Set and retrieve FreeType hinter settings *}
+const
+ TTF_HINTING_NORMAL = 0;
+ TTF_HINTING_LIGHT = 1;
+ TTF_HINTING_MONO = 2;
+ TTF_HINTING_NONE = 3;
+
+function TTF_GetFontHinting(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontHinting' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontHinting(font: PTTF_Font; hinting: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontHinting' {$ENDIF} {$ENDIF};
+
+{* Get the total height of the font - usually equal to point size *}
+function TTF_FontHeight(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontHeight' {$ENDIF} {$ENDIF};
+
+{* Get the offset from the baseline to the top of the font
+ This is a positive value, relative to the baseline.
+ *}
+function TTF_FontAscent(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontAscent' {$ENDIF} {$ENDIF};
+
+{* Get the offset from the baseline to the bottom of the font
+ This is a negative value, relative to the baseline.
+ *}
+function TTF_FontDescent(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontDescent' {$ENDIF} {$ENDIF};
+
+{* Get the recommended spacing between lines of text for this font *}
+function TTF_FontLineSkip(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontLineSkip' {$ENDIF} {$ENDIF};
+
+{* Get/Set whether or not kerning is allowed for this font *}
+function TTF_GetFontKerning(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontKerning' {$ENDIF} {$ENDIF};
+procedure TTF_SetFontKerning(font: PTTF_Font; allowed: Integer) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SetFontKerning' {$ENDIF} {$ENDIF};
+
+{* Get the number of faces of the font *}
+function TTF_FontFaces(font: PTTF_Font): LongInt cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaces' {$ENDIF} {$ENDIF};
+
+{* Get the font face attributes, if any *}
+function TTF_FontFaceIsFixedWidth(font: PTTF_Font): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceIsFixedWidth' {$ENDIF} {$ENDIF};
+function TTF_FontFaceFamilyName(font: PTTF_Font): PAnsiChar cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceFamilyName' {$ENDIF} {$ENDIF};
+function TTF_FontFaceStyleName(font: PTTF_Font): PAnsiChar cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_FontFaceStyleName' {$ENDIF} {$ENDIF};
+
+{* Check wether a glyph is provided by the font or not *}
+function TTF_GlyphIsProvided(font: PTTF_Font; ch: UInt16): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GlyphIsProvided' {$ENDIF} {$ENDIF};
+
+{* Get the metrics (dimensions) of a glyph
+ To understand what these metrics mean, here is a useful link:
+ http://freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
+ *}
+function TTF_GlyphMetrics(font: PTTF_Font; ch: UInt16;
+ minx, maxx: PInt;
+ miny, maxy: PInt; advance: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GlyphMetrics' {$ENDIF} {$ENDIF};
+
+{* Get the dimensions of a rendered string of text *}
+function TTF_SizeText(font: PTTF_Font; text: PAnsiChar; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeText' {$ENDIF} {$ENDIF};
+function TTF_SizeUTF8(font: PTTF_Font; text: PAnsiChar; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeUTF8' {$ENDIF} {$ENDIF};
+function TTF_SizeUNICODE(font: PTTF_Font; text: PUInt16; w, h: PInt): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_SizeUNICODE' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given text at
+ fast quality with the given font and color. The 0 pixel is the
+ colorkey, giving a transparent background, and the 1 pixel is set
+ to the text color.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Solid(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Solid' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Solid(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Solid' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Solid(font: PTTF_Font; text: PUInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Solid' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given glyph at
+ fast quality with the given font and color. The 0 pixel is the
+ colorkey, giving a transparent background, and the 1 pixel is set
+ to the text color. The glyph is rendered without any padding or
+ centering in the X direction, and aligned normally in the Y direction.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Solid(font: PTTF_Font; ch: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Solid' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given text at
+ high quality with the given font and colors. The 0 pixel is background,
+ while other pixels have varying degrees of the foreground color.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Shaded(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Shaded' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Shaded(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Shaded' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Shaded(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Shaded' {$ENDIF} {$ENDIF};
+
+{* Create an 8-bit palettized surface and render the given glyph at
+ high quality with the given font and colors. The 0 pixel is background,
+ while other pixels have varying degrees of the foreground color.
+ The glyph is rendered without any padding or centering in the X
+ direction, and aligned normally in the Y direction.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Shaded(font: PTTF_Font; ch: UInt16; fg, bg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Shaded' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given text at high quality,
+ using alpha blending to dither the font with the given color.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Blended(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Blended' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Blended(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Blended' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Blended(font: PTTF_Font; text: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Blended' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given text at high quality,
+ using alpha blending to dither the font with the given color.
+ Text is wrapped to multiple lines on line endings and on word boundaries
+ if it extends beyond wrapLength in pixels.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderText_Blended_Wrapped(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderText_Blended_Wrapped' {$ENDIF} {$ENDIF};
+function TTF_RenderUTF8_Blended_Wrapped(font: PTTF_Font; text: PAnsiChar; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUTF8_Blended_Wrapped' {$ENDIF} {$ENDIF};
+function TTF_RenderUNICODE_Blended_Wrapped(font: PTTF_Font; text: PUInt16; fg: TSDL_Color; wrapLength: UInt32): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderUNICODE_Blended_Wrapped' {$ENDIF} {$ENDIF};
+
+{* Create a 32-bit ARGB surface and render the given glyph at high quality,
+ using alpha blending to dither the font with the given color.
+ The glyph is rendered without any padding or centering in the X
+ direction, and aligned normally in the Y direction.
+ This function returns the new surface, or NULL if there was an error.
+*}
+function TTF_RenderGlyph_Blended(font: PTTF_Font; ch: UInt16; fg: TSDL_Color): PSDL_Surface cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_RenderGlyph_Blended' {$ENDIF} {$ENDIF};
+
+{* For compatibility with previous versions, here are the old functions *}
+function TTF_RenderText(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+function TTF_RenderUTF8(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+function TTF_RenderUNICODE(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface;
+
+{* Close an opened font file *}
+procedure TTF_CloseFont(font: PTTF_Font) cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_CloseFont' {$ENDIF} {$ENDIF};
+
+{* De-initialize the TTF engine *}
+procedure TTF_Quit() cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_Quit' {$ENDIF} {$ENDIF};
+
+{* Check if the TTF engine is initialized *}
+function TTF_WasInit: Boolean cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_WasInit' {$ENDIF} {$ENDIF};
+
+{* Get the kerning size of two glyphs *}
+function TTF_GetFontKerningSize(font: PTTF_Font; prev_index, index: Integer): Integer cdecl; external TTF_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_TTF_GetFontKerningSize' {$ENDIF} {$ENDIF};
+
+{* We'll use SDL for reporting errors *}
+function TTF_SetError(const fmt: PAnsiChar): SInt32;
+function TTF_GetError: PAnsiChar;
+
+implementation
+
+function TTF_SetError(const fmt: PAnsiChar): SInt32;
+begin
+ Result := SDL_SetError(fmt);
+end;
+
+function TTF_GetError: PAnsiChar;
+begin
+ Result := SDL_GetError;
+end;
+
+function TTF_RenderText(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+ Result := TTF_RenderText_Shaded(font, text, fg, bg);
+end;
+
+function TTF_RenderUTF8(font: PTTF_Font; text: PAnsiChar; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+ Result := TTF_RenderUTF8_Shaded(font, text, fg, bg);
+end;
+
+function TTF_RenderUNICODE(font: PTTF_Font; text: PUInt16; fg, bg: TSDL_Color): PSDL_Surface;
+begin
+ Result := TTF_RenderUNICODE_Shaded(font, text, fg, bg);
+end;
+
+end.
+
--- /dev/null
+{
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+ Pascal-Header-Conversion
+ Copyright (c) 2012/13 Tim Blume aka End
+
+ sdl.inc is based on the files:
+ "begin_code.h",
+ "close_code.h",
+ "sdl_config.h",
+ "sdl_config_windows.h",
+ ...
+ it defines some variables for several Pascal-Compilers and OS-versions.
+
+ It is based on mine updated version of jedi-sdl.inc from the SDL 1.2 Headers,
+ they can be found at delphigl.com or on my github-repository:
+
+ https://github.com/ev1313/
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+}
+
+{
+ Changelog:
+ ----------
+ v. 1.63-stable; 16.09.13: since GPC isn't supported anymore, i've deleted it from here, too.
+ v. 1.22-alpha; 24.07.13: fixed some bugs. special thanks to kotai from pascalgamedevelopment.com
+ v. 1.00-alpha; 05.07.13: Initial Alpha-Release
+}
+
+{.$define Debug} { uncomment for debugging }
+
+{$IFNDEF FPC}
+ {$IFDEF Debug}
+ {$F+,D+,Q-,L+,R+,I-,S+,Y+,A+}
+ {$ELSE}
+ {$F+,Q-,R-,S-,I-,A+}
+ {$ENDIF}
+{$ENDIF} {FPC}
+
+{$IFDEF LINUX}
+{$DEFINE UNIX}
+{$ENDIF}
+
+{$IFDEF ver70}
+ {$IFDEF Windows}
+ {$DEFINE Win16}
+ {$ENDIF Windows}
+ {$IFDEF MSDOS}
+ {$DEFINE NO_EXPORTS}
+ {$ENDIF MSDOS}
+ {$IFDEF DPMI}
+ {$DEFINE BP_DPMI}
+ {$ENDIF}
+ {$DEFINE OS_16_BIT}
+ {$DEFINE __OS_DOS__}
+{$ENDIF ver70}
+
+{$IFDEF ver80}
+ {$DEFINE Delphi} {Delphi 1.x}
+ {$DEFINE Delphi16}
+ {$DEFINE Win16}
+ {$DEFINE OS_16_BIT}
+ {$DEFINE __OS_DOS__}
+{$ENDIF ver80}
+
+{$IFDEF ver90}
+ {$DEFINE Delphi} {Delphi 2.x}
+ {$DEFINE WIN32}
+ {$DEFINE WINDOWS}
+{$ENDIF ver90}
+
+{$IFDEF ver100}
+ {$DEFINE Delphi} {Delphi 3.x}
+ {$DEFINE WIN32}
+ {$DEFINE WINDOWS}
+{$ENDIF ver100}
+
+{$IFDEF ver93}
+ {$DEFINE Delphi} {C++ Builder 1.x}
+ {$DEFINE WINDOWS}
+{$ENDIF ver93}
+
+{$IFDEF ver110}
+ {$DEFINE Delphi} {C++ Builder 3.x}
+ {$DEFINE WINDOWS}
+{$ENDIF ver110}
+
+{$IFDEF ver120}
+ {$DEFINE Delphi} {Delphi 4.x}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Has_Int64}
+ {$DEFINE WINDOWS}
+{$ENDIF ver120}
+
+{$IFDEF ver130}
+ {$DEFINE Delphi} {Delphi / C++ Builder 5.x}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Has_Int64}
+ {$DEFINE WINDOWS}
+{$ENDIF ver130}
+
+{$IFDEF ver140}
+ {$DEFINE Delphi} {Delphi / C++ Builder 6.x}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Has_Int64}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver140}
+
+{$IFDEF ver150}
+ {$DEFINE Delphi} {Delphi 7.x}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver150}
+
+{$IFDEF ver160}
+ {$DEFINE Delphi} {Delphi 8.x}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver160}
+
+{$IFDEF ver170}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2005}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver170}
+
+{$IFDEF ver180}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2006 / 2007}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver180}
+
+{$IFDEF ver185}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2007}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver185}
+
+{$IFDEF ver190}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2007 }
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver190}
+
+{$IFDEF ver200}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2009 }
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$DEFINE Delphi13UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver200}
+
+{$IFDEF ver210}
+ {$DEFINE Delphi} {Delphi / C++ Builder 2010}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$DEFINE Delphi13UP}
+ {$DEFINE Delphi14UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver210}
+
+{$IFDEF ver220}
+ {$DEFINE Delphi} {Delphi / C++ Builder XE}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$DEFINE Delphi13UP}
+ {$DEFINE Delphi14UP}
+ {$DEFINE Delphi15UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver220}
+
+{$IFDEF ver230}
+ {$DEFINE Delphi} {Delphi / C++ Builder XE2}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$DEFINE Delphi13UP}
+ {$DEFINE Delphi14UP}
+ {$DEFINE Delphi15UP}
+ {$DEFINE Delphi16UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver230}
+
+{$IFDEF ver240}
+ {$DEFINE Delphi} {Delphi / C++ Builder XE4}
+ {$DEFINE Delphi4UP}
+ {$DEFINE Delphi5UP}
+ {$DEFINE Delphi6UP}
+ {$DEFINE Delphi7UP}
+ {$DEFINE Delphi8UP}
+ {$DEFINE Delphi9UP}
+ {$DEFINE Delphi10UP}
+ {$DEFINE Delphi11UP}
+ {$DEFINE Delphi12UP}
+ {$DEFINE Delphi13UP}
+ {$DEFINE Delphi14UP}
+ {$DEFINE Delphi15UP}
+ {$DEFINE Delphi16UP}
+ {$DEFINE Delphi17UP}
+ {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Native}
+ {$DEFINE HAS_TYPES}
+{$ENDIF ver240}
+
+{$IFDEF UNIX}
+ {$ifdef VER140} // Kylix 1 & 2
+ {$DEFINE KYLIX}
+ {$DEFINE KYLIX1UP}
+ {$DEFINE KYLIX2UP}
+ {$DEFINE HAS_TYPES}
+ {$endif}
+
+ {$ifdef VER150} // Kylix 3
+ {$DEFINE KYLIX}
+ {$DEFINE KYLIX1UP}
+ {$DEFINE KYLIX2UP}
+ {$DEFINE KYLIX3UP}
+ {$DEFINE HAS_TYPES}
+ {$endif}
+{$ENDIF UNIX}
+
+{*************** define 16/32/64 Bit ********************}
+
+{$IFDEF WIN16}
+ {$DEFINE 16BIT}
+ {$DEFINE WINDOWS}
+{$ELSE}
+ {$IFDEF WIN32}
+ {$DEFINE 32BIT}
+ {$DEFINE WINDOWS}
+ {$ELSE}
+ {$IFDEF WIN64}
+ {$DEFINE 64BIT}
+ {$DEFINE WINDOWS}
+ {$ELSE}
+ //TODO!!
+ {$DEFINE 32BIT}
+ {$ENDIF}
+ {$ENDIF}
+{$ENDIF}
+
+{$IFDEF VirtualPascal} { Virtual Pascal 2.x }
+ {$DEFINE Delphi} { Use Delphi Syntax }
+ {$DEFINE VP2}
+ {&Delphi+}
+{$ENDIF VirtualPascal}
+
+{$IFDEF Delphi}
+ {$DEFINE USE_STDCALL}
+ {$IFDEF 32Bit}
+ {$DEFINE DELPHI32}
+ {$ELSE}
+ {$IFDEF 64Bit}
+ {$DEFINE DELPHI64}
+ {$ELSE}
+ {$DEFINE DELPHI16}
+ {$ENDIF}
+ {$ENDIF}
+ //{$ALIGN ON}
+{$ENDIF Delphi}
+
+{$IFDEF FPC}
+ {$MODE Delphi} { use Delphi compatibility mode }
+ {$H+}
+ {$PACKRECORDS C} // Added for record
+ {$MACRO ON} // Added For OpenGL
+ {$DEFINE Delphi}
+ {$DEFINE UseAT}
+ {$UNDEF USE_STDCALL}
+ {$DEFINE OS_BigMem}
+ {$DEFINE NO_EXPORTS}
+ {$DEFINE Has_UInt64}
+ {$DEFINE Has_Int64}
+ {$DEFINE Has_Native}
+ {$DEFINE NOCRT}
+ {$IFDEF UNIX}
+ {$DEFINE fpc_unix}
+ {$ELSE}
+ {$DEFINE __OS_DOS__}
+ {$ENDIF}
+ {$IFDEF WIN32}
+ {$DEFINE UseWin}
+ {$ENDIF}
+ {$DEFINE HAS_TYPES}
+{$ENDIF FPC}
+
+{$IFDEF Win16}
+ {$K+} {smart callbacks}
+{$ENDIF Win16}
+
+{$IFDEF OS2}
+ {$UNDEF Windows}
+ {$DEFINE UseWin}
+ {$DEFINE OS_BigMem}
+{$ENDIF OS2}
+
+{$IFDEF __TMT__}
+ {$DEFINE OS_BigMem}
+ {$DEFINE NO_EXPORTS}
+ {$DEFINE __OS_DOS__}
+ {$DEFINE UseAT}
+ {$IFNDEF MSDOS}
+ {$DEFINE USE_STDCALL}
+ {$ENDIF}
+
+ {$IFDEF __WIN32__}
+ {$DEFINE Win32}
+ {$DEFINE UseWin}
+ {$DEFINE NOCRT}
+ {$DEFINE Win32}
+ {$IFNDEF __CON__}
+ {$DEFINE Windows}
+ {$ENDIF}
+ {$ENDIF}
+
+ {$A+} // Word alignment data
+ {$OA+} // Objects and structures align
+{$ENDIF}
+
+{$IFDEF Win32}
+ {$DEFINE OS_BigMem}
+{$ELSE Win32}
+ {$IFDEF ver70}
+ {$DEFINE assembler}
+ {$ENDIF} { use 16-bit assembler! }
+{$ENDIF Win32}
+
+{ ************************** dos/dos-like platforms **************}
+{$IFDEF Windows}
+ {$DEFINE __OS_DOS__}
+ {$DEFINE UseWin}
+ {$DEFINE MSWINDOWS}
+{$ENDIF Delphi}
+
+{$IFDEF OS2}
+ {$DEFINE __OS_DOS__}
+ {$DEFINE Can_Use_DLL}
+{$ENDIF Delphi}
+
+{$IFDEF UseWin}
+ {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF Win16}
+ {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF BP_DPMI}
+ {$DEFINE Can_Use_DLL}
+{$ENDIF}
+
+{$IFDEF USE_STDCALL}
+ {$IFNDEF __TMT__}
+ {$DEFINE BY_NAME}
+ {$ENDIF}
+{$ENDIF}
+
+{$IFNDEF ver70}
+ {$UNDEF assembler}
+{$ENDIF}
+
+{*************** define LITTLE ENDIAN platforms ********************}
+
+
+{$IFDEF Delphi}
+ {$DEFINE IA32}
+ {$DEFINE ENDIAN_LITTLE}
+{$ENDIF}
+
+{$IFDEF KYLIX}
+ {$DEFINE IA32}
+{$ENDIF}
+
+{$IFDEF FPC}
+ {$IFDEF FPC_LITTLE_ENDIAN}
+ {$DEFINE IA32}
+ {$ENDIF}
+{$ENDIF}
--- /dev/null
+//from "sdl.h"
+
+const
+
+ SDL_INIT_TIMER = $00000001;
+ {$EXTERNALSYM SDL_INIT_TIMER}
+ SDL_INIT_AUDIO = $00000010;
+ {$EXTERNALSYM SDL_INIT_AUDIO}
+ SDL_INIT_VIDEO = $00000020;
+ {$EXTERNALSYM SDL_INIT_VIDEO}
+ SDL_INIT_JOYSTICK = $00000200;
+ {$EXTERNALSYM SDL_INIT_JOYSTICK}
+ SDL_INIT_HAPTIC = $00001000;
+ {$EXTERNALSYM SDL_INIT_HAPTIC}
+ SDL_INIT_GAMECONTROLLER = $00002000; //turn on game controller also implicitly does JOYSTICK
+ {$EXTERNALSYM SDL_INIT_GAMECONTROLLER}
+ SDL_INIT_NOPARACHUTE = $00100000; //Don't catch fatal signals
+ {$EXTERNALSYM SDL_INIT_NOPARACHUTE}
+ SDL_INIT_EVERYTHING = SDL_INIT_TIMER or
+ SDL_INIT_AUDIO or
+ SDL_INIT_VIDEO or
+ SDL_INIT_JOYSTICK or
+ SDL_INIT_HAPTIC or
+ SDL_INIT_GAMECONTROLLER;
+ {$EXTERNALSYM SDL_INIT_EVERYTHING}
+
+{**
+ * This function initializes the subsystems specified by flags
+ * Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
+ * signal handlers for some commonly ignored fatal signals (like SIGSEGV).
+ *}
+
+function SDL_Init(flags: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Init' {$ENDIF} {$ENDIF};
+
+{**
+ * This function initializes specific SDL subsystems
+ *}
+
+function SDL_InitSubSystem(flags: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_InitSubSystem' {$ENDIF} {$ENDIF};
+
+{**
+ * This function cleans up specific SDL subsystems
+ *}
+
+procedure SDL_QuitSubSystem(flags: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QuitSubSystem' {$ENDIF} {$ENDIF};
+
+{**
+ * This function returns a mask of the specified subsystems which have
+ * previously been initialized.
+ *
+ * If flags is 0, it returns a mask of all initialized subsystems.
+ *}
+
+function SDL_WasInit(flags: UInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WasInit' {$ENDIF} {$ENDIF};
+
+{**
+ * This function cleans up all initialized subsystems. You should
+ * call it upon all exit conditions.
+ *}
+
+procedure SDL_Quit() cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Quit' {$ENDIF} {$ENDIF};
+
--- /dev/null
+unit SDL2;
+
+{
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
+
+ Pascal-Header-Conversion
+ Copyright (C) 2012/13 Tim Blume aka End/EV1313
+
+ SDL.pas is based on the files:
+ "sdl.h",
+ "sdl_audio.h",
+ "sdl_blendmode.h",
+ "sdl_events.h",
+ "sdl_error.h",
+ "sdl_gesture.h",
+ "sdl_haptic.h",
+ "sdl_hints.h",
+ "sdl_joystick.h",
+ "sdl_keyboard.h",
+ "sdl_keycode.h",
+ "sdl_loadso.h"
+ "sdl_pixels.h",
+ "sdl_power.h",
+ "sdl_main.h",
+ "sdl_messagebox.h",
+ "sdl_mouse.h",
+ "sdl_mutex.h",
+ "sdl_rect.h",
+ "sdl_render.h",
+ "sdl_rwops.h",
+ "sdl_scancode.h",
+ "sdl_shape.h",
+ "sdl_stdinc.h",
+ "sdl_surface.h",
+ "sdl_thread.h",
+ "sdl_timer.h",
+ "sdl_touch.h",
+ "sdl_version.h",
+ "sdl_video.h",
+ "sdltype_s.h"
+
+ I will not translate:
+ "sdl_opengl.h",
+ "sdl_opengles.h"
+ "sdl_opengles2.h"
+
+ cause there's a much better OpenGL-Header avaible at delphigl.com:
+
+ the dglopengl.pas
+
+ Parts of the SDL.pas are from the SDL-1.2-Headerconversion from the JEDI-Team,
+ written by Domenique Louis and others.
+
+ I've changed the names of the dll for 32 & 64-Bit, so theres no conflict
+ between 32 & 64 bit Libraries.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no case will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Special Thanks to:
+
+ - DelphiGL.com - Community
+ - Domenique Louis and everyone else from the JEDI-Team
+ - Sam Latinga and everyone else from the SDL-Team
+}
+
+{
+ Changelog:
+ ----------
+ v.1.73-stable; 08.11.2013: added sdl_hints.h and some keystate helpers
+ thx to Cybermonkey!
+ v.1.72-stable; 23.09.2013: fixed bug with procedures without parameters
+ (they must have brakets)
+ v.1.70-stable; 17.09.2013: added "sdl_messagebox.h" and "sdl_haptic.h"
+ v.1.63-stable; 16.09.2013: added libs sdl2_image and sdl2_ttf and added sdl_audio.h
+ v.1.62-stable; 03.09.2013: fixed.
+ v.1.61-stable; 02.09.2013: now it should REALLY work with Mac...
+ v.1.60-stable; 01.09.2013: now it should work with Delphi XE4 for Windows and
+ MacOS and of course Lazarus. thx to kotai :D
+ v.1.55-Alpha; 24.08.2013: fixed bug with SDL_GetEventState thx to d.l.i.w.
+ v.1.54-Alpha; 24.08.2013: added sdl_loadso.h
+ v.1.53-Alpha; 24.08.2013: renamed *really* and fixed linux comp.
+ v.1.52-Alpha; 24.08.2013: renamed sdl.pas to sdl2.pas
+ v.1.51-Alpha; 24.08.2013: added sdl_platform.h
+ v.1.50-Alpha; 24.08.2013: the header is now modular. thx for the hint from d.l.i.w.
+ v.1.40-Alpha; 13.08.2013: Added MacOS compatibility (thx to stoney-fd)
+ v.1.34-Alpha; 05.08.2013: Added missing functions from sdl_thread.h
+ v.1.33-Alpha; 31.07.2013: Added missing units for Linux. thx to Cybermonkey
+ v.1.32-Alpha; 31.07.2013: Fixed three bugs, thx to grieferatwork
+ v.1.31-Alpha; 30.07.2013: Added "sdl_power.h"
+ v.1.30-Alpha; 26.07.2013: Added "sdl_thread.h" and "sdl_mutex.h"
+ v.1.25-Alpha; 29.07.2013: Added Makros for SDL_RWops
+ v.1.24-Alpha; 28.07.2013: Fixed bug with RWops and size_t
+ v.1.23-Alpha; 27.07.2013: Fixed two bugs, thx to GrieferAtWork
+ v.1.22-Alpha; 24.07.2013: Added "sdl_shape.h" and TSDL_Window
+ (and ordered the translated header list ^^)
+ v.1.21-Alpha; 23.07.2013: Added TSDL_Error
+ v.1.20-Alpha; 19.07.2013: Added "sdl_timer.h"
+ v.1.10-Alpha; 09.07.2013: Added "sdl_render.h"
+ v.1.00-Alpha; 05.07.2013: Initial Alpha-Release.
+}
+
+{$DEFINE SDL}
+
+{$I jedi.inc}
+
+interface
+
+ {$IFDEF WINDOWS}
+ uses
+ Windows;
+ {$ENDIF}
+
+ {$IFDEF LINUX}
+ uses
+ X,
+ XLib;
+ {$ENDIF}
+
+const
+
+ {$IFDEF WINDOWS}
+ SDL_LibName = 'SDL2.dll';
+ {$ENDIF}
+
+ {$IFDEF UNIX}
+ {$IFDEF DARWIN}
+ SDL_LibName = 'libSDL2.dylib';
+ {$ELSE}
+ {$IFDEF FPC}
+ SDL_LibName = 'libSDL2.so';
+ {$ELSE}
+ SDL_LibName = 'libSDL2.so.0';
+ {$ENDIF}
+ {$ENDIF}
+ {$ENDIF}
+
+ {$IFDEF MACOS}
+ SDL_LibName = 'SDL2';
+ {$IFDEF FPC}
+ {$linklib libSDL2}
+ {$ENDIF}
+ {$ENDIF}
+
+{$I sdltype.inc}
+{$I sdlversion.inc}
+{$I sdlerror.inc}
+{$I sdlplatform.inc}
+{$I sdlpower.inc}
+{$I sdlthread.inc}
+{$I sdlmutex.inc}
+{$I sdltimer.inc}
+{$I sdlpixels.inc}
+{$I sdlrect.inc}
+{$I sdlrwops.inc}
+{$I sdlaudio.inc}
+{$I sdlblendmode.inc}
+{$I sdlsurface.inc}
+{$I sdlshape.inc}
+{$I sdlvideo.inc}
+{$I sdlhints.inc}
+{$I sdlmessagebox.inc}
+{$I sdlrenderer.inc}
+{$I sdlscancode.inc}
+{$I sdlkeyboard.inc}
+{$I sdlmouse.inc}
+{$I sdljoystick.inc}
+{$I sdlhaptic.inc}
+{$I sdltouch.inc}
+{$I sdlgesture.inc}
+{$I sdlevents.inc}
+{$I sdl.inc}
+
+implementation
+
+//from "sdl_version.h"
+procedure SDL_VERSION(x: PSDL_Version);
+begin
+ x.major := SDL_MAJOR_VERSION;
+ x.minor := SDL_MINOR_VERSION;
+ x.patch := SDL_PATCHLEVEL;
+end;
+
+function SDL_VERSIONNUM(X,Y,Z: UInt32): Cardinal;
+begin
+ Result := X*1000 + Y*100 + Z;
+end;
+
+function SDL_COMPILEDVERSION: Cardinal;
+begin
+ Result := SDL_VERSIONNUM(SDL_MAJOR_VERSION,
+ SDL_MINOR_VERSION,
+ SDL_PATCHLEVEL);
+end;
+
+function SDL_VERSION_ATLEAST(X,Y,Z: Cardinal): Boolean;
+begin
+ Result := SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X,Y,Z);
+end;
+
+{$IFDEF WINDOWS}
+//from "sdl_thread.h"
+
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; overload;
+begin
+ Result := SDL_CreateThread(fn,name,data,nil,nil);
+end;
+
+{$ENDIF}
+
+//from "sdl_rect.h"
+function SDL_RectEmpty(X: TSDL_Rect): Boolean;
+begin
+ Result := (X.w <= 0) or (X.h <= 0);
+end;
+
+function SDL_RectEquals(A: TSDL_Rect; B: TSDL_Rect): Boolean;
+begin
+ Result := (A.x = B.x) and (A.y = B.y) and (A.w = B.w) and (A.h = B.h);
+end;
+
+//from "sdl_rwops.h"
+
+function SDL_RWsize(ctx: PSDL_RWops): SInt64;
+begin
+ Result := ctx^.size(ctx);
+end;
+
+function SDL_RWseek(ctx: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64;
+begin
+ Result := ctx^.seek(ctx,offset,whence);
+end;
+
+function SDL_RWtell(ctx: PSDL_RWops): SInt64;
+begin
+ Result := ctx^.seek(ctx, 0, RW_SEEK_CUR);
+end;
+
+function SDL_RWread(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+begin
+ Result := ctx^.read(ctx, ptr, size, n);
+end;
+
+function SDL_RWwrite(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+begin
+ Result := ctx^.write(ctx, ptr, size, n);
+end;
+
+function SDL_RWclose(ctx: PSDL_RWops): SInt32;
+begin
+ Result := ctx^.close(ctx);
+end;
+
+//from "sdl_audio.h"
+
+function SDL_LoadWAV(_file: PAnsiChar; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec;
+begin
+ Result := SDL_LoadWAV_RW(SDL_RWFromFile(_file, 'rb'), 1, spec, audio_buf, audio_len);
+end;
+
+function SDL_AUDIO_BITSIZE(x: Cardinal): Cardinal;
+begin
+ Result := x and SDL_AUDIO_MASK_BITSIZE;
+end;
+
+function SDL_AUDIO_ISFLOAT(x: Cardinal): Cardinal;
+begin
+ Result := x and SDL_AUDIO_MASK_DATATYPE;
+end;
+
+function SDL_AUDIO_ISBIGENDIAN(x: Cardinal): Cardinal;
+begin
+ Result := x and SDL_AUDIO_MASK_ENDIAN;
+end;
+
+function SDL_AUDIO_ISSIGNED(x: Cardinal): Cardinal;
+begin
+ Result := x and SDL_AUDIO_MASK_SIGNED;
+end;
+
+function SDL_AUDIO_ISINT(x: Cardinal): Cardinal;
+begin
+ Result := not SDL_AUDIO_ISFLOAT(x);
+end;
+
+function SDL_AUDIO_ISLITTLEENDIAN(x: Cardinal): Cardinal;
+begin
+ Result := not SDL_AUDIO_ISLITTLEENDIAN(x);
+end;
+
+function SDL_AUDIO_ISUNSIGNED(x: Cardinal): Cardinal;
+begin
+ Result := not SDL_AUDIO_ISSIGNED(x);
+end;
+
+//from "sdl_pixels.h"
+
+function SDL_PIXELFLAG(X: Cardinal): Boolean;
+begin
+ Result := (X shr 28) = $0F;
+end;
+
+function SDL_PIXELTYPE(X: Cardinal): Boolean;
+begin
+ Result := (X shr 24) = $0F;
+end;
+
+function SDL_PIXELORDER(X: Cardinal): Boolean;
+begin
+ Result := (X shr 20) = $0F;
+end;
+
+function SDL_PIXELLAYOUT(X: Cardinal): Boolean;
+begin
+ Result := (X shr 16) = $0F;
+end;
+
+function SDL_BITSPERPIXEL(X: Cardinal): Boolean;
+begin
+ Result := (X shr 8) = $FF;
+end;
+
+function SDL_IsPixelFormat_FOURCC(format: Variant): Boolean;
+begin
+ {* The flag is set to 1 because 0x1? is not in the printable ASCII range *}
+ Result := format and SDL_PIXELFLAG(format) <> 1;
+end;
+
+//from "sdl_surface.h"
+function SDL_LoadBMP(_file: PAnsiChar): PSDL_Surface;
+begin
+ Result := SDL_LoadBMP_RW(SDL_RWFromFile(_file, 'rb'), 1);
+end;
+
+//from "sdl_video.h"
+function SDL_WindowPos_IsUndefined(X: Variant): Variant;
+begin
+ Result := (X and $FFFF0000) = SDL_WINDOWPOS_UNDEFINED_MASK;
+end;
+
+function SDL_WindowPos_IsCentered(X: Variant): Variant;
+begin
+ Result := (X and $FFFF0000) = SDL_WINDOWPOS_CENTERED_MASK;
+end;
+
+//from "sdl_events.h"
+
+function SDL_GetEventState(type_: UInt32): UInt8;
+begin
+ Result := SDL_EventState(type_, SDL_QUERY);
+end;
+
+end.
--- /dev/null
+//from sdl_audio.h
+ {**
+ * Audio format flags.
+ *
+ * These are what the 16 bits in SDL_AudioFormat currently mean...
+ * (Unspecified bits are always zero).
+ *
+ *
+ ++-----------------------sample is signed if set
+ ||
+ || ++-----------sample is bigendian if set
+ || ||
+ || || ++---sample is float if set
+ || || ||
+ || || || +---sample bit size---+
+ || || || | |
+ 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
+ *
+ * There are macros in SDL 2.0 and later to query these bits.
+ *}
+type
+ TSDL_AudioFormat = UInt16;
+
+ {**
+ * Audio flags
+ *}
+const
+ SDL_AUDIO_MASK_BITSIZE = ($FF);
+ SDL_AUDIO_MASK_DATATYPE = (1 shl 8);
+ SDL_AUDIO_MASK_ENDIAN = (1 shl 12);
+ SDL_AUDIO_MASK_SIGNED = (1 shl 15);
+
+function SDL_AUDIO_BITSIZE(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISFLOAT(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISBIGENDIAN(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISSIGNED(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISINT(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISLITTLEENDIAN(x: Cardinal): Cardinal;
+function SDL_AUDIO_ISUNSIGNED(x: Cardinal): Cardinal;
+
+ {**
+ * Audio format flags
+ *
+ * Defaults to LSB byte order.
+ *}
+const
+ AUDIO_U8 = $0008; {**< Unsigned 8-bit samples *}
+ AUDIO_S8 = $8008; {**< Signed 8-bit samples *}
+ AUDIO_U16LSB = $0010; {**< Unsigned 16-bit samples *}
+ AUDIO_S16LSB = $8010; {**< Signed 16-bit samples *}
+ AUDIO_U16MSB = $1010; {**< As above, but big-endian byte order *}
+ AUDIO_S16MSB = $9010; {**< As above, but big-endian byte order *}
+ AUDIO_U16 = AUDIO_U16LSB;
+ AUDIO_S16 = AUDIO_S16LSB;
+
+ {**
+ * int32 support
+ *}
+const
+ AUDIO_S32LSB = $8020; {**< 32-bit integer samples *}
+ AUDIO_S32MSB = $9020; {**< As above, but big-endian byte order *}
+ AUDIO_S32 = AUDIO_S32LSB;
+
+ {**
+ * float32 support
+ *}
+const
+ AUDIO_F32LSB = $8120; {**< 32-bit floating point samples *}
+ AUDIO_F32MSB = $9120; {**< As above, but big-endian byte order *}
+ AUDIO_F32 = AUDIO_F32LSB;
+
+ {**
+ * Native audio byte ordering
+ *}
+ {
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define AUDIO_U16SYS AUDIO_U16LSB
+#define AUDIO_S16SYS AUDIO_S16LSB
+#define AUDIO_S32SYS AUDIO_S32LSB
+#define AUDIO_F32SYS AUDIO_F32LSB
+#else
+#define AUDIO_U16SYS AUDIO_U16MSB
+#define AUDIO_S16SYS AUDIO_S16MSB
+#define AUDIO_S32SYS AUDIO_S32MSB
+#define AUDIO_F32SYS AUDIO_F32MSB
+#endif}
+
+ {**
+ * Allow change flags
+ *
+ * Which audio format changes are allowed when opening a device.
+ *}
+const
+ SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = $00000001;
+ SDL_AUDIO_ALLOW_FORMAT_CHANGE = $00000002;
+ SDL_AUDIO_ALLOW_CHANNELS_CHANGE = $00000004;
+ SDL_AUDIO_ALLOW_ANY_CHANGE = (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE or
+ SDL_AUDIO_ALLOW_FORMAT_CHANGE or
+ SDL_AUDIO_ALLOW_CHANNELS_CHANGE);
+
+ {*Audio flags*}
+
+ {**
+ * This function is called when the audio device needs more data.
+ *
+ * userdata An application-specific parameter saved in
+ * the SDL_AudioSpec structure
+ * stream A pointer to the audio data buffer.
+ * len 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.
+ *}
+type
+ TSDL_AudioCallback = procedure(userdata: Pointer; stream: PUInt8; len: Integer);
+
+ {**
+ * The calculated values in this structure are calculated by SDL_OpenAudio().
+ *}
+type
+ PSDL_AudioSpec = ^TSDL_AudioSpec;
+ TSDL_AudioSpec = record
+ freq: Integer; {**< DSP frequency -- samples per second *}
+ format: TSDL_AudioFormat; {**< 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 (power of 2) *}
+ padding: UInt16; {**< Necessary for some compile environments *}
+ size: UInt32; {**< Audio buffer size in bytes (calculated) *}
+ callback: TSDL_AudioCallback;
+ userdata: Pointer;
+ end;
+
+ PSDL_AudioCVT = ^TSDL_AudioCVT;
+ TSDL_AudioFilter = procedure(cvt: PSDL_AudioCVT; format: TSDL_AudioFormat);
+
+ {**
+ * A structure to hold a set of audio conversion filters and buffers.
+ *}
+ TSDL_AudioCVT = record
+ needed: Integer; {**< Set to 1 if conversion possible *}
+ src_format: TSDL_AudioFormat; {**< Source audio format *}
+ dst_format: TSDL_AudioFormat; {**< Target audio format *}
+ rate_incr: Double; {**< Rate conversion increment *}
+ buf: PUInt8; {**< Buffer to hold entire audio data *}
+ len: Integer; {**< Length of original audio buffer *}
+ len_cvt: Integer; {**< Length of converted audio buffer *}
+ len_mult: Integer; {**< buffer must be len*len_mult big *}
+ len_ratio: Double; {**< Given len, final size is len*len_ratio *}
+ filters: array[0..9] of TSDL_AudioFilter; {**< Filter list *}
+ filter_index: Integer; {**< Current audio conversion function *}
+ end;
+
+
+ {* Function prototypes *}
+
+ {**
+ * Driver discovery functions
+ *
+ * These functions return the list of built in audio drivers, in the
+ * order that they are normally initialized by default.
+ *}
+
+function SDL_GetNumAudioDrivers: Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumAudioDrivers' {$ENDIF} {$ENDIF};
+function SDL_GetAudioDriver(index: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDriver' {$ENDIF} {$ENDIF};
+
+ {**
+ * Initialization and cleanup
+ *
+ * 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().
+ *}
+
+function SDL_AudioInit(driver_name: PAnsiChar): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioInit' {$ENDIF} {$ENDIF};
+procedure SDL_AudioQuit cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioQuit' {$ENDIF} {$ENDIF};
+
+ {**
+ * This function returns the name of the current audio driver, or NULL
+ * if no driver has been initialized.
+ *}
+function SDL_GetCurrentAudioDriver: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCurrentAudioDriver' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+function SDL_OpenAudio(desired: PSDL_AudioSpec; obtained: PSDL_AudioSpec): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_OpenAudio' {$ENDIF} {$ENDIF};
+
+ {**
+ * SDL Audio Device IDs.
+ *
+ * A successful call to SDL_OpenAudio() is always device id 1, and legacy
+ * SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
+ * always returns devices >= 2 on success. The legacy calls are good both
+ * for backwards compatibility and when you don't care about multiple,
+ * specific, or capture devices.
+ *}
+type
+ TSDL_AudioDeviceID = UInt32;
+
+ {**
+ * Get the number of available devices exposed by the current driver.
+ * Only valid after a successfully initializing the audio subsystem.
+ * Returns -1 if an explicit list of devices can't be determined; this is
+ * not an error. For example, if SDL is set up to talk to a remote audio
+ * server, it can't list every one available on the Internet, but it will
+ * still allow a specific host to be specified to SDL_OpenAudioDevice().
+ *
+ * In many common cases, when this function returns a value <= 0, it can still
+ * successfully open the default device (NULL for first argument of
+ * SDL_OpenAudioDevice()).
+ *}
+function SDL_GetNumAudioDevices(iscapture: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumAudioDevices' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the human-readable name of a specific audio device.
+ * Must be a value between 0 and (number of audio devices-1).
+ * Only valid after a successfully initializing the audio subsystem.
+ * The values returned by this function reflect the latest call to
+ * SDL_GetNumAudioDevices(); recall that function to redetect available
+ * hardware.
+ *
+ * The string returned by this function is UTF-8 encoded, read-only, and
+ * managed internally. You are not to free it. If you need to keep the
+ * string for any length of time, you should make your own copy of it, as it
+ * will be invalid next time any of several other SDL functions is called.
+ *}
+function SDL_GetAudioDeviceName(index: Integer; iscapture: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDeviceName' {$ENDIF} {$ENDIF};
+
+ {**
+ * Open a specific audio device. Passing in a device name of NULL requests
+ * the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+ *
+ * The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+ * some drivers allow arbitrary and driver-specific strings, such as a
+ * hostname/IP address for a remote audio server, or a filename in the
+ * diskaudio driver.
+ *
+ * 0 on error, a valid device ID that is >= 2 on success.
+ *
+ * SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+ *}
+function SDL_OpenAudioDevice(device: PAnsiChar;
+ iscapture: Integer;
+ desired: PSDL_AudioSpec;
+ obtained: PSDL_AudioSpec;
+ allowed_changes: Integer): TSDL_AudioDeviceID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_OpenAudioDevice' {$ENDIF} {$ENDIF};
+
+ {**
+ * Audio state
+ *
+ * Get the current audio state.
+ *}
+
+type
+ TSDL_AudioStatus = (SDL_AUDIO_STOPPED,SDL_AUDIO_PLAYING,SDL_AUDIO_PAUSED);
+
+function SDL_GetAudioStatus: TSDL_AudioStatus cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioStatus' {$ENDIF} {$ENDIF};
+
+function SDL_GetAudioDeviceStatus(dev: TSDL_AudioDeviceID): TSDL_AudioStatus cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetAudioDeviceStatus' {$ENDIF} {$ENDIF};
+ {*Audio State*}
+
+ {**
+ * Pause audio functions
+ *
+ * These functions pause and unpause the audio callback processing.
+ * They 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.
+ *}
+
+procedure SDL_PauseAudio(pause_on: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PauseAudio' {$ENDIF} {$ENDIF};
+procedure SDL_PauseAudioDevice(dev: TSDL_AudioDeviceID; pause_on: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PauseAudioDevice' {$ENDIF} {$ENDIF};
+ {*Pause audio functions*}
+
+ {**
+ * 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.
+ *}
+function SDL_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadWAV_RW' {$ENDIF} {$ENDIF};
+
+ {**
+ * Loads a WAV from a file.
+ * Compatibility convenience function.
+ *}
+
+ function SDL_LoadWAV(_file: PAnsiChar; spec: PSDL_AudioSpec; audio_buf: PPUInt8; audio_len: PUInt32): PSDL_AudioSpec;
+
+ {**
+ * This function frees data previously allocated with SDL_LoadWAV_RW()
+ *}
+ procedure SDL_FreeWAV(audio_buf: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeWAV' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *
+ * -1 if the format conversion is not supported, 0 if there's
+ * no conversion needed, or 1 if the audio filter is set up.
+ *}
+function SDL_BuildAudioCVT(cvt: PSDL_AudioCVT;
+ src_format: TSDL_AudioFormat;
+ src_channels: UInt8;
+ src_rate: Integer;
+ dst_format: TSDL_AudioFormat;
+ dst_channels: UInt8;
+ dst_rate: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_BuildAudioCVT' {$ENDIF} {$ENDIF};
+
+{**
+ * 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.
+ *}
+function SDL_ConvertAudio(cvt: PSDL_AudioCVT): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertAudio' {$ENDIF} {$ENDIF};
+
+const
+ SDL_MIX_MAXVOLUME = 128;
+
+ {**
+ * 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.
+ *}
+procedure SDL_MixAudio(dst: PUInt8; src: PUInt8; len: UInt32; volume: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MixAudio' {$ENDIF} {$ENDIF};
+
+ {**
+ * This works like SDL_MixAudio(), but you specify the audio format instead of
+ * using the format of audio device 1. Thus it can be used when no audio
+ * device is open at all.
+ *}
+procedure SDL_MixAudioFormat(dst: PUInt8; src: PUInt8; format: TSDL_AudioFormat; len: UInt32; volume: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MixAudioFormat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Audio lock functions
+ *
+ * The lock manipulated by these functions protects the callback function.
+ * During a SDL_LockAudio()/SDL_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.
+ *}
+
+procedure SDL_LockAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockAudio' {$ENDIF} {$ENDIF};
+procedure SDL_LockAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockAudioDevice' {$ENDIF} {$ENDIF};
+procedure SDL_UnlockAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Unlock' {$ENDIF} {$ENDIF};
+procedure SDL_UnlockAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockAudioDevice' {$ENDIF} {$ENDIF};
+ {*Audio lock functions*}
+
+ {**
+ * This function shuts down audio processing and closes the audio device.
+ *}
+procedure SDL_CloseAudio cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CloseAudio' {$ENDIF} {$ENDIF};
+procedure SDL_CloseAudioDevice(dev: TSDL_AudioDeviceID) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CloseAudioDevice' {$ENDIF} {$ENDIF};
+
+ {**
+ * 1 if audio device is still functioning, zero if not, -1 on error.
+ *}
+function SDL_AudioDeviceConnected(dev: TSDL_AudioDeviceID): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AudioDeviceConnected' {$ENDIF} {$ENDIF};
+
--- /dev/null
+//from "sdl_blendmode.h"
+
+{**
+ * The blend mode used in SDL_RenderCopy() and drawing operations.
+ *}
+
+type
+ PSDL_BlendMode = ^TSDL_BlendMode;
+ TSDL_BlendMode = DWord;
+
+const
+ SDL_BLENDMODE_NONE = $00000000; {**< No blending *}
+ SDL_BLENDMODE_BLEND = $00000001; {**< dst = (src * A) + (dst * (1-A)) *}
+ SDL_BLENDMODE_ADD = $00000002; {**< dst = (src * A) + dst *}
+ SDL_BLENDMODE_MOD = $00000004; {**< dst = src * dst *}
--- /dev/null
+//from "sdl_error.h"
+const
+ ERR_MAX_STRLEN = 128;
+ ERR_MAX_ARGS = 5;
+
+ {* Public functions *}
+
+ {* SDL_SetError() unconditionally returns -1. *}
+function SDL_SetError(const fmt: PAnsiChar): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetError' {$ENDIF} {$ENDIF};
+function SDL_GetError: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetError' {$ENDIF} {$ENDIF};
+procedure SDL_ClearError cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ClearError' {$ENDIF} {$ENDIF};
+ {*Internal error functions*}
+ {**
+ * Internal error functions
+ *
+ * Private error reporting function - used internally.
+ *}
+
+ {
+#define SDL_OutOfMemory() SDL_Error(SDL_ENOMEM)
+#define SDL_Unsupported() SDL_Error(SDL_UNSUPPORTED)
+#define SDL_InvalidParamError(param) SDL_SetError("Parameter '%s' is invalid", (param))
+ }
+type
+ TSDL_ErrorCode = (SDL_ENOMEM,
+ SDL_EFREAD,
+ SDL_EFWRITE,
+ SDL_EFSEEK,
+ SDL_UNSUPPORTED,
+ SDL_LASTERROR);
+
+ TSDL_Error = record
+ {* This is a numeric value corresponding to the current error *}
+ error: SInt32;
+
+ {* 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: String[ERR_MAX_STRLEN];
+
+ {* These are the arguments for the error functions *}
+ argc: SInt32;
+ case SInt32 of
+ {* What is a character anyway? (UNICODE issues) *}
+ 0: (value_c: Byte;);
+ 1: (value_ptr: Pointer;);
+ 2: (value_i: SInt32;);
+ 3: (value_f: Double;);
+ 4: (buf: String[ERR_MAX_STRLEN];);
+ end;
+
+ {* SDL_Error() unconditionally returns -1. *}
+function SDL_Error(code: TSDL_ErrorCode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Error' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_events.h"
+
+ {**
+ * The types of events that can be delivered.
+ *}
+
+const
+
+ SDL_FIRSTEVENT = 0; // Unused (do not remove) (needed in pascal?)
+
+ SDL_COMMONEVENT = 1; //added for pascal-compatibility
+
+ { Application events }
+ SDL_QUITEV = $100; // User-requested quit (originally SDL_QUIT, but changed, cause theres a method called SDL_QUIT)
+
+
+ {* These application events have special meaning on iOS, see README.iOS for details *}
+ SDL_APP_TERMINATING = $101; {**< The application is being terminated by the OS
+ Called on iOS in applicationWillTerminate()
+ Called on Android in onDestroy()
+ *}
+ SDL_APP_LOWMEMORY = $102; {**< The application is low on memory, free memory if possible.
+ Called on iOS in applicationDidReceiveMemoryWarning()
+ Called on Android in onLowMemory()
+ *}
+ SDL_APP_WILLENTERBACKGROUND = $103; {**< The application is about to enter the background
+ Called on iOS in applicationWillResignActive()
+ Called on Android in onPause()
+ *}
+ SDL_APP_DIDENTERBACKGROUND = $104; {**< The application did enter the background and may not get CPU for some time
+ Called on iOS in applicationDidEnterBackground()
+ Called on Android in onPause()
+ *}
+ SDL_APP_WILLENTERFOREGROUND = $105; {**< The application is about to enter the foreground
+ Called on iOS in applicationWillEnterForeground()
+ Called on Android in onResume()
+ *}
+ SDL_APP_DIDENTERFOREGROUND = $106; {**< The application is now interactive
+ Called on iOS in applicationDidBecomeActive()
+ Called on Android in onResume()
+ *}
+
+ { Window events }
+ SDL_WINDOWEVENT = $200; // Window state change
+ SDL_SYSWMEVENT = $201; // System specific event
+
+ { Keyboard events }
+ SDL_KEYDOWN = $300; // Key pressed
+ SDL_KEYUP = $301; // Key released
+ SDL_TEXTEDITING = $302; // Keyboard text editing (composition)
+ SDL_TEXTINPUT = $303; // Keyboard text input
+
+ { Mouse events }
+ SDL_MOUSEMOTION = $400; // Mouse moved
+ SDL_MOUSEBUTTONDOWN = $401; // Mouse button pressed
+ SDL_MOUSEBUTTONUP = $402; // Mouse button released
+ SDL_MOUSEWHEEL = $403; // Mouse wheel motion
+
+ { Joystick events }
+ SDL_JOYAXISMOTION = $600; // Joystick axis motion
+ SDL_JOYBALLMOTION = $601; // Joystick trackball motion
+ SDL_JOYHATMOTION = $602; // Joystick hat position change
+ SDL_JOYBUTTONDOWN = $603; // Joystick button pressed
+ SDL_JOYBUTTONUP = $604; // Joystick button released
+ SDL_JOYDEVICEADDED = $605; // A new joystick has been inserted into the system
+ SDL_JOYDEVICEREMOVED = $606; // An opened joystick has been removed
+
+ { Game controller events }
+ SDL_CONTROLLERAXISMOTION = $650; // Game controller axis motion
+ SDL_CONTROLLERBUTTONDOWN = $651; // Game controller button pressed
+ SDL_CONTROLLERBUTTONUP = $652; // Game controller button released
+ SDL_CONTROLLERDEVICEADDED = $653; // A new Game controller has been inserted into the system
+ SDL_CONTROLLERDEVICEREMOVED = $654; // An opened Game controller has been removed
+ SDL_CONTROLLERDEVICEREMAPPED = $655; // The controller mapping was updated
+
+ { Touch events }
+ SDL_FINGERDOWN = $700;
+ SDL_FINGERUP = $701;
+ SDL_FINGERMOTION = $702;
+
+ { Gesture events }
+ SDL_DOLLARGESTURE = $800;
+ SDL_DOLLARRECORD = $801;
+ SDL_MULTIGESTURE = $802;
+
+ { Clipboard events }
+ SDL_CLIPBOARDUPDATE = $900; // The clipboard changed
+
+ { Drag and drop events }
+ SDL_DROPFILE = $1000; // The system requests a file open
+
+ {** Events SDL_USEREVENT through SDL_LASTEVENT are for your use,
+ * and should be allocated with SDL_RegisterEvents()
+ *}
+ SDL_USEREVENT = $8000;
+
+ {**
+ * This last event is only for bounding internal arrays (needed in pascal ??)
+ *}
+ SDL_LASTEVENT = $FFFF;
+
+type
+
+ TSDL_EventType = Word;
+
+ {**
+ * Fields shared by every event
+ *}
+
+ TSDL_CommonEvent = record
+ type_: UInt32;
+ timestamp: UInt32;
+ end;
+
+ {**
+ * Window state change event data (event.window.*)
+ *}
+
+ TSDL_WindowEvent = record
+ type_: UInt32; // SDL_WINDOWEVENT
+ timestamp: UInt32;
+ windowID: UInt32; // The associated window
+ event: UInt8; // SDL_WindowEventID
+ padding1: UInt8;
+ padding2: UInt8;
+ padding3: UInt8;
+ data1: SInt32; // event dependent data
+ data2: SInt32; // event dependent data
+ end;
+
+ {**
+ * Keyboard button event structure (event.key.*)
+ *}
+ TSDL_KeyboardEvent = record
+ type_: UInt32; // SDL_KEYDOWN or SDL_KEYUP
+ timestamp: UInt32;
+ windowID: UInt32; // The window with keyboard focus, if any
+ state: UInt8; // SDL_PRESSED or SDL_RELEASED
+ _repeat: UInt8; // Non-zero if this is a key repeat
+ padding2: UInt8;
+ padding3: UInt8;
+ keysym: TSDL_KeySym; // The key that was pressed or released
+ end;
+
+const
+ SDL_TEXTEDITINGEVENT_TEXT_SIZE = 32;
+
+type
+
+ {**
+ * Keyboard text editing event structure (event.edit.*)
+ *}
+
+ TSDL_TextEditingEvent = record
+ type_: UInt32; // SDL_TEXTEDITING
+ timestamp: UInt32;
+ windowID: UInt32; // The window with keyboard focus, if any
+ text: array[0..SDL_TEXTEDITINGEVENT_TEXT_SIZE] of Char; // The editing text
+ start: SInt32; // The start cursor of selected editing text
+ length: SInt32; // The length of selected editing text
+ end;
+
+const
+ SDL_TEXTINPUTEVENT_TEXT_SIZE = 32;
+
+type
+
+ {**
+ * Keyboard text input event structure (event.text.*)
+ *}
+
+ TSDL_TextInputEvent = record
+ type_: UInt32; // SDL_TEXTINPUT
+ timestamp: UInt32;
+ windowID: UInt32; // The window with keyboard focus, if any
+ text: array[0..SDL_TEXTINPUTEVENT_TEXT_SIZE] of Char; // The input text
+ end;
+
+ {**
+ * Mouse motion event structure (event.motion.*)
+ *}
+
+ TSDL_MouseMotionEvent = record
+ type_: UInt32; // SDL_MOUSEMOTION
+ timestamp: UInt32;
+ windowID: UInt32; // The window with mouse focus, if any
+ which: UInt32; // The mouse instance id, or SDL_TOUCH_MOUSEID
+ state: UInt8; // The current button state
+ padding1: UInt8;
+ padding2: UInt8;
+ padding3: UInt8;
+ x: SInt32; // X coordinate, relative to window
+ y: SInt32; // Y coordinate, relative to window
+ xrel: SInt32; // The relative motion in the X direction
+ yrel: SInt32; // The relative motion in the Y direction
+ end;
+
+ {**
+ * Mouse button event structure (event.button.*)
+ *}
+
+ TSDL_MouseButtonEvent = record
+ type_: UInt32; // SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP
+ timestamp: UInt32;
+ windowID: UInt32; // The window with mouse focus, if any
+ which: UInt32; // The mouse instance id, or SDL_TOUCH_MOUSEID
+ button: UInt8; // The mouse button index
+ state: UInt8; // SDL_PRESSED or SDL_RELEASED
+ padding1: UInt8;
+ padding2: UInt8;
+ x: SInt32; // X coordinate, relative to window
+ y: SInt32; // Y coordinate, relative to window
+ end;
+
+ {**
+ * Mouse wheel event structure (event.wheel.*)
+ *}
+
+ TSDL_MouseWheelEvent = record
+ type_: UInt32; // SDL_MOUSEWHEEL
+ timestamp: UInt32;
+ windowID: UInt32; // The window with mouse focus, if any
+ which: UInt32; // The mouse instance id, or SDL_TOUCH_MOUSEID
+ x: SInt32; // The amount scrolled horizontally
+ y: SInt32; // The amount scrolled vertically
+ end;
+
+ {**
+ * Joystick axis motion event structure (event.jaxis.*)
+ *}
+
+ TSDL_JoyAxisEvent = record
+ type_: UInt32; // SDL_JOYAXISMOTION
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ axis: UInt8; // The joystick axis index
+ padding1: UInt8;
+ padding2: UInt8;
+ padding3: UInt8;
+ value: SInt16; // The axis value (range: -32768 to 32767)
+ padding4: UInt16;
+ end;
+
+ {**
+ * Joystick trackball motion event structure (event.jball.*)
+ *}
+
+ TSDL_JoyBallEvent = record
+ type_: UInt32; // SDL_JOYBALLMOTION
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ ball: UInt8; // The joystick trackball index
+ padding1: UInt8;
+ padding2: UInt8;
+ padding3: UInt8;
+ xrel: SInt16; // The relative motion in the X direction
+ yrel: SInt16; // The relative motion in the Y direction
+ end;
+
+ {**
+ * Joystick hat position change event structure (event.jhat.*)
+ *}
+
+ TSDL_JoyHatEvent = record
+ type_: UInt32; // SDL_JOYHATMOTION
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ hat: UInt8; // The joystick hat index
+ value: UInt8; {* The hat position value.
+ * SDL_HAT_LEFTUP SDL_HAT_UP SDL_HAT_RIGHTUP
+ * SDL_HAT_LEFT SDL_HAT_CENTERED SDL_HAT_RIGHT
+ * SDL_HAT_LEFTDOWN SDL_HAT_DOWN SDL_HAT_RIGHTDOWN
+ *
+ * Note that zero means the POV is centered.
+ *}
+ padding1: UInt8;
+ padding2: UInt8;
+ end;
+
+ {**
+ * Joystick button event structure (event.jbutton.*)
+ *}
+
+ TSDL_JoyButtonEvent = record
+ type_: UInt32; // SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ button: UInt8; // The joystick button index
+ state: UInt8; // SDL_PRESSED or SDL_RELEASED
+ padding1: UInt8;
+ padding2: UInt8;
+ end;
+
+ {**
+ * Joystick device event structure (event.jdevice.*)
+ *}
+
+ TSDL_JoyDeviceEvent = record
+ type_: UInt32; // SDL_JOYDEVICEADDED or SDL_JOYDEVICEREMOVED
+ timestamp: UInt32;
+ which: SInt32; // The joystick device index for the ADDED event, instance id for the REMOVED event
+ end;
+
+ {**
+ * Game controller axis motion event structure (event.caxis.*)
+ *}
+
+ TSDL_ControllerAxisEvent = record
+ type_: UInt32; // SDL_CONTROLLERAXISMOTION
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ axis: UInt8; // The controller axis (SDL_GameControllerAxis)
+ padding1: UInt8;
+ padding2: UInt8;
+ padding3: UInt8;
+ value: SInt16; // The axis value (range: -32768 to 32767)
+ padding4: UInt16;
+ end;
+
+ {**
+ * Game controller button event structure (event.cbutton.*)
+ *}
+
+ TSDL_ControllerButtonEvent = record
+ type_: UInt32; // SDL_CONTROLLERBUTTONDOWN or SDL_CONTROLLERBUTTONUP
+ timestamp: UInt32;
+ which: TSDL_JoystickID; // The joystick instance id
+ button: UInt8; // The controller button (SDL_GameControllerButton)
+ state: UInt8; // SDL_PRESSED or SDL_RELEASED
+ padding1: UInt8;
+ padding2: UInt8;
+ end;
+
+
+ {**
+ * Controller device event structure (event.cdevice.*)
+ *}
+
+ TSDL_ControllerDeviceEvent = record
+ type_: UInt32; // SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, or SDL_CONTROLLERDEVICEREMAPPED
+ timestamp: UInt32;
+ which: SInt32; // The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event
+ end;
+
+ {**
+ * Touch finger event structure (event.tfinger.*)
+ *}
+
+ TSDL_TouchFingerEvent = record
+ type_: UInt32; // SDL_FINGERMOTION or SDL_FINGERDOWN or SDL_FINGERUP
+ timestamp: UInt32;
+ touchId: TSDL_TouchID; // The touch device id
+ fingerId: TSDL_FingerID;
+ x: Float; // Normalized in the range 0...1
+ y: Float; // Normalized in the range 0...1
+ dx: Float; // Normalized in the range 0...1
+ dy: Float; // Normalized in the range 0...1
+ pressure: Float; // Normalized in the range 0...1
+ end;
+
+ {**
+ * Multiple Finger Gesture Event (event.mgesture.*)
+ *}
+ TSDL_MultiGestureEvent = record
+ type_: UInt32; // SDL_MULTIGESTURE
+ timestamp: UInt32;
+ touchId: TSDL_TouchID; // The touch device index
+ dTheta: Float;
+ dDist: Float;
+ x: Float;
+ y: Float;
+ numFingers: UInt16;
+ padding: UInt16;
+ end;
+
+
+ {* (event.dgesture.*) *}
+ TSDL_DollarGestureEvent = record
+ type_: UInt32; // SDL_DOLLARGESTURE
+ timestamp: UInt32;
+ touchId: TSDL_TouchID; // The touch device id
+ gestureId: TSDL_GestureID;
+ numFingers: UInt32;
+ error: Float;
+ x: Float; // Normalized center of gesture
+ y: Float; // Normalized center of gesture
+ end;
+
+
+ {**
+ * An event used to request a file open by the system (event.drop.*)
+ * This event is disabled by default, you can enable it with SDL_EventState()
+ * If you enable this event, you must free the filename in the event.
+ *}
+
+ TSDL_DropEvent = record
+ type_: UInt32; // SDL_DROPFILE
+ timestamp: UInt32;
+ _file: PAnsiChar; // The file name, which should be freed with SDL_free()
+ end;
+
+ {**
+ * The "quit requested" event
+ *}
+
+ TSDL_QuitEvent = record
+ type_: UInt32; // SDL_QUIT
+ timestamp: UInt32;
+ end;
+
+ {**
+ * A user-defined event type (event.user.*)
+ *}
+
+ TSDL_UserEvent = record
+ type_: UInt32; // SDL_USEREVENT through SDL_NUMEVENTS-1
+ timestamp: UInt32;
+ windowID: UInt32; // The associated window if any
+ code: SInt32; // User defined event code
+ data1: Pointer; // User defined data pointer
+ data2: Pointer; // User defined data pointer
+ end;
+
+ {$IFDEF Unix}
+ //These are the various supported subsystems under UNIX
+ TSDL_SysWm = ( SDL_SYSWM_X11 ) ;
+ {$ENDIF}
+
+ // The windows custom event structure
+ {$IFDEF Windows}
+ PSDL_SysWMmsg = ^TSDL_SysWMmsg;
+ TSDL_SysWMmsg = record
+ version: TSDL_Version;
+ h_wnd: HWND; // The window for the message
+ msg: UInt32; // The type of message
+ w_Param: WPARAM; // WORD message parameter
+ lParam: LPARAM; // LONG message parameter
+ end;
+ {$ELSE}
+
+ {$IFDEF Unix}
+ { The Linux custom event structure }
+ PSDL_SysWMmsg = ^TSDL_SysWMmsg;
+ TSDL_SysWMmsg = record
+ version : TSDL_Version;
+ subsystem : TSDL_SysWm;
+ {$IFDEF FPC}
+ {$IFNDEF DARWIN}
+ event : TXEvent;
+ {$ENDIF}
+ {$ELSE}
+ event : XEvent;
+ {$ENDIF}
+ end;
+ {$ELSE}
+ { The generic custom event structure }
+ PSDL_SysWMmsg = ^TSDL_SysWMmsg;
+ TSDL_SysWMmsg = record
+ version: TSDL_Version;
+ data: Integer;
+ end;
+ {$ENDIF}
+
+ {$ENDIF}
+
+ // The Windows custom window manager information structure
+ {$IFDEF Windows}
+ PSDL_SysWMinfo = ^TSDL_SysWMinfo;
+ TSDL_SysWMinfo = record
+ version : TSDL_Version;
+ window : HWnd; // The display window
+ end;
+ {$ELSE}
+ // The Linux custom window manager information structure
+ {$IFDEF Unix}
+ {$IFNDEF DARWIN}
+ TX11 = record
+ 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 */
+ end;
+ {$ENDIF}
+
+ PSDL_SysWMinfo = ^TSDL_SysWMinfo;
+ TSDL_SysWMinfo = record
+ version : TSDL_Version;
+ subsystem : TSDL_SysWm;
+ {$IFNDEF DARWIN}
+ X11 : TX11;
+ {$ENDIF}
+ end;
+ {$ELSE}
+ // The generic custom window manager information structure
+ PSDL_SysWMinfo = ^TSDL_SysWMinfo;
+ TSDL_SysWMinfo = record
+ version : TSDL_Version;
+ data : integer;
+ end;
+ {$ENDIF}
+
+ {$ENDIF}
+
+ {**
+ * A video driver dependent system event (event.syswm.*)
+ * This event is disabled by default, you can enable it with SDL_EventState()
+ *
+ * If you want to use this event, you should include SDL_syswm.h.
+ *}
+
+ PSDL_SysWMEvent = ^TSDL_SysWMEvent;
+ TSDL_SysWMEvent = record
+ type_: UInt32; // SDL_SYSWMEVENT
+ timestamp: UInt32;
+ msg: PSDL_SysWMmsg; // driver dependent data (defined in SDL_syswm.h)
+ end;
+
+ {**
+ * General event structure
+ *}
+
+ PSDL_Event = ^TSDL_Event;
+ TSDL_Event = record
+ case Integer of
+ 0: (type_: UInt32);
+
+ SDL_COMMONEVENT: (common: TSDL_CommonEvent);
+ SDL_WINDOWEVENT: (window: TSDL_WindowEvent);
+
+ SDL_KEYUP,
+ SDL_KEYDOWN: (key: TSDL_KeyboardEvent);
+ SDL_TEXTEDITING: (edit: TSDL_TextEditingEvent);
+ SDL_TEXTINPUT: (text: TSDL_TextInputEvent);
+
+ SDL_MOUSEMOTION: (motion: TSDL_MouseMotionEvent);
+ SDL_MOUSEBUTTONUP,
+ SDL_MOUSEBUTTONDOWN: (button: TSDL_MouseButtonEvent);
+ SDL_MOUSEWHEEL: (wheel: TSDL_MouseWheelEvent);
+
+ SDL_JOYAXISMOTION: (jaxis: TSDL_JoyAxisEvent);
+ SDL_JOYBALLMOTION: (jball: TSDL_JoyBallEvent);
+ SDL_JOYHATMOTION: (jhat: TSDL_JoyHatEvent);
+ SDL_JOYBUTTONDOWN,
+ SDL_JOYBUTTONUP: (jbutton: TSDL_JoyButtonEvent);
+ SDL_JOYDEVICEADDED,
+ SDL_JOYDEVICEREMOVED: (jdevice: TSDL_JoyDeviceEvent);
+
+ SDL_CONTROLLERAXISMOTION: (caxis: TSDL_ControllerAxisEvent);
+ SDL_CONTROLLERBUTTONUP,
+ SDL_CONTROLLERBUTTONDOWN: (cbutton: TSDL_ControllerButtonEvent);
+ SDL_CONTROLLERDEVICEADDED,
+ SDL_CONTROLLERDEVICEREMOVED,
+ SDL_CONTROLLERDEVICEREMAPPED: (cdevice: TSDL_ControllerDeviceEvent);
+
+ SDL_QUITEV: (quit: TSDL_QuitEvent);
+
+ SDL_USEREVENT: (user: TSDL_UserEvent);
+ SDL_SYSWMEVENT: (syswm: TSDL_SysWMEvent);
+
+ SDL_FINGERDOWN,
+ SDL_FINGERUP,
+ SDL_FINGERMOTION: (tfinger: TSDL_TouchFingerEvent);
+ SDL_MULTIGESTURE: (mgesture: TSDL_MultiGestureEvent);
+ SDL_DOLLARGESTURE,SDL_DOLLARRECORD: (dgesture: TSDL_DollarGestureEvent);
+
+ SDL_DROPFILE: (drop: TSDL_DropEvent);
+ end;
+
+
+ {* Function prototypes *}
+
+ {**
+ * 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.
+ *}
+ procedure SDL_PumpEvents cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PumpEvents' {$ENDIF} {$ENDIF};
+
+const
+ SDL_ADDEVENT = 0;
+ SDL_PEEKEVENT = 1;
+ SDL_GETEVENT = 2;
+
+type
+ TSDL_EventAction = Word;
+
+ {**
+ * 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, within the specified minimum and maximum type,
+ * 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, within the specified minimum and maximum type,
+ * will be returned and will be removed from the queue.
+ *
+ * Result: The number of events actually stored, or -1 if there was an error.
+ *
+ * This function is thread-safe.
+ *}
+
+ function SDL_PeepEvents(events: PSDL_Event; numevents: SInt32; action: TSDL_EventAction; minType: UInt32; maxType: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PeepEvents' {$ENDIF} {$ENDIF};
+
+ {**
+ * Checks to see if certain event types are in the event queue.
+ *}
+
+ function SDL_HasEvent(type_: UInt32): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasEvent' {$ENDIF} {$ENDIF};
+ function SDL_HasEvents(minType: UInt32; maxType: UInt32): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasEvents' {$ENDIF} {$ENDIF};
+
+ {**
+ * This function clears events from the event queue
+ *}
+
+ procedure SDL_FlushEvent(type_: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FlushEvent' {$ENDIF} {$ENDIF};
+ procedure SDL_FlushEvents(minType: UInt32; maxType: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FlushEvents' {$ENDIF} {$ENDIF};
+
+ {**
+ * Polls for currently pending events.
+ *
+ * 1 if there are any pending events, or 0 if there are none available.
+ *
+ * event - If not nil, the next event is removed from the queue and
+ * stored in that area.
+ *}
+
+ function SDL_PollEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PollEvent' {$ENDIF} {$ENDIF};
+
+ {**
+ * Waits indefinitely for the next available event.
+ *
+ * 1, or 0 if there was an error while waiting for events.
+ *
+ * event - If not nil, the next event is removed from the queue and
+ * stored in that area.
+ *}
+
+ function SDL_WaitEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitEvent' {$ENDIF} {$ENDIF};
+
+ {**
+ * Waits until the specified timeout (in milliseconds) for the next
+ * available event.
+ *
+ * 1, or 0 if there was an error while waiting for events.
+ *
+ * event - If not nil, the next event is removed from the queue and
+ * stored in that area.
+ *}
+
+ function SDL_WaitEventTimeout(event: PSDL_Event; timeout: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitEventTimeout' {$ENDIF} {$ENDIF};
+
+ {**
+ * Add an event to the event queue.
+ *
+ * 1 on success, 0 if the event was filtered, or -1 if the event queue
+ * was full or there was some other error.
+ *}
+
+ function SDL_PushEvent(event: PSDL_Event): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PumpEvents' {$ENDIF} {$ENDIF};
+
+type
+ PSDL_EventFilter = ^TSDL_EventFilter;
+ {$IFNDEF GPC}
+ TSDL_EventFilter = function( event: PSDL_Event ): Integer; cdecl;
+ {$ELSE}
+ TSDL_EventFilter = function( event: PSDL_Event ): Integer;
+ {$ENDIF}
+
+ {**
+ * Sets up a filter to process all events before they change internal state and
+ * are posted to the internal event queue.
+ *
+ * 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.
+ *
+ * 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.
+ *}
+
+ procedure SDL_SetEventFilter(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetEventFilter' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return the current event filter - can be used to "chain" filters.
+ * If there is no event filter set, this function returns SDL_FALSE.
+ *}
+
+ function SDL_GetEventFilter(filter: PSDL_EventFilter; userdata: Pointer): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetEventFilter' {$ENDIF} {$ENDIF};
+
+ {**
+ * Add a function which is called when an event is added to the queue.
+ *}
+
+ procedure SDL_AddEventWatch(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AddEventWatch' {$ENDIF} {$ENDIF};
+
+ {**
+ * Remove an event watch function added with SDL_AddEventWatch()
+ *}
+
+ procedure SDL_DelEventWatch(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DelEventWatch' {$ENDIF} {$ENDIF};
+
+ {**
+ * Run the filter function on the current event queue, removing any
+ * events for which the filter returns 0.
+ *}
+
+ procedure SDL_FilterEvents(filter: TSDL_EventFilter; userdata: Pointer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FilterEvents' {$ENDIF} {$ENDIF};
+
+const
+
+ SDL_QUERY = -1;
+ SDL_IGNORE = 0;
+ SDL_DISABLE = 0;
+ SDL_ENABLE = 1;
+
+ {**
+ * 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.
+ *}
+
+ function SDL_EventState(type_: UInt32; state: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_EventState' {$ENDIF} {$ENDIF};
+
+ function SDL_GetEventState(type_: UInt32): UInt8;
+
+ {**
+ * This function allocates a set of user-defined events, and returns
+ * the beginning event number for that set of events.
+ *
+ * If there aren't enough user-defined events left, this function
+ * returns (Uint32)-1
+ *}
+
+ function SDL_RegisterEvents(numevents: SInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RegisterEvents' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_gesture.h"
+
+type
+ TSDL_GestureID = SInt64;
+
+ {* Function prototypes *}
+
+ {**
+ * Begin Recording a gesture on the specified touch, or all touches (-1)
+ *
+ *
+ *}
+function SDL_RecordGesture(touchId: TSDL_TouchID): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RecordGesture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Save all currently loaded Dollar Gesture templates
+ *
+ *
+ *}
+function SDL_SaveAllDollarTemplates(src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SaveAllDollarTemplates' {$ENDIF} {$ENDIF};
+
+ {**
+ * Save a currently loaded Dollar Gesture template
+ *
+ *
+ *}
+function SDL_SaveDollarTemplate(gestureId: TSDL_GestureID; src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SaveDollarTemplate' {$ENDIF} {$ENDIF};
+
+
+ {**
+ * Load Dollar Gesture templates from a file
+ *
+ *
+ *}
+function SDL_LoadDollarTemplates(touchId: TSDL_TouchID; src: PSDL_RWops): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadDollarTemplates' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_haptic.h"
+
+{**
+ *
+ * The SDL Haptic subsystem allows you to control haptic (force feedback)
+ * devices.
+ *
+ * The basic usage is as follows:
+ * - Initialize the Subsystem (::SDL_INIT_HAPTIC).
+ * - Open a Haptic Device.
+ * - SDL_HapticOpen() to open from index.
+ * - SDL_HapticOpenFromJoystick() to open from an existing joystick.
+ * - Create an effect (::SDL_HapticEffect).
+ * - Upload the effect with SDL_HapticNewEffect().
+ * - Run the effect with SDL_HapticRunEffect().
+ * - (optional) Free the effect with SDL_HapticDestroyEffect().
+ * - Close the haptic device with SDL_HapticClose().
+ *
+ * Simple rumble example:
+ *
+ * SDL_Haptic *haptic;
+ *
+ * // Open the device
+ * haptic = SDL_HapticOpen( 0 );
+ * if (haptic == NULL)
+ * return -1;
+ *
+ * // Initialize simple rumble
+ * if (SDL_HapticRumbleInit( haptic ) != 0)
+ * return -1;
+ *
+ * // Play effect at 50% strength for 2 seconds
+ * if (SDL_HapticRumblePlay( haptic, 0.5, 2000 ) != 0)
+ * return -1;
+ * SDL_Delay( 2000 );
+ *
+ * // Clean up
+ * SDL_HapticClose( haptic );
+ *
+ *
+ * Complete example:
+ *
+ * int test_haptic( SDL_Joystick * joystick )
+ * SDL_Haptic *haptic;
+ * SDL_HapticEffect effect;
+ * int effect_id;
+ *
+ * // Open the device
+ * haptic = SDL_HapticOpenFromJoystick( joystick );
+ * if (haptic == NULL) return -1; // Most likely joystick isn't haptic
+ *
+ * // See if it can do sine waves
+ * if ((SDL_HapticQuery(haptic) & SDL_HAPTIC_SINE)==0)
+ * SDL_HapticClose(haptic); // No sine effect
+ * return -1;
+ *
+ *
+ * // Create the effect
+ * memset( &effect, 0, sizeof(SDL_HapticEffect) ); // 0 is safe default
+ * effect.type = SDL_HAPTIC_SINE;
+ * effect.periodic.direction.type = SDL_HAPTIC_POLAR; // Polar coordinates
+ * effect.periodic.direction.dir[0] = 18000; // Force comes from south
+ * effect.periodic.period = 1000; // 1000 ms
+ * effect.periodic.magnitude = 20000; // 20000/32767 strength
+ * effect.periodic.length = 5000; // 5 seconds long
+ * effect.periodic.attack_length = 1000; // Takes 1 second to get max strength
+ * effect.periodic.fade_length = 1000; // Takes 1 second to fade away
+ *
+ * // Upload the effect
+ * effect_id = SDL_HapticNewEffect( haptic, &effect );
+ *
+ * // Test the effect
+ * SDL_HapticRunEffect( haptic, effect_id, 1 );
+ * SDL_Delay( 5000); // Wait for the effect to finish
+ *
+ * // We destroy the effect, although closing the device also does this
+ * SDL_HapticDestroyEffect( haptic, effect_id );
+ *
+ * // Close the device
+ * SDL_HapticClose(haptic);
+ *
+ * return 0; // Success
+ *
+ *
+ *
+ * You can also find out more information on my blog:
+ * http://bobbens.dyndns.org/journal/2010/sdl_haptic/
+ *
+ * Edgar Simo Serra
+ *}
+
+{$I jedi.inc}
+
+ {**
+ * SDL_Haptic
+ *
+ * The haptic structure used to identify an SDL haptic.
+ *
+ * SDL_HapticOpen
+ * SDL_HapticOpenFromJoystick
+ * SDL_HapticClose
+ *}
+type
+ PSDL_Haptic = ^TSDL_Haptic;
+ TSDL_Haptic = record end;
+
+ {**
+ * Haptic features
+ *
+ * Different haptic features a device can have.
+ *}
+
+ {**
+ * Haptic effects
+ *}
+
+ {**
+ * Constant effect supported.
+ *
+ * Constant haptic effect.
+ *
+ * SDL_HapticCondition
+ *}
+const
+ SDL_HAPTIC_CONSTANT = (1 shl 0);
+
+ {**
+ * Sine wave effect supported.
+ *
+ * Periodic haptic effect that simulates sine waves.
+ *
+ * SDL_HapticPeriodic
+ *}
+const
+ SDL_HAPTIC_SINE = (1 shl 1);
+
+ {**
+ * Square wave effect supported.
+ *
+ * Periodic haptic effect that simulates square waves.
+ *
+ * SDL_HapticPeriodic
+ *}
+const
+ SDL_HAPTIC_SQUARE = (1 shl 2);
+
+ {**
+ * Triangle wave effect supported.
+ *
+ * Periodic haptic effect that simulates triangular waves.
+ *
+ * SDL_HapticPeriodic
+ *}
+const
+ SDL_HAPTIC_TRIANGLE = (1 shl 3);
+
+ {**
+ * Sawtoothup wave effect supported.
+ *
+ * Periodic haptic effect that simulates saw tooth up waves.
+ *
+ * SDL_HapticPeriodic
+ *}
+const
+ SDL_HAPTIC_SAWTOOTHUP = (1 shl 4);
+
+ {**
+ * Sawtoothdown wave effect supported.
+ *
+ * Periodic haptic effect that simulates saw tooth down waves.
+ *
+ * SDL_HapticPeriodic
+ *}
+const
+ SDL_HAPTIC_SAWTOOTHDOWN = (1 shl 5);
+
+ {**
+ * Ramp effect supported.
+ *
+ * Ramp haptic effect.
+ *
+ * SDL_HapticRamp
+ *}
+const
+ SDL_HAPTIC_RAMP = (1 shl 6);
+
+ {**
+ * Spring effect supported - uses axes position.
+ *
+ * Condition haptic effect that simulates a spring. Effect is based on the
+ * axes position.
+ *
+ * SDL_HapticCondition
+ *}
+const
+ SDL_HAPTIC_SPRING = (1 shl 7);
+
+ {**
+ * Damper effect supported - uses axes velocity.
+ *
+ * Condition haptic effect that simulates dampening. Effect is based on the
+ * axes velocity.
+ *
+ * SDL_HapticCondition
+ *}
+const
+ SDL_HAPTIC_DAMPER = (1 shl 8);
+
+ {**
+ * Inertia effect supported - uses axes acceleration.
+ *
+ * Condition haptic effect that simulates inertia. Effect is based on the axes
+ * acceleration.
+ *
+ * SDL_HapticCondition
+ *}
+const
+ SDL_HAPTIC_INERTIA = (1 shl 9);
+
+ {**
+ * Friction effect supported - uses axes movement.
+ *
+ * Condition haptic effect that simulates friction. Effect is based on the
+ * axes movement.
+ *
+ * SDL_HapticCondition
+ *}
+const
+ SDL_HAPTIC_FRICTION = (1 shl 10);
+
+ {**
+ * Custom effect is supported.
+ *
+ * User defined custom haptic effect.
+ *}
+const
+ SDL_HAPTIC_CUSTOM = (1 shl 11);
+
+ {*Haptic effects*}
+
+ {* These last few are features the device has, not effects *}
+
+ {**
+ * Device can set global gain.
+ *
+ * Device supports setting the global gain.
+ *
+ * SDL_HapticSetGain
+ *}
+const
+ SDL_HAPTIC_GAIN = (1 shl 12);
+
+ {**
+ * Device can set autocenter.
+ *
+ * Device supports setting autocenter.
+ *
+ * SDL_HapticSetAutocenter
+ *}
+const
+ SDL_HAPTIC_AUTOCENTER = (1 shl 13);
+
+ {**
+ * Device can be queried for effect status.
+ *
+ * Device can be queried for effect status.
+ *
+ * SDL_HapticGetEffectStatus
+ *}
+const
+ SDL_HAPTIC_STATUS = (1 shl 14);
+
+ {**
+ * Device can be paused.
+ *
+ * SDL_HapticPause
+ * SDL_HapticUnpause
+ *}
+const
+ SDL_HAPTIC_PAUSE = (1 shl 15);
+
+ {**
+ * Direction encodings
+ *}
+
+ {**
+ * Uses polar coordinates for the direction.
+ *
+ * SDL_HapticDirection
+ *}
+const
+ SDL_HAPTIC_POLAR = 0;
+
+ {**
+ * Uses cartesian coordinates for the direction.
+ *
+ * SDL_HapticDirection
+ *}
+const
+ SDL_HAPTIC_CARTESIAN = 1;
+
+ {**
+ * Uses spherical coordinates for the direction.
+ *
+ * SDL_HapticDirection
+ *}
+const
+ SDL_HAPTIC_SPHERICAL = 2;
+
+ {*Direction encodings*}
+
+ {*Haptic features*}
+
+ {*
+ * Misc defines.
+ *}
+
+ {**
+ * Used to play a device an infinite number of times.
+ *
+ * SDL_HapticRunEffect
+ *}
+const
+ //SDL_HAPTIC_INFINITY = 4294967295U;
+ SDL_HAPTIC_INFINITY = 4294967295; //right?!
+
+ {**
+ * Structure that represents a haptic direction.
+ *
+ * Directions can be specified by:
+ * - SDL_HAPTIC_POLAR : Specified by polar coordinates.
+ * - SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.
+ * - SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.
+ *
+ * Cardinal directions of the haptic device are relative to the positioning
+ * of the device. North is considered to be away from the user.
+ *
+ * The following diagram represents the cardinal directions:
+ *
+ .--.
+ |__| .-------.
+ |=.| |.-----.|
+ |--| || ||
+ | | |'-----'|
+ |__|~')_____('
+ [ COMPUTER ]
+
+
+ North (0,-1)
+ ^
+ |
+ |
+ (1,0) West <----[ HAPTIC ]----> East (-1,0)
+ |
+ |
+ v
+ South (0,1)
+
+
+ [ USER ]
+ \|||/
+ (o o)
+ ---ooO-(_)-Ooo---
+
+ *
+ * If type is SDL_HAPTIC_POLAR, direction is encoded by hundredths of a
+ * degree starting north and turning clockwise. ::SDL_HAPTIC_POLAR only uses
+ * the first dir parameter. The cardinal directions would be:
+ * - North: 0 (0 degrees)
+ * - East: 9000 (90 degrees)
+ * - South: 18000 (180 degrees)
+ * - West: 27000 (270 degrees)
+ *
+ * If type is SDL_HAPTIC_CARTESIAN, direction is encoded by three positions
+ * (X axis, Y axis and Z axis (with 3 axes)). ::SDL_HAPTIC_CARTESIAN uses
+ * the first three dir parameters. The cardinal directions would be:
+ * - North: 0,-1, 0
+ * - East: -1, 0, 0
+ * - South: 0, 1, 0
+ * - West: 1, 0, 0
+ *
+ * The Z axis represents the height of the effect if supported, otherwise
+ * it's unused. In cartesian encoding (1, 2) would be the same as (2, 4), you
+ * can use any multiple you want, only the direction matters.
+ *
+ * If type is SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations.
+ * The first two dir parameters are used. The dir parameters are as
+ * follows (all values are in hundredths of degrees):
+ * - Degrees from (1, 0) rotated towards (0, 1).
+ * - Degrees towards (0, 0, 1) (device needs at least 3 axes).
+ *
+ *
+ * Example of force coming from the south with all encodings (force coming
+ * from the south means the user will have to pull the stick to counteract):
+ *
+ * SDL_HapticDirection direction;
+ *
+ * // Cartesian directions
+ * direction.type = SDL_HAPTIC_CARTESIAN; // Using cartesian direction encoding.
+ * direction.dir[0] = 0; // X position
+ * direction.dir[1] = 1; // Y position
+ * // Assuming the device has 2 axes, we don't need to specify third parameter.
+ *
+ * // Polar directions
+ * direction.type = SDL_HAPTIC_POLAR; // We'll be using polar direction encoding.
+ * direction.dir[0] = 18000; // Polar only uses first parameter
+ *
+ * // Spherical coordinates
+ * direction.type = SDL_HAPTIC_SPHERICAL; // Spherical encoding
+ * direction.dir[0] = 9000; // Since we only have two axes we don't need more parameters.
+ *
+ *
+ * SDL_HAPTIC_POLAR
+ * SDL_HAPTIC_CARTESIAN
+ * SDL_HAPTIC_SPHERICAL
+ * SDL_HapticEffect
+ * SDL_HapticNumAxes
+ *}
+type
+ TSDL_HapticDirection = record
+ _type: UInt8; {**< The type of encoding. *}
+ dir: array[0..2] of SInt32; {**< The encoded direction. *}
+ end;
+
+ {**
+ * A structure containing a template for a Constant effect.
+ *
+ * The struct is exclusive to the ::SDL_HAPTIC_CONSTANT effect.
+ *
+ * A constant effect applies a constant force in the specified direction
+ * to the joystick.
+ *
+ * SDL_HAPTIC_CONSTANT
+ * SDL_HapticEffect
+ *}
+type
+ TSDL_HapticConstant = record
+ {* Header *}
+ _type: UInt16; {**< SDL_HAPTIC_CONSTANT *}
+ direction: TSDL_HapticDirection; {**< Direction of the effect. *}
+
+ {* Replay *}
+ length: UInt32; {**< Duration of the effect. *}
+ delay: UInt16; {**< Delay before starting the effect. *}
+
+ {* Trigger *}
+ button: UInt16; {**< Button that triggers the effect. *}
+ interval: UInt16; {**< How soon it can be triggered again after button. *}
+
+ {* Constant *}
+ level: SInt16; {**< Strength of the constant effect. *}
+
+ {* Envelope *}
+ attack_length: UInt16; {**< Duration of the attack. *}
+ attack_level: UInt16; {**< Level at the start of the attack. *}
+ fade_length: UInt16; {**< Duration of the fade. *}
+ fade_level: UInt16; {**< Level at the end of the fade. *}
+ end;
+
+ {**
+ * A structure containing a template for a Periodic effect.
+ *
+ * The struct handles the following effects:
+ * - SDL_HAPTIC_SINE
+ * - SDL_HAPTIC_SQUARE
+ * - SDL_HAPTIC_TRIANGLE
+ * - SDL_HAPTIC_SAWTOOTHUP
+ * - SDL_HAPTIC_SAWTOOTHDOWN
+ *
+ * A periodic effect consists in a wave-shaped effect that repeats itself
+ * over time. The type determines the shape of the wave and the parameters
+ * determine the dimensions of the wave.
+ *
+ * Phase is given by hundredth of a cycle meaning that giving the phase a value
+ * of 9000 will displace it 25% of its period. Here are sample values:
+ * - 0: No phase displacement.
+ * - 9000: Displaced 25% of its period.
+ * - 18000: Displaced 50% of its period.
+ * - 27000: Displaced 75% of its period.
+ * - 36000: Displaced 100% of its period, same as 0, but 0 is preferred.
+ *
+ * Examples:
+ *
+ SDL_HAPTIC_SINE
+ __ __ __ __
+ / \ / \ / \ /
+ / \__/ \__/ \__/
+
+ SDL_HAPTIC_SQUARE
+ __ __ __ __ __
+ | | | | | | | | | |
+ | |__| |__| |__| |__| |
+
+ SDL_HAPTIC_TRIANGLE
+ /\ /\ /\ /\ /\
+ / \ / \ / \ / \ /
+ / \/ \/ \/ \/
+
+ SDL_HAPTIC_SAWTOOTHUP
+ /| /| /| /| /| /| /|
+ / | / | / | / | / | / | / |
+ / |/ |/ |/ |/ |/ |/ |
+
+ SDL_HAPTIC_SAWTOOTHDOWN
+ \ |\ |\ |\ |\ |\ |\ |
+ \ | \ | \ | \ | \ | \ | \ |
+ \| \| \| \| \| \| \|
+
+ *
+ * SDL_HAPTIC_SINE
+ * SDL_HAPTIC_SQUARE
+ * SDL_HAPTIC_TRIANGLE
+ * SDL_HAPTIC_SAWTOOTHUP
+ * SDL_HAPTIC_SAWTOOTHDOWN
+ * SDL_HapticEffect
+ *}
+type
+ TSDL_HapticPeriodic = record
+ { Header *}
+ _type: UInt16; {**< SDL_HAPTIC_SINE, SDL_HAPTIC_SQUARE,
+ SDL_HAPTIC_TRIANGLE, SDL_HAPTIC_SAWTOOTHUP or
+ SDL_HAPTIC_SAWTOOTHDOWN *}
+ direction: TSDL_HapticDirection; {**< Direction of the effect. *}
+
+ {* Replay *}
+ length: UInt32; {**< Duration of the effect. *}
+ delay: UInt16; {**< Delay before starting the effect. *}
+
+ {* Trigger *}
+ button: UInt16; {**< Button that triggers the effect. *}
+ interval: UInt16; {**< How soon it can be triggered again after button. *}
+
+ {* Periodic *}
+ period: UInt16; {**< Period of the wave. *}
+ magnitude: SInt16; {**< Peak value. *}
+ offset: SInt16; {**< Mean value of the wave. *}
+ phase: UInt16; {**< Horizontal shift given by hundredth of a cycle. *}
+
+ {* Envelope *}
+ attack_length: UInt16; {**< Duration of the attack. *}
+ attack_level: UInt16; {**< Level at the start of the attack. *}
+ fade_length: UInt16; {**< Duration of the fade. *}
+ fade_level: UInt16; {**< Level at the end of the fade. *}
+ end;
+
+ {**
+ * A structure containing a template for a Condition effect.
+ *
+ * The struct handles the following effects:
+ * - SDL_HAPTIC_SPRING: Effect based on axes position.
+ * - SDL_HAPTIC_DAMPER: Effect based on axes velocity.
+ * - SDL_HAPTIC_INERTIA: Effect based on axes acceleration.
+ * - SDL_HAPTIC_FRICTION: Effect based on axes movement.
+ *
+ * Direction is handled by condition internals instead of a direction member.
+ * The condition effect specific members have three parameters. The first
+ * refers to the X axis, the second refers to the Y axis and the third
+ * refers to the Z axis. The right terms refer to the positive side of the
+ * axis and the left terms refer to the negative side of the axis. Please
+ * refer to the ::SDL_HapticDirection diagram for which side is positive and
+ * which is negative.
+ *
+ * SDL_HapticDirection
+ * SDL_HAPTIC_SPRING
+ * SDL_HAPTIC_DAMPER
+ * SDL_HAPTIC_INERTIA
+ * SDL_HAPTIC_FRICTION
+ * SDL_HapticEffect
+ *}
+type
+ TSDL_HapticCondition = record
+ {* Header *}
+ _type: UInt16; {**< SDL_HAPTIC_SPRING, SDL_HAPTIC_DAMPER,
+ SDL_HAPTIC_INERTIA or SDL_HAPTIC_FRICTION *}
+ direction: TSDL_HapticDirection; {**< Direction of the effect - Not used ATM. *}
+
+ {* Replay *}
+ length: UInt32; {**< Duration of the effect. *}
+ delay: UInt16; {**< Delay before starting the effect. *}
+
+ {* Trigger *}
+ button: UInt16; {**< Button that triggers the effect. *}
+ interval: UInt16; {**< How soon it can be triggered again after button. *}
+
+ {* Condition *}
+ right_sat: array[0..2] of UInt16; {**< Level when joystick is to the positive side. *}
+ left_sat: array[0..2] of UInt16; {**< Level when joystick is to the negative side. *}
+ right_coeff: array[0..2] of SInt16; {**< How fast to increase the force towards the positive side. *}
+ left_coeff: array[0..2] of SInt16; {**< How fast to increase the force towards the negative side. *}
+ deadband: array[0..2] of UInt16; {**< Size of the dead zone. *}
+ center: array[0..2] of SInt16; {**< Position of the dead zone. *}
+ end;
+
+ {**
+ * A structure containing a template for a Ramp effect.
+ *
+ * This struct is exclusively for the ::SDL_HAPTIC_RAMP effect.
+ *
+ * The ramp effect starts at start strength and ends at end strength.
+ * It augments in linear fashion. If you use attack and fade with a ramp
+ * the effects get added to the ramp effect making the effect become
+ * quadratic instead of linear.
+ *
+ * SDL_HAPTIC_RAMP
+ * SDL_HapticEffect
+ *}
+type
+ TSDL_HapticRamp = record
+ {* Header *}
+ _type: UInt16; {**< SDL_HAPTIC_RAMP *}
+ direction: TSDL_HapticDirection; {**< Direction of the effect. *}
+
+ {* Replay *}
+ length: UInt32; {**< Duration of the effect. *}
+ delay: UInt16; {**< Delay before starting the effect. *}
+
+ {* Trigger *}
+ button: UInt16; {**< Button that triggers the effect. *}
+ interval: UInt16; {**< How soon it can be triggered again after button. *}
+
+ {* Ramp *}
+ start: SInt16; {**< Beginning strength level. *}
+ _end: SInt16; {**< Ending strength level. *}
+
+ {* Envelope *}
+ attack_length: UInt16; {**< Duration of the attack. *}
+ attack_level: UInt16; {**< Level at the start of the attack. *}
+ fade_length: UInt16; {**< Duration of the fade. *}
+ fade_level: UInt16; {**< Level at the end of the fade. *}
+ end;
+
+ {**
+ * A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect.
+ *
+ * A custom force feedback effect is much like a periodic effect, where the
+ * application can define its exact shape. You will have to allocate the
+ * data yourself. Data should consist of channels * samples Uint16 samples.
+ *
+ * If channels is one, the effect is rotated using the defined direction.
+ * Otherwise it uses the samples in data for the different axes.
+ *
+ * SDL_HAPTIC_CUSTOM
+ * SDL_HapticEffect
+ *}
+type
+ TSDL_HapticCustom = record
+ {* Header *}
+ _type: UInt16; {**< SDL_HAPTIC_CUSTOM *}
+ direction: TSDL_HapticDirection; {**< Direction of the effect. *}
+
+ {* Replay *}
+ length: UInt32; {**< Duration of the effect. *}
+ delay: UInt16; {**< Delay before starting the effect. *}
+
+ {* Trigger *}
+ button: UInt16; {**< Button that triggers the effect. *}
+ interval: UInt16; {**< How soon it can be triggered again after button. *}
+
+ {* Custom *}
+ channels: UInt8; {**< Axes to use, minimum of one. *}
+ period: UInt16; {**< Sample periods. *}
+ samples: UInt16; {**< Amount of samples. *}
+ data: PUInt16; {**< Should contain channels*samples items. *}
+
+ {* Envelope *}
+ attack_length: UInt16; {**< Duration of the attack. *}
+ attack_level: UInt16; {**< Level at the start of the attack. *}
+ fade_length: UInt16; {**< Duration of the fade. *}
+ fade_level: UInt16; {**< Level at the end of the fade. *}
+ end;
+
+ {**
+ * The generic template for any haptic effect.
+ *
+ * All values max at 32767 (0x7FFF). Signed values also can be negative.
+ * Time values unless specified otherwise are in milliseconds.
+ *
+ * You can also pass SDL_HAPTIC_INFINITY to length instead of a 0-32767
+ * value. Neither delay, interval, attack_length nor fade_length support
+ * SDL_HAPTIC_INFINITY. Fade will also not be used since effect never ends.
+ *
+ * Additionally, the SDL_HAPTIC_RAMP effect does not support a duration of
+ * SDL_HAPTIC_INFINITY.
+ *
+ * Button triggers may not be supported on all devices, it is advised to not
+ * use them if possible. Buttons start at index 1 instead of index 0 like
+ * the joystick.
+ *
+ * If both attack_length and fade_level are 0, the envelope is not used,
+ * otherwise both values are used.
+ *
+ * Common parts:
+ *
+ * // Replay - All effects have this
+ * Uint32 length; // Duration of effect (ms).
+ * Uint16 delay; // Delay before starting effect.
+ *
+ * // Trigger - All effects have this
+ * Uint16 button; // Button that triggers effect.
+ * Uint16 interval; // How soon before effect can be triggered again.
+ *
+ * // Envelope - All effects except condition effects have this
+ * Uint16 attack_length; // Duration of the attack (ms).
+ * Uint16 attack_level; // Level at the start of the attack.
+ * Uint16 fade_length; // Duration of the fade out (ms).
+ * Uint16 fade_level; // Level at the end of the fade.
+ *
+ *
+ *
+ * Here we have an example of a constant effect evolution in time:
+ *
+ Strength
+ ^
+ |
+ | effect level --> _________________
+ | / \
+ | / \
+ | / \
+ | / \
+ | attack_level --> | \
+ | | | <--- fade_level
+ |
+ +--------------------------------------------------> Time
+ [--] [---]
+ attack_length fade_length
+
+ [------------------][-----------------------]
+ delay length
+
+ *
+ * Note either the attack_level or the fade_level may be above the actual
+ * effect level.
+ *
+ * SDL_HapticConstant
+ * SDL_HapticPeriodic
+ * SDL_HapticCondition
+ * SDL_HapticRamp
+ * SDL_HapticCustom
+ *}
+type
+ PSDL_HapticEffect = ^TSDL_HapticEffect;
+ TSDL_HapticEffect = record
+ {* Common for all force feedback effects *}
+ _type: UInt16; {**< Effect type. *}
+ case UInt16 of
+ 0: (constant: TSDL_HapticConstant;); {**< Constant effect. *}
+ 1: (periodic: TSDL_HapticPeriodic;); {**< Periodic effect. *}
+ 2: (condition: TSDL_HapticCondition;); {**< Condition effect. *}
+ 3: (ramp: TSDL_HapticRamp;); {**< Ramp effect. *}
+ 4: (custom: TSDL_HapticCustom;); {**< Custom effect. *}
+ end;
+
+ {* Function prototypes *}
+
+ {**
+ * Count the number of haptic devices attached to the system.
+ *
+ * Number of haptic devices detected on the system.
+ *}
+function SDL_NumHaptics: Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_NumHaptics' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the implementation dependent name of a Haptic device.
+ *
+ * This can be called before any joysticks are opened.
+ * If no name can be found, this function returns NULL.
+ *
+ * device_index Index of the device to get its name.
+ * Name of the device or NULL on error.
+ *
+ * SDL_NumHaptics
+ *}
+function SDL_HapticName(device_index: Integer): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticName' {$ENDIF} {$ENDIF};
+
+ {**
+ * Opens a Haptic device for usage.
+ *
+ * The index passed as an argument refers to the N'th Haptic device on this
+ * system.
+ *
+ * When opening a haptic device, its gain will be set to maximum and
+ * autocenter will be disabled. To modify these values use
+ * SDL_HapticSetGain() and SDL_HapticSetAutocenter().
+ *
+ * device_index Index of the device to open.
+ * Device identifier or NULL on error.
+ *
+ * SDL_HapticIndex
+ * SDL_HapticOpenFromMouse
+ * SDL_HapticOpenFromJoystick
+ * SDL_HapticClose
+ * SDL_HapticSetGain
+ * SDL_HapticSetAutocenter
+ * SDL_HapticPause
+ * SDL_HapticStopAll
+ *}
+function SDL_HapticOpen(device_index: Integer): PSDL_Haptic cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticOpen' {$ENDIF} {$ENDIF};
+
+ {**
+ * Checks if the haptic device at index has been opened.
+ *
+ * device_index Index to check to see if it has been opened.
+ * 1 if it has been opened or 0 if it hasn't.
+ *
+ * SDL_HapticOpen
+ * SDL_HapticIndex
+ *}
+function SDL_HapticOpened(device_index: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticOpened' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets the index of a haptic device.
+ *
+ * haptic Haptic device to get the index of.
+ * The index of the haptic device or -1 on error.
+ *
+ * SDL_HapticOpen
+ * SDL_HapticOpened
+ *}
+function SDL_HapticIndex(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticIndex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets whether or not the current mouse has haptic capabilities.
+ *
+ * SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't.
+ *
+ * SDL_HapticOpenFromMouse
+ *}
+function SDL_MouseIsHaptic: Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MouseInHaptic' {$ENDIF} {$ENDIF};
+
+ {**
+ * Tries to open a haptic device from the current mouse.
+ *
+ * The haptic device identifier or NULL on error.
+ *
+ * SDL_MouseIsHaptic
+ * SDL_HapticOpen
+ *}
+function SDL_HapticOpenFromMouse: PSDL_Haptic cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticOpenFromMouse' {$ENDIF} {$ENDIF};
+
+ {**
+ * Checks to see if a joystick has haptic features.
+ *
+ * joystick Joystick to test for haptic capabilities.
+ * 1 if the joystick is haptic, 0 if it isn't
+ * or -1 if an error ocurred.
+ *
+ * SDL_HapticOpenFromJoystick
+ *}
+function SDL_JoystickIsHaptic(joystick: PSDL_Joystick): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickIsHaptic' {$ENDIF} {$ENDIF};
+
+ {**
+ * Opens a Haptic device for usage from a Joystick device.
+ *
+ * You must still close the haptic device seperately. It will not be closed
+ * with the joystick.
+ *
+ * When opening from a joystick you should first close the haptic device before
+ * closing the joystick device. If not, on some implementations the haptic
+ * device will also get unallocated and you'll be unable to use force feedback
+ * on that device.
+ *
+ * joystick Joystick to create a haptic device from.
+ * A valid haptic device identifier on success or NULL on error.
+ *
+ * SDL_HapticOpen
+ * SDL_HapticClose
+ *}
+function SDL_HapticOpenFromJoystick(joystick: PSDL_Joystick): PSDL_Haptic cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticOpenFromJoystick' {$ENDIF} {$ENDIF};
+
+ {**
+ * Closes a Haptic device previously opened with SDL_HapticOpen().
+ *
+ * haptic Haptic device to close.
+ *}
+procedure SDL_HapticClose(haptic: PSDL_Haptic) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticClose' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the number of effects a haptic device can store.
+ *
+ * On some platforms this isn't fully supported, and therefore is an
+ * approximation. Always check to see if your created effect was actually
+ * created and do not rely solely on SDL_HapticNumEffects().
+ *
+ * haptic The haptic device to query effect max.
+ * The number of effects the haptic device can store or
+ * -1 on error.
+ *
+ * SDL_HapticNumEffectsPlaying
+ * SDL_HapticQuery
+ *}
+function SDL_HapticNumEffects(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticNumEffects' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the number of effects a haptic device can play at the same
+ * time.
+ *
+ * This is not supported on all platforms, but will always return a value.
+ * Added here for the sake of completeness.
+ *
+ * haptic The haptic device to query maximum playing effects.
+ * The number of effects the haptic device can play at the same time
+ * or -1 on error.
+ *
+ * SDL_HapticNumEffects
+ * SDL_HapticQuery
+ *}
+function SDL_HapticNumEffectsPlaying(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticNumEffectsPlaying' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets the haptic devices supported features in bitwise matter.
+ *
+ * Example:
+ *
+ * if (SDL_HapticQueryEffects(haptic) & SDL_HAPTIC_CONSTANT)
+ * printf("We have constant haptic effect!");
+ *
+ *
+ *
+ * haptic The haptic device to query.
+ * Haptic features in bitwise manner (OR'd).
+ *
+ * SDL_HapticNumEffects
+ * SDL_HapticEffectSupported
+ *}
+function SDL_HapticQuery(haptic: PSDL_Haptic): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticQuery' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets the number of haptic axes the device has.
+ *
+ * SDL_HapticDirection
+ *}
+function SDL_HapticNumAxes(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticNumAxes' {$ENDIF} {$ENDIF};
+
+ {**
+ * Checks to see if effect is supported by haptic.
+ *
+ * haptic Haptic device to check on.
+ * effect Effect to check to see if it is supported.
+ * SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+ *
+ * SDL_HapticQuery
+ * SDL_HapticNewEffect
+ *}
+function SDL_HapticEffectSupported(haptic: PSDL_Haptic; effect: PSDL_HapticEffect): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticEffectSupported' {$ENDIF} {$ENDIF};
+
+ {**
+ * Creates a new haptic effect on the device.
+ *
+ * haptic Haptic device to create the effect on.
+ * effect Properties of the effect to create.
+ * The id of the effect on success or -1 on error.
+ *
+ * SDL_HapticUpdateEffect
+ * SDL_HapticRunEffect
+ * SDL_HapticDestroyEffect
+ *}
+function SDL_HapticNewEffect(haptic: PSDL_Haptic; effect: PSDL_HapticEffect): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticNewEffect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Updates the properties of an effect.
+ *
+ * Can be used dynamically, although behaviour when dynamically changing
+ * direction may be strange. Specifically the effect may reupload itself
+ * and start playing from the start. You cannot change the type either when
+ * running SDL_HapticUpdateEffect().
+ *
+ * haptic Haptic device that has the effect.
+ * effect Effect to update.
+ * data New effect properties to use.
+ * The id of the effect on success or -1 on error.
+ *
+ * SDL_HapticNewEffect
+ * SDL_HapticRunEffect
+ * SDL_HapticDestroyEffect
+ *}
+function SDL_HapticUpdateEffect(haptic: PSDL_Haptic; effect: Integer; data: PSDL_HapticEffect): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticUpdateEffect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Runs the haptic effect on its associated haptic device.
+ *
+ * If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over
+ * repeating the envelope (attack and fade) every time. If you only want the
+ * effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length
+ * parameter.
+ *
+ * haptic Haptic device to run the effect on.
+ * effect Identifier of the haptic effect to run.
+ * iterations Number of iterations to run the effect. Use
+ * SDL_HAPTIC_INFINITY for infinity.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticStopEffect
+ * SDL_HapticDestroyEffect
+ * SDL_HapticGetEffectStatus
+ *}
+function SDL_HapticRunEffect(haptic: PSDL_Haptic; effect: Integer; iterations: UInt32): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticRunEffect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Stops the haptic effect on its associated haptic device.
+ *
+ * haptic Haptic device to stop the effect on.
+ * effect Identifier of the effect to stop.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticRunEffect
+ * SDL_HapticDestroyEffect
+ *}
+function SDL_HapticStopEffect(haptic: PSDL_Haptic; effect: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticStopEffect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroys a haptic effect on the device.
+ *
+ * This will stop the effect if it's running. Effects are automatically
+ * destroyed when the device is closed.
+ *
+ * haptic Device to destroy the effect on.
+ * effect Identifier of the effect to destroy.
+ *
+ * SDL_HapticNewEffect
+ *}
+procedure SDL_HapticDestroyEffect(haptic: PSDL_Haptic; effect: Integer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticDestroyEffect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets the status of the current effect on the haptic device.
+ *
+ * Device must support the ::SDL_HAPTIC_STATUS feature.
+ *
+ * haptic Haptic device to query the effect status on.
+ * effect Identifier of the effect to query its status.
+ * 0 if it isn't playing, 1 if it is playing or -1 on error.
+ *
+ * SDL_HapticRunEffect
+ * SDL_HapticStopEffect
+ *}
+function SDL_HapticGetEffectStatus(haptic: PSDL_Haptic; effect: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticGetEffectStatus' {$ENDIF} {$ENDIF};
+
+ {**
+ * Sets the global gain of the device.
+ *
+ * Device must support the SDL_HAPTIC_GAIN feature.
+ *
+ * The user may specify the maximum gain by setting the environment variable
+ * SDL_HAPTIC_GAIN_MAX which should be between 0 and 100. All calls to
+ * SDL_HapticSetGain() will scale linearly using SDL_HAPTIC_GAIN_MAX as the
+ * maximum.
+ *
+ * haptic Haptic device to set the gain on.
+ * gain Value to set the gain to, should be between 0 and 100.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticQuery
+ *}
+function SDL_HapticSetGain(haptic: PSDL_Haptic; gain: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticSetGain' {$ENDIF} {$ENDIF};
+
+ {**
+ * Sets the global autocenter of the device.
+ *
+ * Autocenter should be between 0 and 100. Setting it to 0 will disable
+ * autocentering.
+ *
+ * Device must support the ::SDL_HAPTIC_AUTOCENTER feature.
+ *
+ * haptic Haptic device to set autocentering on.
+ * autocenter Value to set autocenter to, 0 disables autocentering.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticQuery
+ *}
+function SDL_HapticSetAutocenter(haptic: PSDL_Haptic; autocenter: Integer): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticSetAutocenter' {$ENDIF} {$ENDIF};
+
+ {**
+ * Pauses a haptic device.
+ *
+ * Device must support the SDL_HAPTIC_PAUSE feature. Call
+ * SDL_HapticUnpause() to resume playback.
+ *
+ * Do not modify the effects nor add new ones while the device is paused.
+ * That can cause all sorts of weird errors.
+ *
+ * haptic Haptic device to pause.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticUnpause
+ *}
+function SDL_HapticPause(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticPause' {$ENDIF} {$ENDIF};
+
+ {**
+ * Unpauses a haptic device.
+ *
+ * Call to unpause after SDL_HapticPause().
+ *
+ * haptic Haptic device to pause.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticPause
+ *}
+function SDL_HapticUnpause(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticUnPause' {$ENDIF} {$ENDIF};
+
+ {**
+ * Stops all the currently playing effects on a haptic device.
+ *
+ * haptic Haptic device to stop.
+ * 0 on success or -1 on error.
+ *}
+function SDL_HapticStopAll(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticStopAll' {$ENDIF} {$ENDIF};
+
+ {**
+ * Checks to see if rumble is supported on a haptic device..
+ *
+ * haptic Haptic device to check to see if it supports rumble.
+ * SDL_TRUE if effect is supported, SDL_FALSE if it isn't or -1 on error.
+ *
+ * SDL_HapticRumbleInit
+ * SDL_HapticRumblePlay
+ * SDL_HapticRumbleStop
+ *}
+function SDL_HapticRumbleSupported(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticRumbleSupported' {$ENDIF} {$ENDIF};
+
+ {**
+ * Initializes the haptic device for simple rumble playback.
+ *
+ * haptic Haptic device to initialize for simple rumble playback.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticOpen
+ * SDL_HapticRumbleSupported
+ * SDL_HapticRumblePlay
+ * SDL_HapticRumbleStop
+ *}
+function SDL_HapticRumbleInit(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticRumbleInit' {$ENDIF} {$ENDIF};
+
+ {**
+ * Runs simple rumble on a haptic device
+ *
+ * haptic Haptic device to play rumble effect on.
+ * strength Strength of the rumble to play as a 0-1 float value.
+ * length Length of the rumble to play in milliseconds.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticRumbleSupported
+ * SDL_HapticRumbleInit
+ * SDL_HapticRumbleStop
+ *}
+function SDL_HapticRumblePlay(haptic: PSDL_Haptic; strength: Float; length: UInt32): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticRumblePlay' {$ENDIF} {$ENDIF};
+
+ {**
+ * Stops the simple rumble on a haptic device.
+ *
+ * haptic Haptic to stop the rumble on.
+ * 0 on success or -1 on error.
+ *
+ * SDL_HapticRumbleSupported
+ * SDL_HapticRumbleInit
+ * SDL_HapticRumblePlay
+ *}
+function SDL_HapticRumbleStop(haptic: PSDL_Haptic): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HapticRumbleStop' {$ENDIF} {$ENDIF};
+
--- /dev/null
+//from sdl_hints.h
+
+type
+TSDL_Char = PChar;
+
+const
+ SDL_HINT_FRAMEBUFFER_ACCELERATION = 'SDL_FRAMEBUFFER_ACCELERATION';
+ SDL_HINT_RENDER_DRIVER = 'SDL_RENDER_DRIVER';
+ SDL_HINT_RENDER_OPENGL_SHADERS = 'SDL_RENDER_OPENGL_SHADERS';
+ SDL_HINT_RENDER_SCALE_QUALITY = 'SDL_RENDER_SCALE_QUALITY';
+ SDL_HINT_RENDER_VSYNC = 'SDL_RENDER_VSYNC';
+ SDL_HINT_VIDEO_X11_XVIDMODE = 'SDL_VIDEO_X11_XVIDMODE';
+ SDL_HINT_VIDEO_X11_XINERAMA = 'SDL_VIDEO_X11_XINERAMA';
+ SDL_HINT_VIDEO_X11_XRANDR = 'SDL_VIDEO_X11_XRANDR';
+ SDL_HINT_GRAB_KEYBOARD = 'SDL_GRAB_KEYBOARD';
+ SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = 'SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS';
+ SDL_HINT_IDLE_TIMER_DISABLED = 'SDL_IOS_IDLE_TIMER_DISABLED';
+ SDL_HINT_ORIENTATIONS = 'SDL_IOS_ORIENTATIONS';
+ SDL_HINT_XINPUT_ENABLED = 'SDL_XINPUT_ENABLED';
+ SDL_HINT_GAMECONTROLLERCONFIG = 'SDL_GAMECONTROLLERCONFIG';
+ SDL_HINT_ALLOW_TOPMOST = 'SDL_ALLOW_TOPMOST';
+
+
+ SDL_HINT_DEFAULT = 0;
+ SDL_HINT_NORMAL = SDL_HINT_DEFAULT + 1;
+ SDL_HINT_OVERRIDE = SDL_HINT_NORMAL + 1;
+
+function SDL_SetHintWithPriority(name, value: TSDL_Char; priority: Uint32): TSDL_Bool; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetHintWithPriority' {$ENDIF} {$ENDIF};
+function SDL_SetHint(name, value: TSDL_Char): TSDL_Bool; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetHint' {$ENDIF} {$ENDIF};
+function SDL_GetHint(name: TSDL_Char): TSDL_Char; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetHint' {$ENDIF} {$ENDIF};
+procedure SDL_ClearHints; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ClearHints' {$ENDIF} {$ENDIF};
\ No newline at end of file
--- /dev/null
+//from "sdl_joystick.h"
+
+ {**
+ * SDL_joystick.h
+ *
+ * In order to use these functions, SDL_Init() must have been called
+ * with the ::SDL_INIT_JOYSTICK flag. This causes SDL to scan the system
+ * for joysticks, and load appropriate drivers.
+ *}
+
+type
+
+ {* The joystick structure used to identify an SDL joystick *}
+ PSDL_Joystick = Pointer; // todo!!
+
+{* A structure that encodes the stable unique id for a joystick device *}
+
+ TSDL_JoystickGUID = record
+ data: array[0..15] of UInt8;
+ end;
+
+ TSDL_JoystickID = SInt32;
+
+ {* Function prototypes *}
+ {**
+ * Count the number of joysticks attached to the system right now
+ *}
+function SDL_NumJoysticks: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_NumJoysticks' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+function SDL_JoystickNameForIndex(device_index: SInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNameForIndex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Open a joystick for use.
+ * The index passed as an argument refers tothe N'th joystick on the system.
+ * This index is the value which will identify this joystick in future joystick
+ * events.
+ *
+ * A joystick identifier, or NULL if an error occurred.
+ *}
+function SDL_JoystickOpen(device_index: SInt32): PSDL_Joystick cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickOpen' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return the name for this currently opened joystick.
+ * If no name can be found, this function returns NULL.
+ *}
+function SDL_JoystickName(joystick: PSDL_Joystick): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickName' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return the GUID for the joystick at this index
+ *}
+function SDL_JoystickGetDeviceGUID(device_index: SInt32): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetDeviceGUID' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return the GUID for this opened joystick
+ *}
+function SDL_JoystickGetGUID(joystick: PSDL_Joystick): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUID' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return a string representation for this guid. pszGUID must point to at least 33 bytes
+ * (32 for the string plus a NULL terminator).
+ *}
+procedure SDL_JoystickGetGUIDString(guid: TSDL_JoystickGUId; pszGUID: PAnsiChar; cbGUID: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUIDString' {$ENDIF} {$ENDIF};
+
+ {**
+ * convert a string into a joystick formatted guid
+ *}
+function SDL_JoystickGetGUIDFromString(const pchGUID: PAnsiChar): TSDL_JoystickGUID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetGUIDFromString' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns SDL_TRUE if the joystick has been opened and currently connected, or SDL_FALSE if it has not.
+ *}
+function SDL_JoystickGetAttached(joystick: PSDL_Joystick): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetAttached' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the instance ID of an opened joystick or -1 if the joystick is invalid.
+ *}
+function SDL_JoystickInstanceID(joystick: PSDL_Joystick): TSDL_JoystickID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickInstanceID' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the number of general axis controls on a joystick.
+ *}
+function SDL_JoystickNumAxes(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumAxes' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the number of trackballs on a joystick.
+ *
+ * Joystick trackballs have only relative motion events associated
+ * with them and their state cannot be polled.
+ *}
+function SDL_JoystickNumBalls(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumBalls' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the number of POV hats on a joystick.
+ *}
+function SDL_JoystickNumHats(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumHats' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the number of buttons on a joystick.
+ *}
+function SDL_JoystickNumButtons(joystick: PSDL_Joystick): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickNumButtons' {$ENDIF} {$ENDIF};
+
+ {**
+ * Update the current state of the open joysticks.
+ *
+ * This is called automatically by the event loop if any joystick
+ * events are enabled.
+ *}
+procedure SDL_JoystickUpdate cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickUpdate' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+function SDL_JoystickEventState(state: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickEventState' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+function SDL_JoystickGetAxis(joystick: PSDL_Joystick; axis: SInt32): SInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetAxis' {$ENDIF} {$ENDIF};
+
+ {**
+ * Hat positions
+ *}
+const
+ SDL_HAT_CENTERED = $00;
+ SDL_HAT_UP = $01;
+ SDL_HAT_RIGHT = $02;
+ SDL_HAT_DOWN = $04;
+ SDL_HAT_LEFT = $08;
+ 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;
+
+ {**
+ * Get the current state of a POV hat on a joystick.
+ *
+ * The hat indices start at index 0.
+ *
+ * The return value is one of the following positions:
+ * - SDL_HAT_CENTERED
+ * - SDL_HAT_UP
+ * - SDL_HAT_RIGHT
+ * - SDL_HAT_DOWN
+ * - SDL_HAT_LEFT
+ * - SDL_HAT_RIGHTUP
+ * - SDL_HAT_RIGHTDOWN
+ * - SDL_HAT_LEFTUP
+ * - SDL_HAT_LEFTDOWN
+ *}
+function SDL_JoystickGetHat(joystick: PSDL_Joystick; hat: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetHat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the ball axis change since the last poll.
+ *
+ * 0, or -1 if you passed it invalid parameters.
+ *
+ * The ball indices start at index 0.
+ *}
+function SDL_JoystickGetBall(joystick: PSDL_Joystick; ball: SInt32; dx: PInt; dy: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetBall' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the current state of a button on a joystick.
+ *
+ * The button indices start at index 0.
+ *}
+function SDL_JoystickGetButton(joystick: PSDL_Joystick; button: SInt32): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickGetButton' {$ENDIF} {$ENDIF};
+ {**
+ * Close a joystick previously opened with SDL_JoystickOpen().
+ *}
+procedure SDL_JoystickClose(joystick: PSDL_Joystick) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_JoystickClose' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_keyboard.h"
+
+type
+ PKeyStateArr = ^TKeyStateArr;
+ TKeyStateArr = array[0..65000] of UInt8;
+
+ {**
+ * The SDL keysym structure, used in key events.
+ *}
+ PSDL_Keysym = ^TSDL_Keysym;
+ TSDL_Keysym = record
+ scancode: TSDL_ScanCode; // SDL physical key code - see SDL_Scancode for details
+ sym: TSDL_KeyCode; // SDL virtual key code - see SDL_Keycode for details
+ _mod: UInt16; // current key modifiers
+ unicode: UInt32; // (deprecated) use SDL_TextInputEvent instead
+ end;
+
+ {**
+ * Get the window which currently has keyboard focus.
+ *}
+
+ function SDL_GetKeyboardFocus: PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyboardFocus' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get a snapshot of the current state of the keyboard.
+ *
+ * numkeys if non-nil, receives the length of the returned array.
+ *
+ * An array of key states. Indexes into this array are obtained by using SDL_Scancode values.
+ *
+ *}
+
+ function SDL_GetKeyboardState(numkeys: PInt): PUInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyboardState' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get the current key modifier state for the keyboard.
+ *}
+
+ function SDL_GetModState: TSDL_KeyMod cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetModState' {$ENDIF}{$ENDIF};
+
+ {**
+ * Set the current key modifier state for the keyboard.
+ *
+ * This does not change the keyboard state, only the key modifier flags.
+ *}
+
+ procedure SDL_SetModState(modstate: TSDL_KeyMod) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetModState' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get the key code corresponding to the given scancode according
+ * to the current keyboard layout.
+ *
+ * See SDL_Keycode for details.
+ *
+ * SDL_GetKeyName()
+ *}
+
+ function SDL_GetKeyFromScancode(scancode: TSDL_ScanCode): TSDL_KeyCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyFromScancode' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get the scancode corresponding to the given key code according to the
+ * current keyboard layout.
+ *
+ * See SDL_Scancode for details.
+ *
+ * SDL_GetScancodeName()
+ *}
+
+ function SDL_GetScancodeFromKey(key: TSDL_KeyCode): TSDL_ScanCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeFromKey' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get a human-readable name for a scancode.
+ *
+ * A pointer to the name for the scancode.
+ *
+ * If the scancode doesn't have a name, this function returns
+ * an empty string ("").
+ *
+ *}
+
+ function SDL_GetScancodeName(scancode: TSDL_ScanCode): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeName' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get a scancode from a human-readable name
+ *
+ * scancode, or SDL_SCANCODE_UNKNOWN if the name wasn't recognized
+ *
+ * SDL_Scancode
+ *}
+
+ function SDL_GetScancodeFromName(const name: PAnsiChar): TSDL_ScanCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetScancodeFromName' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get a human-readable name for a key.
+ *
+ * A pointer to a UTF-8 string that stays valid at least until the next
+ * call to this function. If you need it around any longer, you must
+ * copy it. If the key doesn't have a name, this function returns an
+ * empty string ("").
+ *
+ * SDL_Key
+ *}
+
+ function SDL_GetKeyName(key: TSDL_ScanCode): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyName' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get a key code from a human-readable name
+ *
+ * key code, or SDLK_UNKNOWN if the name wasn't recognized
+ *
+ * SDL_Keycode
+ *}
+
+ function SDL_GetKeyFromName(const name: PAnsiChar): TSDL_KeyCode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetKeyFromName' {$ENDIF}{$ENDIF};
+
+ {**
+ * Start accepting Unicode text input events.
+ * This function will show the on-screen keyboard if supported.
+ *
+ * SDL_StopTextInput()
+ * SDL_SetTextInputRect()
+ * SDL_HasScreenKeyboardSupport()
+ *}
+
+ procedure SDL_StartTextInput cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_StartTextInput' {$ENDIF}{$ENDIF};
+
+ {**
+ * Return whether or not Unicode text input events are enabled.
+ *
+ * SDL_StartTextInput()
+ * SDL_StopTextInput()
+ *}
+
+ function SDL_IsTextInputActive: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsTextInputActive' {$ENDIF}{$ENDIF};
+
+ {**
+ * Stop receiving any text input events.
+ * This function will hide the on-screen keyboard if supported.
+ *
+ * SDL_StartTextInput()
+ * SDL_HasScreenKeyboardSupport()
+ *}
+
+ procedure SDL_StopTextInput cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_StopTextInput' {$ENDIF}{$ENDIF};
+
+ {**
+ * Set the rectangle used to type Unicode text inputs.
+ * This is used as a hint for IME and on-screen keyboard placement.
+ *
+ * SDL_StartTextInput()
+ *}
+
+ procedure SDL_SetTextInputRect(rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextInputRect' {$ENDIF}{$ENDIF};
+
+ {**
+ * Returns whether the platform has some screen keyboard support.
+ *
+ * SDL_TRUE if some keyboard support is available else SDL_FALSE.
+ *
+ * Not all screen keyboard functions are supported on all platforms.
+ *
+ * SDL_IsScreenKeyboardShown()
+ *}
+
+ function SDL_HasScreenKeyboardSupport: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasScreenKeyboardSupport' {$ENDIF}{$ENDIF};
+
+ {**
+ * Returns whether the screen keyboard is shown for given window.
+ *
+ * window The window for which screen keyboard should be queried.
+ *
+ * Result - SDL_TRUE if screen keyboard is shown else SDL_FALSE.
+ *
+ * SDL_HasScreenKeyboardSupport()
+ *}
+
+ function SDL_IsScreenKeyboardShown(window: PSDL_Window): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsScreenKeyboardShown' {$ENDIF}{$ENDIF};
--- /dev/null
+//from 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.
+ *}
+function SDL_LoadObject(sofile: PAnsiChar): Pointer;
+
+{**
+ * 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().
+ *}
+function SDL_LoadFunction(handle: Pointer; name: PAnsiChar): Pointer;
+
+{**
+ * Unload a shared object from memory.
+ *}
+procedure SDL_UnloadObject(handle: Pointer);
--- /dev/null
+//from "sdl_messagebox.h"
+
+ {**
+ * SDL_MessageBox flags. If supported will display warning icon, etc.
+ *}
+
+const
+ SDL_MESSAGEBOX_ERROR = $00000010; {**< error dialog *}
+ SDL_MESSAGEBOX_WARNING = $00000020; {**< warning dialog *}
+ SDL_MESSAGEBOX_INFORMATION = $00000040; {**< informational dialog *}
+
+type
+ TSDL_MessageBoxFlags = Byte;
+
+ {**
+ * Flags for SDL_MessageBoxButtonData.
+ *}
+const
+ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = $00000001; {**< Marks the default button when return is hit *}
+ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = $00000002; {**< Marks the default button when escape is hit *}
+type
+ TSDL_MessageBoxButtonFlags = Byte;
+
+ {**
+ * Individual button data.
+ *}
+type
+ PSDL_MessageBoxButtonData = ^TSDL_MessageBoxButtonData;
+ TSDL_MessageBoxButtonData = record
+ flags: UInt32; {**< ::SDL_MessageBoxButtonFlags *}
+ buttonid: Integer; {**< User defined button id (value returned via SDL_ShowMessageBox) *}
+ text: PAnsiChar; {**< The UTF-8 button text *}
+ end;
+
+ {**
+ * RGB value used in a message box color scheme
+ *}
+type
+ PSDL_MessageBoxColor = ^TSDL_MessageBoxColor;
+ TSDL_MessageBoxColor = record
+ r, g, b: UInt8;
+ end;
+
+ PSDL_MessageBoxColorType = ^TSDL_MessageBoxColorType;
+ TSDL_MessageBoxColorType = (SDL_MESSAGEBOX_COLOR_BACKGROUND,
+ SDL_MESSAGEBOX_COLOR_TEXT,
+ SDL_MESSAGEBOX_COLOR_BUTTON_BORDER,
+ SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND,
+ SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED,
+ SDL_MESSAGEBOX_COLOR_MAX);
+
+ {**
+ * A set of colors to use for message box dialogs
+ *}
+type
+ PSDL_MessageBoxColorScheme = ^TSDL_MessageBoxColorScheme;
+ TSDL_MessageBoxColorScheme = record
+ //colors: array[0..SDL_MESSAGEBOX_COLOR_MAX-1] of TSDL_MessageBoxColor;
+ colors: array[0..4] of TSDL_MessageBoxColor; //right?!
+ end;
+
+ {**
+ * MessageBox structure containing title, text, window, etc.
+ *}
+type
+ PSDL_MessageBoxData = ^TSDL_MessageBoxData;
+ TSDL_MessageBoxData = record
+ flags: UInt32; {**< SDL_MessageBoxFlags *}
+ window: PSDL_Window; {**< Parent window, can be NULL *}
+ title: PAnsiChar; {**< UTF-8 title *}
+ _message: PAnsiChar; {**< UTF-8 message text *}
+
+ numbuttons: Integer;
+ buttons: PSDL_MessageBoxButtonData;
+
+ colorScheme: PSDL_MessageBoxColorScheme; {**< SDL_MessageBoxColorScheme, can be NULL to use system settings *}
+ end;
+
+ {**
+ * Create a modal message box.
+ *
+ * messageboxdata The SDL_MessageBoxData structure with title, text, etc.
+ * buttonid The pointer to which user id of hit button should be copied.
+ *
+ * -1 on error, otherwise 0 and buttonid contains user id of button
+ * hit or -1 if dialog was closed.
+ *
+ * This function should be called on the thread that created the parent
+ * window, or on the main thread if the messagebox has no parent. It will
+ * block execution of that thread until the user clicks a button or
+ * closes the messagebox.
+ *}
+function SDL_ShowMessageBox(messageboxdata: PSDL_MessageBoxData; buttonid: PInt): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowMessageBox' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a simple modal message box
+ *
+ * flags SDL_MessageBoxFlags
+ * title UTF-8 title text
+ * message UTF-8 message text
+ * window The parent window, or NULL for no parent
+ *
+ * 0 on success, -1 on error
+ *
+ * SDL_ShowMessageBox
+ *}
+function SDL_ShowSimpleMessageBox(flags: UInt32; title: PAnsiChar; _message: PAnsiChar; window: PSDL_Window): Integer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowSimpleMessageBox' {$ENDIF} {$ENDIF};
+
--- /dev/null
+//from "sdl_mouse.h"
+
+type
+ PSDL_Cursor = Pointer;
+
+const
+
+ {**
+ * Cursor types for SDL_CreateSystemCursor.
+ *}
+
+ SDL_SYSTEM_CURSOR_ARROW = 0; // Arrow
+ SDL_SYSTEM_CURSOR_IBEAM = 1; // I-beam
+ SDL_SYSTEM_CURSOR_WAIT = 2; // Wait
+ SDL_SYSTEM_CURSOR_CROSSHAIR = 3; // Crosshair
+ SDL_SYSTEM_CURSOR_WAITARROW = 4; // Small wait cursor (or Wait if not available)
+ SDL_SYSTEM_CURSOR_SIZENWSE = 5; // Double arrow pointing northwest and southeast
+ SDL_SYSTEM_CURSOR_SIZENESW = 6; // Double arrow pointing northeast and southwest
+ SDL_SYSTEM_CURSOR_SIZEWE = 7; // Double arrow pointing west and east
+ SDL_SYSTEM_CURSOR_SIZENS = 8; // Double arrow pointing north and south
+ SDL_SYSTEM_CURSOR_SIZEALL = 9; // Four pointed arrow pointing north, south, east, and west
+ SDL_SYSTEM_CURSOR_NO = 10; // Slashed circle or crossbones
+ SDL_SYSTEM_CURSOR_HAND = 11; // Hand
+ SDL_NUM_SYSTEM_CURSORS = 12;
+
+type
+ PSDL_SystemCursor = ^TSDL_SystemCursor;
+ TSDL_SystemCursor = Word;
+
+ {* Function prototypes *}
+
+ {**
+ * Get the window which currently has mouse focus.
+ *}
+
+ function SDL_GetMouseFocus: PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetMouseFocus' {$ENDIF}{$ENDIF};
+
+ {**
+ * 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 cursor position relative to the focus window for the currently
+ * selected mouse. You can pass nil for either x or y.
+ *
+ * SDL_Button = 1 shl ((X)-1)
+ *}
+
+ function SDL_GetMouseState(x: PInt; y: PInt): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetMouseState' {$ENDIF}{$ENDIF};
+
+ {**
+ * Retrieve the relative 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().
+ *}
+
+ function SDL_GetRelativeMouseState(x: PInt; y: PInt): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRelativeMouseState' {$ENDIF}{$ENDIF};
+
+ {**
+ * Moves the mouse to the given position within the window.
+ *
+ * window The window to move the mouse into, or nil for the current mouse focus
+ * x The x coordinate within the window
+ * y The y coordinate within the window
+ *
+ * This function generates a mouse motion event
+ *}
+
+ procedure SDL_WarpMouseInWindow(window: PSDL_Window; x: SInt32; y: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WarpMouseInWindow' {$ENDIF}{$ENDIF};
+
+ {**
+ * Set relative mouse mode.
+ *
+ * enabled Whether or not to enable relative mode
+ *
+ * 0 on success, or -1 if relative mode is not supported.
+ *
+ * While the mouse is in relative mode, the cursor is hidden, and the
+ * driver will try to report continuous motion in the current window.
+ * Only relative motion events will be delivered, the mouse position
+ * will not change.
+ *
+ * This function will flush any pending mouse motion.
+ *
+ * SDL_GetRelativeMouseMode()
+ *}
+
+ function SDL_SetRelativeMouseMode(enabled: TSDL_Bool): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRelativeMouseMode' {$ENDIF}{$ENDIF};
+
+ {**
+ * Query whether relative mouse mode is enabled.
+ *
+ * SDL_SetRelativeMouseMode()
+ *}
+
+ function SDL_GetRelativeMouseMode: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRelativeMouseMode' {$ENDIF}{$ENDIF};
+
+ {**
+ * Create a cursor, using the specified bitmap 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:
+ * <table>
+ * <tr><td> data </td><td> mask </td><td> resulting pixel on screen </td></tr>
+ * <tr><td> 0 </td><td> 1 </td><td> White </td></tr>
+ * <tr><td> 1 </td><td> 1 </td><td> Black </td></tr>
+ * <tr><td> 0 </td><td> 0 </td><td> Transparent </td></tr>
+ * <tr><td> 1 </td><td> 0 </td><td> Inverted color if possible, black
+ * if not. </td></tr>
+ * </table>
+ *
+ * SDL_FreeCursor()
+ *}
+
+ function SDL_CreateCursor(const data: PUInt8; const mask: PUInt8; w: SInt32; h: SInt32; hot_x: SInt32; hot_y: SInt32): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Create a color cursor.
+ *
+ * SDL_FreeCursor()
+ *}
+
+ function SDL_CreateColorCursor(surface: PSDL_Surface; hot_x: SInt32; hot_y: SInt32): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateColorCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Create a system cursor.
+ *
+ * SDL_FreeCursor()
+ *}
+
+ function SDL_CreateSystemCursor(id: TSDL_SystemCursor): PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSystemCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Set the active cursor.
+ *}
+
+ procedure SDL_SetCursor(cursor: PSDL_Cursor) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Return the active cursor.
+ *}
+
+ function SDL_GetCursor: PSDL_Cursor cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Frees a cursor created with SDL_CreateCursor().
+ *
+ * SDL_CreateCursor()
+ *}
+
+ procedure SDL_FreeCursor(cursor: PSDL_Cursor) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeCursor' {$ENDIF}{$ENDIF};
+
+ {**
+ * Toggle whether or not the cursor is shown.
+ *
+ * toggle 1 to show the cursor, 0 to hide it, -1 to query the current
+ * state.
+ *
+ * 1 if the cursor is shown, or 0 if the cursor is hidden.
+ *}
+
+ function SDL_ShowCursor(toggle: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowCursor' {$ENDIF}{$ENDIF};
+
+const
+ {**
+ * Used as a mask when testing buttons in buttonstate.
+ * - Button 1: Left mouse button
+ * - Button 2: Middle mouse button
+ * - Button 3: Right mouse button
+ *}
+
+ SDL_BUTTON_LEFT = 1;
+ SDL_BUTTON_MIDDLE = 2;
+ SDL_BUTTON_RIGHT = 3;
+ SDL_BUTTON_X1 = 4;
+ SDL_BUTTON_X2 = 5;
+ SDL_BUTTON_LMASK = 1 shl ((SDL_BUTTON_LEFT) - 1);
+ SDL_BUTTON_MMASK = 1 shl ((SDL_BUTTON_MIDDLE) - 1);
+ SDL_BUTTON_RMASK = 1 shl ((SDL_BUTTON_RIGHT) - 1);
+ SDL_BUTTON_X1MASK = 1 shl ((SDL_BUTTON_X1) - 1);
+ SDL_BUTTON_X2MASK = 1 shl ((SDL_BUTTON_X2) - 1);
--- /dev/null
+//from "sdl_mutex.h"
+
+ {**
+ * Synchronization functions which can time out return this value
+ * if they time out.
+ *}
+const
+ SDL_MUTEX_TIMEDOUT = 1;
+
+ {**
+ * This is the timeout value which corresponds to never time out.
+ *}
+ //SDL_MUTEX_MAXWAIT (~(Uint32)0)
+
+
+ {**
+ * Mutex functions
+ *}
+type
+ {* The SDL mutex structure, defined in SDL_mutex.c *}
+ PSDL_Mutex = Pointer; //todo!
+
+ {**
+ * Create a mutex, initialized unlocked.
+ *}
+function SDL_CreateMutex: PSDL_Mutex cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateMutex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Lock the mutex.
+ *
+ * 0, or -1 on error.
+ *}
+//#define SDL_mutexP(m) SDL_LockMutex(m)
+function SDL_LockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockMutex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Try to lock the mutex
+ *
+ * 0, SDL_MUTEX_TIMEDOUT, or -1 on error
+ *}
+function SDL_TryLockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TryLockMutex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Unlock the mutex.
+ *
+ * 0, or -1 on error.
+ *
+ * It is an error to unlock a mutex that has not been locked by
+ * the current thread, and doing so results in undefined behavior.
+ *}
+//#define SDL_mutexV(m) SDL_UnlockMutex(m)
+function SDL_UnlockMutex(mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockMutex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy a mutex.
+ *}
+procedure SDL_DestroyMutex(mutex: PSDL_Mutex) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyMutex' {$ENDIF} {$ENDIF};
+
+ {*Mutex functions*}
+
+ {**
+ * Semaphore functions
+ *}
+type
+ {* The SDL semaphore structure, defined in SDL_sem.c *}
+ PSDL_Sem = Pointer; //todo!
+
+ {**
+ * Create a semaphore, initialized with value, returns NULL on failure.
+ *}
+function SDL_CreateSemaphore(initial_value: UInt32): PSDL_sem cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSemaphore' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy a semaphore.
+ *}
+procedure SDL_DestroySemaphore(sem: PSDL_Sem) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroySemaphore' {$ENDIF} {$ENDIF};
+
+ {**
+ * This function suspends the calling thread until the semaphore pointed
+ * to by sem has a positive count. It then atomically decreases the
+ * semaphore count.
+ *}
+function SDL_SemWait(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemWait' {$ENDIF} {$ENDIF};
+
+ {**
+ * Non-blocking variant of SDL_SemWait().
+ *
+ * 0 if the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait would
+ * block, and -1 on error.
+ *}
+function SDL_SemTryWait(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemTryWait' {$ENDIF} {$ENDIF};
+
+ {**
+ * Variant of SDL_SemWait() with a timeout in milliseconds.
+ *
+ * 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.
+ *}
+function SDL_SemWaitTimeout(sem: PSDL_Sem; ms: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemWaitTimeout' {$ENDIF} {$ENDIF};
+
+ {**
+ * Atomically increases the semaphore'_S count (not blocking).
+ *
+ * 0, or -1 on error.
+ *}
+function SDL_SemPost(sem: PSDL_Sem): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemPost' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the current count of the semaphore.
+ *}
+function SDL_SemValue(sem: PSDL_Sem): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SemValue' {$ENDIF} {$ENDIF};
+
+ {*Semaphore functions*}
+
+ {**
+ * Condition variable functions
+ * }
+type
+ {* The SDL condition variable structure, defined in SDL_cond.c *}
+ PSDL_Cond = Pointer; //todo!!
+
+ {**
+ * Create a condition variable.
+ *
+ * Typical use of condition variables:
+ *
+ * Thread A:
+ * SDL_LockMutex(lock);
+ * while ( not condition )
+ * begin
+ * SDL_CondWait(cond, lock);
+ * end;
+ * SDL_UnlockMutex(lock);
+ *
+ * Thread B:
+ * SDL_LockMutex(lock);
+ * ...
+ * condition := true;
+ * ...
+ * SDL_CondSignal(cond);
+ * SDL_UnlockMutex(lock);
+ *
+ * There is some discussion whether to signal the condition variable
+ * with the mutex locked or not. There is some potential performance
+ * benefit to unlocking first on some platforms, but there are some
+ * potential race conditions depending on how your code is structured.
+ *
+ * In general it'_S safer to signal the condition variable while the
+ * mutex is locked.
+ *}
+function SDL_CreateCond: PSDL_Cond cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateCond' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy a condition variable.
+ *}
+procedure SDL_DestroyCond(cond: PSDL_Cond) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyCond' {$ENDIF} {$ENDIF};
+
+ {**
+ * Restart one of the threads that are waiting on the condition variable.
+ *
+ * 0 or -1 on error.
+ *}
+function SDL_CondSignal(cond: PSDL_Cond): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondSignal' {$ENDIF} {$ENDIF};
+
+ {**
+ * Restart all threads that are waiting on the condition variable.
+ *
+ * 0 or -1 on error.
+ *}
+function SDL_CondBroadcast(cond: PSDL_Cond): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondBroadcast' {$ENDIF} {$ENDIF};
+
+ {**
+ * Wait on the condition variable, unlocking the provided mutex.
+ *
+ * The mutex must be locked before entering this function!
+ *
+ * The mutex is re-locked once the condition variable is signaled.
+ *
+ * 0 when it is signaled, or -1 on error.
+ *}
+function SDL_CondWait(cond: PSDL_Cond; mutex: PSDL_Mutex): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondWait' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+function SDL_CondWaitTimeout(cond: PSDL_Cond; mutex: PSDL_Mutex; ms: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CondWaitTimeout' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_pixels.h"
+
+ {**
+ * Transparency definitions
+ *
+ * These define alpha as the opacity of a surface.
+ *}
+
+ const
+ SDL_ALPHA_OPAQUE = 255;
+ SDL_ALPHA_TRANSPARENT = 0;
+
+ {** Pixel type. *}
+ SDL_PIXELTYPE_UNKNOWN = 0;
+ SDL_PIXELTYPE_INDEX1 = 1;
+ SDL_PIXELTYPE_INDEX4 = 2;
+ SDL_PIXELTYPE_INDEX8 = 3;
+ SDL_PIXELTYPE_PACKED8 = 4;
+ SDL_PIXELTYPE_PACKED16 = 5;
+ SDL_PIXELTYPE_PACKED32 = 6;
+ SDL_PIXELTYPE_ARRAYU8 = 7;
+ SDL_PIXELTYPE_ARRAYU16 = 8;
+ SDL_PIXELTYPE_ARRAYU32 = 9;
+ SDL_PIXELTYPE_ARRAYF16 = 10;
+ SDL_PIXELTYPE_ARRAYF32 = 11;
+
+ {** Bitmap pixel order, high bit -> low bit. *}
+ SDL_BITMAPORDER_NONE = 0;
+ SDL_BITMAPORDER_4321 = 1;
+ SDL_BITMAPORDER_1234 = 2;
+
+ {** Packed component order, high bit -> low bit. *}
+
+ SDL_PACKEDORDER_NONE = 0;
+ SDL_PACKEDORDER_XRGB = 1;
+ SDL_PACKEDORDER_RGBX = 2;
+ SDL_PACKEDORDER_ARGB = 3;
+ SDL_PACKEDORDER_RGBA = 4;
+ SDL_PACKEDORDER_XBGR = 5;
+ SDL_PACKEDORDER_BGRX = 6;
+ SDL_PACKEDORDER_ABGR = 7;
+ SDL_PACKEDORDER_BGRA = 8;
+
+ {** Array component order, low byte -> high byte. *}
+ SDL_ARRAYORDER_NONE = 0;
+ SDL_ARRAYORDER_RGB = 1;
+ SDL_ARRAYORDER_RGBA = 2;
+ SDL_ARRAYORDER_ARGB = 3;
+ SDL_ARRAYORDER_BGR = 4;
+ SDL_ARRAYORDER_BGRA = 5;
+ SDL_ARRAYORDER_ABGR = 6;
+
+ {** Packed component layout. *}
+ SDL_PACKEDLAYOUT_NONE = 0;
+ SDL_PACKEDLAYOUT_332 = 1;
+ SDL_PACKEDLAYOUT_4444 = 2;
+ SDL_PACKEDLAYOUT_1555 = 3;
+ SDL_PACKEDLAYOUT_5551 = 4;
+ SDL_PACKEDLAYOUT_565 = 5;
+ SDL_PACKEDLAYOUT_8888 = 6;
+ SDL_PACKEDLAYOUT_2101010 = 7;
+ SDL_PACKEDLAYOUT_1010102 = 8;
+
+ {
+ //todo!!
+function SDL_DEFINE_PIXELFORMAT(type, order, layour, bit, bytes: UInt32): Result;
+
+function SDL_DEFINE_PIXELFOURCC(A,B,C,D: Variant): Variant;
+
+#define SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \
+ ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
+ ((bits) << 8) | ((bytes) << 0))
+ }
+
+function SDL_PIXELFLAG(X: Cardinal): Boolean;
+function SDL_PIXELTYPE(X: Cardinal): Boolean;
+function SDL_PIXELORDER(X: Cardinal): Boolean;
+function SDL_PIXELLAYOUT(X: Cardinal): Boolean;
+function SDL_BITSPERPIXEL(X: Cardinal): Boolean;
+ {
+#define SDL_BYTESPERPIXEL(X) \
+ (SDL_ISPIXELFORMAT_FOURCC(X) ? \
+ ((((X) == SDL_PIXELFORMAT_YUY2) || \
+ ((X) == SDL_PIXELFORMAT_UYVY) || \
+ ((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
+
+#define SDL_ISPIXELFORMAT_INDEXED(format) \
+ (!SDL_ISPIXELFORMAT_FOURCC(format) && \
+ ((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \
+ (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \
+ (SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)))
+
+#define SDL_ISPIXELFORMAT_ALPHA(format) \
+ (!SDL_ISPIXELFORMAT_FOURCC(format) && \
+ ((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \
+ (SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \
+ (SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \
+ (SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA)))
+
+ function SDL_IsPixelFormat_FOURCC(format: Variant);
+
+ {* Note: If you modify this list, update SDL_GetPixelFormatName() *}
+
+const
+ SDL_PIXELFORMAT_UNKNOWN = 0;
+ SDL_PIXELFORMAT_INDEX1LSB = (1 shl 28) or
+ (SDL_PIXELTYPE_INDEX1 shl 24) or
+ (SDL_BITMAPORDER_4321 shl 20) or
+ (0 shl 16) or
+ (1 shl 8) or
+ (0 shl 0);
+
+ SDL_PIXELFORMAT_INDEX1MSB = (1 shl 28) or
+ (SDL_PIXELTYPE_INDEX1 shl 24) or
+ (SDL_BITMAPORDER_1234 shl 20) or
+ (0 shl 16) or
+ (1 shl 8) or
+ (0 shl 0);
+
+ SDL_PIXELFORMAT_INDEX4LSB = (1 shl 28) or
+ (SDL_PIXELTYPE_INDEX4 shl 24) or
+ (SDL_BITMAPORDER_4321 shl 20) or
+ (0 shl 16) or
+ (4 shl 8) or
+ (0 shl 0);
+
+ SDL_PIXELFORMAT_INDEX4MSB = (1 shl 28) or
+ (SDL_PIXELTYPE_INDEX4 shl 24) or
+ (SDL_BITMAPORDER_1234 shl 20) or
+ (0 shl 16) or
+ (4 shl 8) or
+ (0 shl 0);
+
+ SDL_PIXELFORMAT_INDEX8 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED8 shl 24) or
+ (0 shl 20) or
+ (0 shl 16) or
+ (8 shl 8) or
+ (1 shl 0);
+
+ SDL_PIXELFORMAT_RGB332 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED8 shl 24) or
+ (SDL_PACKEDORDER_XRGB shl 20) or
+ (SDL_PACKEDLAYOUT_332 shl 16) or
+ (8 shl 8) or
+ (1 shl 0);
+
+ SDL_PIXELFORMAT_RGB444 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_XRGB shl 20) or
+ (SDL_PACKEDLAYOUT_4444 shl 16) or
+ (12 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_RGB555 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_XRGB shl 20) or
+ (SDL_PACKEDLAYOUT_1555 shl 16) or
+ (15 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_BGR555 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_XBGR shl 20) or
+ (SDL_PACKEDLAYOUT_1555 shl 16) or
+ (15 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_ARGB4444 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_ARGB shl 20) or
+ (SDL_PACKEDLAYOUT_4444 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_RGBA4444 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_RGBA shl 20) or
+ (SDL_PACKEDLAYOUT_4444 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_ABGR4444 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_ABGR shl 20) or
+ (SDL_PACKEDLAYOUT_4444 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_BGRA4444 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_BGRA shl 20) or
+ (SDL_PACKEDLAYOUT_4444 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_ARGB1555 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_ARGB shl 20) or
+ (SDL_PACKEDLAYOUT_1555 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_RGBA5551 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_RGBA shl 20) or
+ (SDL_PACKEDLAYOUT_5551 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_ABGR1555 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_ABGR shl 20) or
+ (SDL_PACKEDLAYOUT_1555 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_BGRA5551 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_BGRA shl 20) or
+ (SDL_PACKEDLAYOUT_5551 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_RGB565 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_XRGB shl 20) or
+ (SDL_PACKEDLAYOUT_565 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_BGR565 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED16 shl 24) or
+ (SDL_PACKEDORDER_XBGR shl 20) or
+ (SDL_PACKEDLAYOUT_1555 shl 16) or
+ (16 shl 8) or
+ (2 shl 0);
+
+ SDL_PIXELFORMAT_RGB24 = (1 shl 28) or
+ (SDL_PIXELTYPE_ARRAYU8 shl 24) or
+ (SDL_ARRAYORDER_RGB shl 20) or
+ (0 shl 16) or
+ (24 shl 8) or
+ (3 shl 0);
+
+ SDL_PIXELFORMAT_BGR24 = (1 shl 28) or
+ (SDL_PIXELTYPE_ARRAYU8 shl 24) or
+ (SDL_ARRAYORDER_BGR shl 20) or
+ (0 shl 16) or
+ (24 shl 8) or
+ (3 shl 0);
+
+ SDL_PIXELFORMAT_RGB888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_XRGB shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (24 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_RGBX8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_RGBX shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (24 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_BGR888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_XBGR shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (24 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_BGRX8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_BGRX shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (24 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_ARGB8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_ARGB shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (32 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_RGBA8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_RGBA shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (32 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_ABGR8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_ABGR shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (32 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_BGRA8888 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_RGBX shl 20) or
+ (SDL_PACKEDLAYOUT_8888 shl 16) or
+ (32 shl 8) or
+ (4 shl 0);
+
+ SDL_PIXELFORMAT_ARGB2101010 = (1 shl 28) or
+ (SDL_PIXELTYPE_PACKED32 shl 24) or
+ (SDL_PACKEDORDER_ARGB shl 20) or
+ (SDL_PACKEDLAYOUT_2101010 shl 16)or
+ (32 shl 8) or
+ (4 shl 0);
+
+ {**< Planar mode: Y + V + U (3 planes) *}
+ SDL_PIXELFORMAT_YV12 = (Integer('Y') ) or
+ (Integer('V') shl 8) or
+ (Integer('1') shl 16) or
+ (Integer('2') shl 24);
+ {**< Planar mode: Y + U + V (3 planes) *}
+ SDL_PIXELFORMAT_IYUV = (Integer('I') ) or
+ (Integer('Y') shl 8) or
+ (Integer('U') shl 16) or
+ (Integer('V') shl 24);
+ {**< Packed mode: Y0+U0+Y1+V0 (1 plane) *}
+ SDL_PIXELFORMAT_YUY2 = (Integer('Y') ) or
+ (Integer('U') shl 8) or
+ (Integer('Y') shl 16) or
+ (Integer('2') shl 24);
+ {**< Packed mode: U0+Y0+V0+Y1 (1 plane) *}
+ SDL_PIXELFORMAT_UYVY = (Integer('U') ) or
+ (Integer('Y') shl 8) or
+ (Integer('V') shl 16) or
+ (Integer('Y') shl 24);
+ {**< Packed mode: Y0+V0+Y1+U0 (1 plane) *}
+ SDL_PIXELFORMAT_YVYU = (Integer('Y') ) or
+ (Integer('V') shl 8) or
+ (Integer('Y') shl 16) or
+ (Integer('U') shl 24);
+
+type
+ PSDL_Color = ^TSDL_Color;
+ TSDL_Color = record
+ r: UInt8;
+ g: UInt8;
+ b: UInt8;
+ unused: UInt8;
+ end;
+
+ TSDL_Colour = TSDL_Color;
+ PSDL_Colour = ^TSDL_Colour;
+
+ PSDL_Palette = ^TSDL_Palette;
+ TSDL_Palette = record
+ ncolors: SInt32;
+ colors: PSDL_Color;
+ version: UInt32;
+ refcount: SInt32;
+ end;
+
+ {**
+ * Everything in the pixel format structure is read-only.
+ *}
+
+ PSDL_PixelFormat = ^TSDL_PixelFormat;
+ TSDL_PixelFormat = record
+ format: UInt32;
+ palette: PSDL_Palette;
+ BitsPerPixel: UInt8;
+ BytesPerPixel: UInt8;
+ padding: array[0..1] of UInt8;
+ Rmask: UInt32;
+ Gmask: UInt32;
+ Bmask: UInt32;
+ Amask: UInt32;
+ Rloss: UInt8;
+ Gloss: UInt8;
+ Bloss: UInt8;
+ Aloss: UInt8;
+ Rshift: UInt8;
+ Gshift: UInt8;
+ Bshift: UInt8;
+ Ashift: UInt8;
+ refcount: SInt32;
+ next: PSDL_PixelFormat;
+ end;
+
+ {**
+ * Get the human readable name of a pixel format
+ *}
+
+function SDL_GetPixelFormatName(format: UInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPixelFormatName' {$ENDIF} {$ENDIF};
+
+ {**
+ * Convert one of the enumerated pixel formats to a bpp and RGBA masks.
+ *
+ * SDL_TRUE, or SDL_FALSE if the conversion wasn't possible.
+ *
+ * SDL_MasksToPixelFormatEnum()
+ *}
+
+function SDL_PixelFormatEnumToMasks(format: UInt32; bpp: PInt; Rmask: PUInt32; Gmask: PUInt32; Bmask: PUInt32; Amask: PUInt32): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_PixelFormatEnumToMasks' {$ENDIF} {$ENDIF};
+
+ {**
+ * Convert a bpp and RGBA masks to an enumerated pixel format.
+ *
+ * The pixel format, or SDL_PIXELFORMAT_UNKNOWN if the conversion
+ * wasn't possible.
+ *
+ * SDL_PixelFormatEnumToMasks()
+ *}
+
+function SDL_MasksToPixelFormatEnum(bpp: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MasksToPixelFormatEnum' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create an SDL_PixelFormat structure from a pixel format enum.
+ *}
+
+function SDL_AllocFormat(pixel_format: UInt32): PSDL_PixelFormat cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocFormat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Free an SDL_PixelFormat structure.
+ *}
+
+procedure SDL_FreeFormat(format: PSDL_PixelFormat) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeFormat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a palette structure with the specified number of color
+ * entries.
+ *
+ * A new palette, or nil if there wasn't enough memory.
+ *
+ * The palette entries are initialized to white.
+ *
+ * SDL_FreePalette()
+ *}
+
+function SDL_AllocPalette(ncolors: SInt32): PSDL_Palette cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocPalette' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the palette for a pixel format structure.
+ *}
+
+function SDL_SetPixelFormatPalette(format: PSDL_PixelFormat; palette: PSDL_Palette): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetPixelFormatPalette' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set a range of colors in a palette.
+ *
+ * palette The palette to modify.
+ * colors An array of colors to copy into the palette.
+ * firstcolor The index of the first palette entry to modify.
+ * ncolors The number of entries to modify.
+ *
+ * 0 on success, or -1 if not all of the colors could be set.
+ *}
+
+function SDL_SetPaletteColors(palette: PSDL_Palette; const colors: PSDL_Color; firstcolor: SInt32; ncolors: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetPaletteColors' {$ENDIF} {$ENDIF};
+
+ {**
+ * Free a palette created with SDL_AllocPalette().
+ *
+ * SDL_AllocPalette()
+ *}
+
+procedure SDL_FreePalette(palette: PSDL_Palette) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreePalette' {$ENDIF} {$ENDIF};
+
+ {**
+ * Maps an RGB triple to an opaque pixel value for a given pixel format.
+ *
+ * SDL_MapRGBA
+ *}
+
+function SDL_MapRGB(const format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MapRGB' {$ENDIF} {$ENDIF};
+
+ {**
+ * Maps an RGBA quadruple to a pixel value for a given pixel format.
+ *
+ * SDL_MapRGB
+ *}
+
+function SDL_MapRGBA(const format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8; a: UInt8): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MapRGBA' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the RGB components from a pixel of the specified format.
+ *
+ * SDL_GetRGBA
+ *}
+
+procedure SDL_GetRGB(pixel: UInt32; const format: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRGB' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the RGBA components from a pixel of the specified format.
+ *
+ * SDL_GetRGB
+ *}
+
+procedure SDL_GetRGBA(pixel: UInt32; const format: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRGBA' {$ENDIF} {$ENDIF};
+
+ {**
+ * Calculate a 256 entry gamma ramp for a gamma value.
+ *}
+
+procedure SDL_CalculateGammaRamp(gamma: Float; ramp: PUInt16) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CalculateGammaRamp' {$ENDIF} {$ENDIF};
--- /dev/null
+//from sdl_platform.h
+
+{**
+ * Gets the name of the platform.
+ *}
+function SDL_GetPlatform: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPlatform' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_power.h"
+
+ {**
+ * The basic state for the system's power supply.
+ *}
+type
+ TSDL_PowerState = (SDL_POWERSTATE_UNKNOWN, {**< cannot determine power status *}
+ SDL_POWERSTATE_ON_BATTERY, {**< Not plugged in, running on the battery *}
+ SDL_POWERSTATE_NO_BATTERY, {**< Plugged in, no battery available *}
+ SDL_POWERSTATE_CHARGING, {**< Plugged in, charging battery *}
+ SDL_POWERSTATE_CHARGED); {**< Plugged in, battery charged *}
+
+ {**
+ * Get the current power supply details.
+ *
+ * secs Seconds of battery life left. You can pass a NULL here if
+ * you don't care. Will return -1 if we can't determine a
+ * value, or we're not running on a battery.
+ *
+ * pct Percentage of battery life left, between 0 and 100. You can
+ * pass a NULL here if you don't care. Will return -1 if we
+ * can't determine a value, or we're not running on a battery.
+ *
+ * The state of the battery (if any).
+ *}
+function SDL_GetPowerInfo(secs: PInt; pct: PInt): TSDL_PowerState cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPowerInfo' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_rect.h"
+
+type
+ {**
+ * The structure that defines a point
+ *
+ * SDL_EnclosePoints
+ *}
+
+ PSDL_Point = ^TSDL_Point;
+ TSDL_Point = record
+ x: SInt32;
+ y: SInt32;
+ end;
+
+ {**
+ * A rectangle, with the origin at the upper left.
+ *
+ * SDL_RectEmpty
+ * SDL_RectEquals
+ * SDL_HasIntersection
+ * SDL_IntersectRect
+ * SDL_UnionRect
+ * SDL_EnclosePoints
+ *}
+
+ PSDL_Rect = ^TSDL_Rect;
+ TSDL_Rect = record
+ x,y: SInt32;
+ w,h: SInt32;
+ end;
+
+ {**
+ * Returns true if the rectangle has no area.
+ *}
+
+ //changed from variant(b�����h!) to TSDL_Rect
+ //maybe PSDL_Rect?
+function SDL_RectEmpty(X: TSDL_Rect): Boolean;
+
+ {**
+ * Returns true if the two rectangles are equal.
+ *}
+
+function SDL_RectEquals(A: TSDL_Rect; B: TSDL_Rect): Boolean;
+
+ {**
+ * Determine whether two rectangles intersect.
+ *
+ * SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *}
+
+function SDL_HasIntersection(const A: PSDL_Rect; const B: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HasIntersection' {$ENDIF} {$ENDIF};
+
+ {**
+ * Calculate the intersection of two rectangles.
+ *
+ * SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *}
+
+function SDL_IntersectRect(const A: PSDL_Rect; const B: PSDL_Rect; result: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IntersectRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Calculate the union of two rectangles.
+ *}
+
+procedure SDL_UnionRect(const A: PSDL_Rect; const B: PSDL_Rect; result: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnionRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Calculate a minimal rectangle enclosing a set of points
+ *
+ * SDL_TRUE if any points were within the clipping rect
+ *}
+
+function SDL_EnclosePoints(const points: PSDL_Point; count: SInt32; const clip: PSDL_Rect; result: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_EnclosePoints' {$ENDIF} {$ENDIF};
+
+ {**
+ * Calculate the intersection of a rectangle and line segment.
+ *
+ * SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
+ *}
+
+function SDL_IntersectRectAndLine(const rect: PSDL_Rect; X1: PInt; Y1: PInt; X2: PInt; Y2: PInt): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IntersectRectAndLine' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_renderer.h"
+
+ {**
+ * Flags used when creating a rendering context
+ *}
+const
+ SDL_RENDERER_SOFTWARE = $00000001; {**< The renderer is a software fallback *}
+ SDL_RENDERER_ACCELERATED = $00000002; {**< The renderer uses hardware
+ acceleration *}
+ SDL_RENDERER_PRESENTVSYNC = $00000004; {**< Present is synchronized
+ with the refresh rate *}
+ SDL_RENDERER_TARGETTEXTURE = $00000008; {**< The renderer supports
+ rendering to texture *}
+
+type
+ PSDL_RendererFlags = ^TSDL_RendererFlags;
+ TSDL_RendererFlags = Word;
+
+ {**
+ * Information on the capabilities of a render driver or context.
+ *}
+ PSDL_RendererInfo = ^TSDL_RendererInfo;
+ TSDL_RendererInfo = record
+ name: PAnsiChar; {**< The name of the renderer *}
+ flags: UInt32; {**< Supported ::SDL_RendererFlags *}
+ num_texture_formats: UInt32; {**< The number of available texture formats *}
+ texture_formats: array[0..15] of UInt32; {**< The available texture formats *}
+ max_texture_width: SInt32; {**< The maximimum texture width *}
+ max_texture_height: SInt32; {**< The maximimum texture height *}
+ end;
+
+ {**
+ * The access pattern allowed for a texture.
+ *}
+type
+ PSDL_TextureAccess = ^TSDL_TextureAccess;
+ TSDL_TextureAccess = (
+ SDL_TEXTUREACCESS_STATIC, {**< Changes rarely, not lockable *}
+ SDL_TEXTUREACCESS_STREAMING, {**< Changes frequently, lockable *}
+ SDL_TEXTUREACCESS_TARGET {**< Texture can be used as a render target *}
+ );
+
+ {**
+ * The texture channel modulation used in SDL_RenderCopy().
+ *}
+ PSDL_TextureModulate = ^TSDL_TextureModulate;
+ TSDL_TextureModulate = (
+ SDL_TEXTUREMODULATE_NONE, {**< No modulation *}
+ SDL_TEXTUREMODULATE_COLOR, {**< srcC = srcC * color *}
+ SDL_TEXTUREMODULATE_ALPHA {**< srcA = srcA * alpha *}
+ );
+
+ {**
+ * Flip constants for SDL_RenderCopyEx
+ *}
+type
+ PSDL_RendererFlip = ^TSDL_RendererFlip;
+ TSDL_RendererFlip = (SDL_FLIP_NONE, {**< Do not flip *}
+ SDL_FLIP_HORIZONTAL, {**< flip horizontally *}
+ SDL_FLIP_VERTICAL {**< flip vertically *}
+ );
+
+ {**
+ * A structure representing rendering state
+ *}
+
+ PPSDL_Renderer = ^PSDL_Renderer;
+ PSDL_Renderer = Pointer; //todo!
+
+ {**
+ * An efficient driver-specific representation of pixel data
+ *}
+ PSDL_Texture = Pointer; //todo!
+
+ {* Function prototypes *}
+
+ {**
+ * Get the number of 2D rendering drivers available for the current
+ * display.
+ *
+ * A render driver is a set of code that handles rendering and texture
+ * management on a particular display. Normally there is only one, but
+ * some drivers may have several available with different capabilities.
+ *
+ * SDL_GetRenderDriverInfo()
+ * SDL_CreateRenderer()
+ *}
+function SDL_GetNumRenderDrivers: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumRenderDrivers' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get information about a specific 2D rendering driver for the current
+ * display.
+ *
+ * index The index of the driver to query information about.
+ * info A pointer to an SDL_RendererInfo struct to be filled with
+ * information on the rendering driver.
+ *
+ * 0 on success, -1 if the index was out of range.
+ *
+ * SDL_CreateRenderer()
+ *}
+function SDL_GetRenderDriverInfo(index: SInt32; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDriverInfo' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a window and default renderer
+ *
+ * width The width of the window
+ * height The height of the window
+ * window_flags The flags used to create the window
+ * window A pointer filled with the window, or NULL on error
+ * renderer A pointer filled with the renderer, or NULL on error
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_CreateWindowAndRenderer(width: SInt32; height: SInt32; window_flags: UInt32; window: PPSDL_Window; renderer: PPSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateWindowAndRenderer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a 2D rendering context for a window.
+ *
+ * window The window where rendering is displayed.
+ * index The index of the rendering driver to initialize, or -1 to
+ * initialize the first one supporting the requested flags.
+ * flags ::SDL_RendererFlags.
+ *
+ * A valid rendering context or NULL if there was an error.
+ *
+ * SDL_CreateSoftwareRenderer()
+ * SDL_GetRendererInfo()
+ * SDL_DestroyRenderer()
+ *}
+function SDL_CreateRenderer(window: PSDL_Window; index: SInt32; flags: UInt32): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRenderer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a 2D software rendering context for a surface.
+ *
+ * surface The surface where rendering is done.
+ *
+ * A valid rendering context or NULL if there was an error.
+ *
+ * SDL_CreateRenderer()
+ * SDL_DestroyRenderer()
+ *}
+function SDL_CreateSoftwareRenderer(surface: PSDL_Surface): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSoftwareRenderer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the renderer associated with a window.
+ *}
+function SDL_GetRenderer(window: PSDL_Window): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get information about a rendering context.
+ *}
+function SDL_GetRendererInfo(renderer: PSDL_Renderer; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererInfo' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the output size of a rendering context.
+ *}
+function SDL_GetRendererOutputSize(renderer: PSDL_Renderer; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererOutputSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a texture for a rendering context.
+ *
+ * renderer The renderer.
+ * format The format of the texture.
+ * access One of the enumerated values in ::SDL_TextureAccess.
+ * w The width of the texture in pixels.
+ * h The height of the texture in pixels.
+ *
+ * The created texture is returned, or 0 if no rendering context was
+ * active, the format was unsupported, or the width or height were out
+ * of range.
+ *
+ * SDL_QueryTexture()
+ * SDL_UpdateTexture()
+ * SDL_DestroyTexture()
+ *}
+function SDL_CreateTexture(renderer: PSDL_Renderer; format: UInt32; access: SInt32; w: SInt32; h: SInt32): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a texture from an existing surface.
+ *
+ * renderer The renderer.
+ * surface The surface containing pixel data used to fill the texture.
+ *
+ * The created texture is returned, or 0 on error.
+ *
+ * The surface is not modified or freed by this function.
+ *
+ * SDL_QueryTexture()
+ * SDL_DestroyTexture()
+ *}
+function SDL_CreateTextureFromSurface(renderer: PSDL_Renderer; surface: PSDL_Surface): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTextureFromSurface' {$ENDIF} {$ENDIF};
+
+ {**
+ * Query the attributes of a texture
+ *
+ * texture A texture to be queried.
+ * format A pointer filled in with the raw format of the texture. The
+ * actual format may differ, but pixel transfers will use this
+ * format.
+ * access A pointer filled in with the actual access to the texture.
+ * w A pointer filled in with the width of the texture in pixels.
+ * h A pointer filled in with the height of the texture in pixels.
+ *
+ * 0 on success, or -1 if the texture is not valid.
+ *}
+function SDL_QueryTexture(texture: PSDL_Texture; format: PUInt32; access: PInt; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QueryTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set an additional color value used in render copy operations.
+ *
+ * texture The texture to update.
+ * r The red color value multiplied into copy operations.
+ * g The green color value multiplied into copy operations.
+ * b The blue color value multiplied into copy operations.
+ *
+ * 0 on success, or -1 if the texture is not valid or color modulation
+ * is not supported.
+ *
+ * SDL_GetTextureColorMod()
+ *}
+function SDL_SetTextureColorMod(texture: PSDL_Texture; r: UInt8; g: UInt8; b: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureColorMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the additional color value used in render copy operations.
+ *
+ * texture The texture to query.
+ * r A pointer filled in with the current red color value.
+ * g A pointer filled in with the current green color value.
+ * b A pointer filled in with the current blue color value.
+ *
+ * 0 on success, or -1 if the texture is not valid.
+ *
+ * SDL_SetTextureColorMod()
+ *}
+function SDL_GetTextureColorMod(texture: PSDL_Texture; r: PUInt8; g: PUInt8; b: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureColorMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set an additional alpha value used in render copy operations.
+ *
+ * texture The texture to update.
+ * alpha The alpha value multiplied into copy operations.
+ *
+ * 0 on success, or -1 if the texture is not valid or alpha modulation
+ * is not supported.
+ *
+ * SDL_GetTextureAlphaMod()
+ *}
+function SDL_SetTextureAlphaMod(texture: PSDL_Texture; alpha: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureAlphaMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the additional alpha value used in render copy operations.
+ *
+ * texture The texture to query.
+ * alpha A pointer filled in with the current alpha value.
+ *
+ * 0 on success, or -1 if the texture is not valid.
+ *
+ * SDL_SetTextureAlphaMod()
+ *}
+function SDL_GetTextureAlphaMod(texture: PSDL_Texture; alpha: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureAlphaMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the blend mode used for texture copy operations.
+ *
+ * texture The texture to update.
+ * blendMode ::SDL_BlendMode to use for texture blending.
+ *
+ * 0 on success, or -1 if the texture is not valid or the blend mode is
+ * not supported.
+ *
+ * If the blend mode is not supported, the closest supported mode is
+ * chosen.
+ *
+ * SDL_GetTextureBlendMode()
+ *}
+function SDL_SetTextureBlendMode(texture: PSDL_Texture; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the blend mode used for texture copy operations.
+ *
+ * texture The texture to query.
+ * blendMode A pointer filled in with the current blend mode.
+ *
+ * 0 on success, or -1 if the texture is not valid.
+ *
+ * SDL_SetTextureBlendMode()
+ *}
+function SDL_GetTextureBlendMode(texture: PSDL_Texture; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Update the given texture rectangle with new pixel data.
+ *
+ * texture The texture to update
+ * rect A pointer to the rectangle of pixels to update, or NULL to
+ * update the entire texture.
+ * pixels The raw pixel data.
+ * pitch The number of bytes between rows of pixel data.
+ *
+ * 0 on success, or -1 if the texture is not valid.
+ *
+ * This is a fairly slow function.
+ *}
+function SDL_UpdateTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Lock a portion of the texture for write-only pixel access.
+ *
+ * texture The texture to lock for access, which was created with
+ * SDL_TEXTUREACCESS_STREAMING.
+ * rect A pointer to the rectangle to lock for access. If the rect
+ * is NULL, the entire texture will be locked.
+ * pixels This is filled in with a pointer to the locked pixels,
+ * appropriately offset by the locked area.
+ * pitch This is filled in with the pitch of the locked pixels.
+ *
+ * 0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
+ *
+ * SDL_UnlockTexture()
+ *}
+function SDL_LockTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: PPointer; pitch: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Unlock a texture, uploading the changes to video memory, if needed.
+ *
+ * SDL_LockTexture()
+ *}
+procedure SDL_UnlockTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Determines whether a window supports the use of render targets
+ *
+ * renderer The renderer that will be checked
+ *
+ * SDL_TRUE if supported, SDL_FALSE if not.
+ *}
+function SDL_RenderTargetSupported(renderer: PSDL_Renderer): Boolean cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderTargetSupported' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set a texture as the current rendering target.
+ *
+ * renderer The renderer.
+ * texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
+ *
+ * 0 on success, or -1 on error
+ *
+ * SDL_GetRenderTarget()
+ *}
+function SDL_SetRenderTarget(renderer: PSDL_Renderer; texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderTarget' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the current render target or NULL for the default render target.
+ *
+ * The current render target
+ *
+ * SDL_SetRenderTarget()
+ *}
+function SDL_GetRenderTarget(renderer: PSDL_Renderer): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderTarget' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set device independent resolution for rendering
+ *
+ * renderer The renderer for which resolution should be set.
+ * w The width of the logical resolution
+ * h The height of the logical resolution
+ *
+ * This function uses the viewport and scaling functionality to allow a fixed logical
+ * resolution for rendering, regardless of the actual output resolution. If the actual
+ * output resolution doesn't have the same aspect ratio the output rendering will be
+ * centered within the output display.
+ *
+ * If the output display is a window, mouse events in the window will be filtered
+ * and scaled so they seem to arrive within the logical resolution.
+ *
+ * If this function results in scaling or subpixel drawing by the
+ * rendering backend, it will be handled using the appropriate
+ * quality hints.
+ *
+ * SDL_RenderGetLogicalSize()
+ * SDL_RenderSetScale()
+ * SDL_RenderSetViewport()
+ *}
+function SDL_RenderSetLogicalSize(renderer: PSDL_Renderer; w: SInt32; h: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetLogicalSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get device independent resolution for rendering
+ *
+ * renderer The renderer from which resolution should be queried.
+ * w A pointer filled with the width of the logical resolution
+ * h A pointer filled with the height of the logical resolution
+ *
+ * SDL_RenderSetLogicalSize()
+ *}
+procedure SDL_RenderGetLogicalSize(renderer: PSDL_Renderer; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetLogicalSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the drawing area for rendering on the current target.
+ *
+ * renderer The renderer for which the drawing area should be set.
+ * rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
+ *
+ * The x,y of the viewport rect represents the origin for rendering.
+ *
+ * 0 on success, or -1 on error
+ *
+ * If the window associated with the renderer is resized, the viewport is automatically reset.
+ *
+ * SDL_RenderGetViewport()
+ * SDL_RenderSetLogicalSize()
+ *}
+function SDL_RenderSetViewport(renderer: PSDL_Renderer; const rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetViewport' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the drawing area for the current target.
+ *
+ * SDL_RenderSetViewport()
+ *}
+procedure SDL_RenderGetViewport(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetViewport' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the clip rectangle for the current target.
+ *
+ * renderer The renderer for which clip rectangle should be set.
+ * rect A pointer to the rectangle to set as the clip rectangle, or
+ * NULL to disable clipping.
+ *
+ * 0 on success, or -1 on error
+ *
+ * SDL_RenderGetClipRect()
+ *}
+function SDL_RenderSetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetClipRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the clip rectangle for the current target.
+ *
+ * renderer The renderer from which clip rectangle should be queried.
+ * rect A pointer filled in with the current clip rectangle, or
+ * an empty rectangle if clipping is disabled.
+ *
+ * SDL_RenderSetClipRect()
+ *}
+procedure SDL_RenderGetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetClipRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the drawing scale for rendering on the current target.
+ *
+ * renderer The renderer for which the drawing scale should be set.
+ * scaleX The horizontal scaling factor
+ * scaleY The vertical scaling factor
+ *
+ * The drawing coordinates are scaled by the x/y scaling factors
+ * before they are used by the renderer. This allows resolution
+ * independent drawing with a single coordinate system.
+ *
+ * If this results in scaling or subpixel drawing by the
+ * rendering backend, it will be handled using the appropriate
+ * quality hints. For best results use integer scaling factors.
+ *
+ * SDL_RenderGetScale()
+ * SDL_RenderSetLogicalSize()
+ *}
+function SDL_RenderSetScale(renderer: PSDL_Renderer; scaleX: Float; scaleY: Float): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetScale' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the drawing scale for the current target.
+ *
+ * renderer The renderer from which drawing scale should be queried.
+ * scaleX A pointer filled in with the horizontal scaling factor
+ * scaleY A pointer filled in with the vertical scaling factor
+ *
+ * SDL_RenderSetScale()
+ *}
+procedure SDL_RenderGetScale(renderer: PSDL_Renderer; scaleX: PFloat; scaleY: PFloat) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetScale' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the color used for drawing operations (Rect, Line and Clear).
+ *
+ * renderer The renderer for which drawing color should be set.
+ * r The red value used to draw on the rendering target.
+ * g The green value used to draw on the rendering target.
+ * b The blue value used to draw on the rendering target.
+ * a The alpha value used to draw on the rendering target, usually
+ * SDL_ALPHA_OPAQUE (255).
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_SetRenderDrawColor(renderer: PSDL_Renderer; r: UInt8; g: UInt8; b: UInt8; a: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawColor' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the color used for drawing operations (Rect, Line and Clear).
+ *
+ * renderer The renderer from which drawing color should be queried.
+ * r A pointer to the red value used to draw on the rendering target.
+ * g A pointer to the green value used to draw on the rendering target.
+ * b A pointer to the blue value used to draw on the rendering target.
+ * a A pointer to the alpha value used to draw on the rendering target,
+ * usually SDL_ALPHA_OPAQUE (255).
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_GetRenderDrawColor(renderer: PSDL_Renderer; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawColor' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the blend mode used for drawing operations (Fill and Line).
+ *
+ * renderer The renderer for which blend mode should be set.
+ * blendMode SDL_BlendMode to use for blending.
+ *
+ * 0 on success, or -1 on error
+ *
+ * If the blend mode is not supported, the closest supported mode is
+ * chosen.
+ *
+ * SDL_GetRenderDrawBlendMode()
+ *}
+function SDL_SetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the blend mode used for drawing operations.
+ *
+ * renderer The renderer from which blend mode should be queried.
+ * blendMode A pointer filled in with the current blend mode.
+ *
+ * 0 on success, or -1 on error
+ *
+ * SDL_SetRenderDrawBlendMode()
+ *}
+function SDL_GetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Clear the current rendering target with the drawing color
+ *
+ * This function clears the entire rendering target, ignoring the viewport.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderClear(renderer: PSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderClear' {$ENDIF} {$ENDIF};
+
+ {**
+ * Draw a point on the current rendering target.
+ *
+ * renderer The renderer which should draw a point.
+ * x The x coordinate of the point.
+ * y The y coordinate of the point.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawPoint(renderer: PSDL_Renderer; x: SInt32; y: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoint' {$ENDIF} {$ENDIF};
+
+ {**
+ * Draw multiple points on the current rendering target.
+ *
+ * renderer The renderer which should draw multiple points.
+ * points The points to draw
+ * count The number of points to draw
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawPoints(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoints' {$ENDIF} {$ENDIF};
+
+ {**
+ * Draw a line on the current rendering target.
+ *
+ * renderer The renderer which should draw a line.
+ * x1 The x coordinate of the start point.
+ * y1 The y coordinate of the start point.
+ * x2 The x coordinate of the end point.
+ * y2 The y coordinate of the end point.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawLine(renderer: PSDL_Renderer; x1: SInt32; y1: SInt32; x2: SInt32; y2: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLine' {$ENDIF} {$ENDIF};
+
+ {**
+ * \brief Draw a series of connected lines on the current rendering target.
+ *
+ * \param renderer The renderer which should draw multiple lines.
+ * \param points The points along the lines
+ * \param count The number of points, drawing count-1 lines
+ *
+ * \return 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawLines(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLines' {$ENDIF} {$ENDIF};
+
+ {**
+ * Draw a rectangle on the current rendering target.
+ *
+ * renderer The renderer which should draw a rectangle.
+ * rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Draw some number of rectangles on the current rendering target.
+ *
+ * renderer The renderer which should draw multiple rectangles.
+ * rects A pointer to an array of destination rectangles.
+ * count The number of rectangles.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderDrawRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRects' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill a rectangle on the current rendering target with the drawing color.
+ *
+ * renderer The renderer which should fill a rectangle.
+ * rect A pointer to the destination rectangle, or NULL for the entire
+ * rendering target.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderFillRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill some number of rectangles on the current rendering target with the drawing color.
+ *
+ * renderer The renderer which should fill multiple rectangles.
+ * rects A pointer to an array of destination rectangles.
+ * count The number of rectangles.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderFillRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRects' {$ENDIF} {$ENDIF};
+
+ {**
+ * Copy a portion of the texture to the current rendering target.
+ *
+ * renderer The renderer which should copy parts of a texture.
+ * texture The source texture.
+ * srcrect A pointer to the source rectangle, or NULL for the entire
+ * texture.
+ * dstrect A pointer to the destination rectangle, or NULL for the
+ * entire rendering target.
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderCopy(renderer: PSDL_Renderer; texture: PSDL_Texture; srcrect: PSDL_Rect; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopy' {$ENDIF} {$ENDIF};
+
+ {**
+ * Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
+ *
+ * renderer The renderer which should copy parts of a texture.
+ * texture The source texture.
+ * srcrect A pointer to the source rectangle, or NULL for the entire
+ * texture.
+ * dstrect A pointer to the destination rectangle, or NULL for the
+ * entire rendering target.
+ * angle An angle in degrees that indicates the rotation that will be applied to dstrect
+ * center A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done aroud dstrect.w/2, dstrect.h/2)
+ * flip An SDL_RendererFlip value stating which flipping actions should be performed on the texture
+ *
+ * 0 on success, or -1 on error
+ *}
+function SDL_RenderCopyEx(renderer: PSDL_Renderer; texture: PSDL_Texture; const srcrect: PSDL_Rect; dstrect: PSDL_Rect; angle: Double; center: PSDL_Point; flip: PSDL_RendererFlip): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopyEx' {$ENDIF} {$ENDIF};
+
+ {**
+ * Read pixels from the current rendering target.
+ *
+ * renderer The renderer from which pixels should be read.
+ * rect A pointer to the rectangle to read, or NULL for the entire
+ * render target.
+ * format The desired format of the pixel data, or 0 to use the format
+ * of the rendering target
+ * pixels A pointer to be filled in with the pixel data
+ * pitch The pitch of the pixels parameter.
+ *
+ * 0 on success, or -1 if pixel reading is not supported.
+ *
+ * This is a very slow operation, and should not be used frequently.
+ *}
+function SDL_RenderReadPixels(renderer: PSDL_Renderer; rect: PSDL_Rect; format: UInt32; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderReadPixels' {$ENDIF} {$ENDIF};
+
+ {**
+ * Update the screen with rendering performed.
+ *}
+procedure SDL_RenderPresent(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderPresent' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy the specified texture.
+ *
+ * SDL_CreateTexture()
+ * SDL_CreateTextureFromSurface()
+ *}
+procedure SDL_DestroyTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy the rendering context for a window and free associated
+ * textures.
+ *
+ * SDL_CreateRenderer()
+ *}
+procedure SDL_DestroyRenderer(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyRenderer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Bind the texture to the current OpenGL/ES/ES2 context for use with
+ * OpenGL instructions.
+ *
+ * texture The SDL texture to bind
+ * texw A pointer to a float that will be filled with the texture width
+ * texh A pointer to a float that will be filled with the texture height
+ *
+ * 0 on success, or -1 if the operation is not supported
+ *}
+function SDL_GL_BindTexture(texture: PSDL_Texture; texw: PFloat; texh: PFloat): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_BindTexture' {$ENDIF} {$ENDIF};
+
+ {**
+ * Unbind a texture from the current OpenGL/ES/ES2 context.
+ *
+ * texture The SDL texture to unbind
+ *
+ * 0 on success, or -1 if the operation is not supported
+ *}
+function SDL_GL_UnbindTexture(texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_UnbindTexture' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_rwops"
+
+const
+ {* RWops Types *}
+ SDL_RWOPS_UNKNOWN = 0; {* Unknown stream type *}
+ SDL_RWOPS_WINFILE = 1; {* Win32 file *}
+ SDL_RWOPS_STDFILE = 2; {* Stdio file *}
+ SDL_RWOPS_JNIFILE = 3; {* Android asset *}
+ SDL_RWOPS_MEMORY = 4; {* Memory stream *}
+ SDL_RWOPS_MEMORY_RO = 5; {* Read-Only memory stream *}
+
+type
+ PSDL_RWops = ^TSDL_RWops;
+
+ {**
+ * This is the read/write operation structure -- very basic.
+ *}
+
+ {**
+ * Return the size of the file in this rwops, or -1 if unknown
+ *}
+ TSize = function(context: PSDL_RWops): SInt64; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+ {**
+ * Seek to offset relative to whence, one of stdio's whence values:
+ * RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+ *
+ * the final offset in the data stream, or -1 on error.
+ *}
+ TSeek = function(context: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+ {**
+ * Read up to maxnum objects each of size size from the data
+ * stream to the area pointed at by ptr.
+ *
+ * the number of objects read, or 0 at error or end of file.
+ *}
+
+ TRead = function(context: PSDL_RWops; ptr: Pointer; size: size_t; maxnum: size_t): size_t; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+ {**
+ * Write exactly num objects each of size size from the area
+ * pointed at by ptr to data stream.
+ *
+ * the number of objects written, or 0 at error or end of file.
+ *}
+
+ TWrite = function(context: PSDL_RWops; const ptr: Pointer; size: size_t; num: size_t): size_t; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+ {**
+ * Close and free an allocated SDL_RWops structure.
+ *
+ * 0 if successful or -1 on write error when flushing data.
+ *}
+
+ TClose = function(context: PSDL_RWops): SInt32; {$IFNDEF GPC} cdecl; {$ENDIF}
+
+ TStdio = record
+ autoclose: TSDL_Bool;
+ fp: file;
+ end;
+
+ TMem = record
+ base: PUInt8;
+ here: PUInt8;
+ stop: PUInt8;
+ end;
+
+ TUnknown = record
+ data1: Pointer;
+ end;
+
+ TAndroidIO = record
+ fileNameRef: Pointer;
+ inputStreamRef: Pointer;
+ readableByteChannelRef: Pointer;
+ readMethod: Pointer;
+ assetFileDescriptorRef: Pointer;
+ position: LongInt;
+ size: LongInt;
+ offset: LongInt;
+ fd: SInt32;
+ end;
+
+ TWindowsIOBuffer = record
+ data: Pointer;
+ size: size_t;
+ left: size_t;
+ end;
+
+ TWindowsIO = record
+ append: TSDL_Bool;
+ h: Pointer;
+ buffer: TWindowsIOBuffer;
+ end;
+
+ TSDL_RWops = packed record
+ size: TSize;
+ seek: TSeek;
+ read: TRead;
+ write: TWrite;
+ close: TClose;
+
+ _type: UInt32;
+
+ case Integer of
+ 0: (stdio: TStdio);
+ 1: (mem: TMem);
+ 2: (unknown: TUnknown);
+ {$IFDEF ANDROID}
+ 3: (androidio: TAndroidIO);
+ {$ENDIF}
+ {$IFDEF WINDOWS}
+ 3: (windowsio: TWindowsIO);
+ {$ENDIF}
+ end;
+
+ {**
+ * RWFrom functions
+ *
+ * Functions to create SDL_RWops structures from various data streams.
+ *}
+
+function SDL_RWFromFile(const _file: PAnsiChar; const mode: PAnsiChar): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromFile' {$ENDIF} {$ENDIF};
+
+ {function SDL_RWFromFP(fp: file; autoclose: TSDL_Bool): PSDL_RWops; cdecl; external SDL_LibName;} //don't know if this works
+
+function SDL_RWFromFP(fp: Pointer; autoclose: TSDL_Bool): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromFP' {$ENDIF} {$ENDIF};
+
+function SDL_RWFromMem(mem: Pointer; size: SInt32): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromMem' {$ENDIF} {$ENDIF};
+function SDL_RWFromConstMem(const mem: Pointer; size: SInt32): PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RWFromConstMem' {$ENDIF} {$ENDIF};
+
+{*RWFrom functions*}
+
+
+function SDL_AllocRW: PSDL_RWops; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AllocRW' {$ENDIF} {$ENDIF};
+procedure SDL_FreeRW(area: PSDL_RWops); cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeRW' {$ENDIF} {$ENDIF};
+
+const
+ RW_SEEK_SET = 0; {**< Seek from the beginning of data *}
+ RW_SEEK_CUR = 1; {**< Seek relative to current read point *}
+ RW_SEEK_END = 2; {**< Seek relative to the end of data *}
+
+ {**
+ * Read/write macros
+ *
+ * Macros to easily read and write from an SDL_RWops structure.
+ *}
+
+ function SDL_RWsize(ctx: PSDL_RWops): SInt64;
+ function SDL_RWseek(ctx: PSDL_RWops; offset: SInt64; whence: SInt32): SInt64;
+ function SDL_RWtell(ctx: PSDL_RWops): SInt64;
+ function SDL_RWread(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+ function SDL_RWwrite(ctx: PSDL_RWops; ptr: Pointer; size: size_t; n: size_t): size_t;
+ function SDL_RWclose(ctx: PSDL_RWops): SInt32;
+ { Read/write macros }
+
+
+ {**
+ * Read endian functions
+ *
+ * Read an item of the specified endianness and return in native format.
+ *}
+
+function SDL_ReadU8(src: PSDL_RWops): UInt8 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadU8' {$ENDIF} {$ENDIF};
+function SDL_ReadLE16(src: PSDL_RWops): UInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE16' {$ENDIF} {$ENDIF};
+function SDL_ReadBE16(src: PSDL_RWops): UInt16 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE16' {$ENDIF} {$ENDIF};
+function SDL_ReadLE32(src: PSDL_RWops): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE32' {$ENDIF} {$ENDIF};
+function SDL_ReadBE32(src: PSDL_RWops): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE32' {$ENDIF} {$ENDIF};
+function SDL_ReadLE64(src: PSDL_RWops): UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadLE64' {$ENDIF} {$ENDIF};
+function SDL_ReadBE64(src: PSDL_RWops): UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ReadBE64' {$ENDIF} {$ENDIF};
+
+ {*Read endian functions*}
+
+ {**
+ * Write endian functions
+ *
+ * Write an item of native format to the specified endianness.
+ *}
+
+function SDL_WriteU8(dst: PSDL_RWops; value: UInt8): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteU8' {$ENDIF} {$ENDIF};
+function SDL_WriteLE16(dst: PSDL_RWops; value: UInt16): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE16' {$ENDIF} {$ENDIF};
+function SDL_WriteBE16(dst: PSDL_RWops; value: UInt16): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE16' {$ENDIF} {$ENDIF};
+function SDL_WriteLE32(dst: PSDL_RWops; value: UInt32): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE32' {$ENDIF} {$ENDIF};
+function SDL_WriteBE32(dst: PSDL_RWops; value: UInt32): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE32' {$ENDIF} {$ENDIF};
+function SDL_WriteLE64(dst: PSDL_RWops; value: UInt64): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteLE64' {$ENDIF} {$ENDIF};
+function SDL_WriteBE64(dst: PSDL_RWops; value: UInt64): size_t cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WriteBE64' {$ENDIF} {$ENDIF};
+ { Write endian functions }
--- /dev/null
+//from "sdl_scancode.h"
+
+ {**
+ * The SDL keyboard scancode representation.
+ *
+ * Values of this type are used to represent keyboard keys, among other places
+ * in the SDL_Keysym.scancode key.keysym.scancode \endlink field of the
+ * SDL_Event structure.
+ *
+ * The values in this enumeration are based on the USB usage page standard:
+ * http://www.usb.org/developers/devclass_docs/Hut1_12v2.pdf
+ *}
+
+const
+ SDL_SCANCODE_UNKNOWN = 0;
+
+ {**
+ * Usage page $07
+ *
+ * These values are from usage page $07 (USB keyboard page).
+ *}
+
+ SDL_SCANCODE_A = 4;
+ SDL_SCANCODE_B = 5;
+ SDL_SCANCODE_C = 6;
+ SDL_SCANCODE_D = 7;
+ SDL_SCANCODE_E = 8;
+ SDL_SCANCODE_F = 9;
+ SDL_SCANCODE_G = 10;
+ SDL_SCANCODE_H = 11;
+ SDL_SCANCODE_I = 12;
+ SDL_SCANCODE_J = 13;
+ SDL_SCANCODE_K = 14;
+ SDL_SCANCODE_L = 15;
+ SDL_SCANCODE_M = 16;
+ SDL_SCANCODE_N = 17;
+ SDL_SCANCODE_O = 18;
+ SDL_SCANCODE_P = 19;
+ SDL_SCANCODE_Q = 20;
+ SDL_SCANCODE_R = 21;
+ SDL_SCANCODE_S = 22;
+ SDL_SCANCODE_T = 23;
+ SDL_SCANCODE_U = 24;
+ SDL_SCANCODE_V = 25;
+ SDL_SCANCODE_W = 26;
+ SDL_SCANCODE_X = 27;
+ SDL_SCANCODE_Y = 28;
+ SDL_SCANCODE_Z = 29;
+
+ SDL_SCANCODE_1 = 30;
+ SDL_SCANCODE_2 = 31;
+ SDL_SCANCODE_3 = 32;
+ SDL_SCANCODE_4 = 33;
+ SDL_SCANCODE_5 = 34;
+ SDL_SCANCODE_6 = 35;
+ SDL_SCANCODE_7 = 36;
+ SDL_SCANCODE_8 = 37;
+ SDL_SCANCODE_9 = 38;
+ SDL_SCANCODE_0 = 39;
+
+ SDL_SCANCODE_RETURN = 40;
+ SDL_SCANCODE_ESCAPE = 41;
+ SDL_SCANCODE_BACKSPACE = 42;
+ SDL_SCANCODE_TAB = 43;
+ SDL_SCANCODE_SPACE = 44;
+
+ SDL_SCANCODE_MINUS = 45;
+ SDL_SCANCODE_EQUALS = 46;
+ SDL_SCANCODE_LEFTBRACKET = 47;
+ SDL_SCANCODE_RIGHTBRACKET = 48;
+ SDL_SCANCODE_BACKSLASH = 49; {**< Located at the lower left of the return
+ * key on ISO keyboards and at the right end
+ * of the QWERTY row on ANSI keyboards.
+ * Produces REVERSE SOLIDUS (backslash) and
+ * VERTICAL LINE in a US layout; REVERSE
+ * SOLIDUS and VERTICAL LINE in a UK Mac
+ * layout; NUMBER SIGN and TILDE in a UK
+ * Windows layout; DOLLAR SIGN and POUND SIGN
+ * in a Swiss German layout; NUMBER SIGN and
+ * APOSTROPHE in a German layout; GRAVE
+ * ACCENT and POUND SIGN in a French Mac
+ * layout; and ASTERISK and MICRO SIGN in a
+ * French Windows layout.
+ *}
+ SDL_SCANCODE_NONUSHASH = 50; {**< ISO USB keyboards actually use this code
+ * instead of 49 for the same key; but all
+ * OSes I've seen treat the two codes
+ * identically. So; as an implementor; unless
+ * your keyboard generates both of those
+ * codes and your OS treats them differently;
+ * you should generate SDL_SCANCODE_BACKSLASH
+ * instead of this code. As a user; you
+ * should not rely on this code because SDL
+ * will never generate it with most (all?)
+ * keyboards.
+ *}
+ SDL_SCANCODE_SEMICOLON = 51;
+ SDL_SCANCODE_APOSTROPHE = 52;
+ SDL_SCANCODE_GRAVE = 53; {**< Located in the top left corner (on both ANSI
+ * and ISO keyboards). Produces GRAVE ACCENT and
+ * TILDE in a US Windows layout and in US and UK
+ * Mac layouts on ANSI keyboards; GRAVE ACCENT
+ * and NOT SIGN in a UK Windows layout; SECTION
+ * SIGN and PLUS-MINUS SIGN in US and UK Mac
+ * layouts on ISO keyboards; SECTION SIGN and
+ * DEGREE SIGN in a Swiss German layout (Mac:
+ * only on ISO keyboards); CIRCUMFLEX ACCENT and
+ * DEGREE SIGN in a German layout (Mac: only on
+ * ISO keyboards); SUPERSCRIPT TWO and TILDE in a
+ * French Windows layout; COMMERCIAL AT and
+ * NUMBER SIGN in a French Mac layout on ISO
+ * keyboards; and LESS-THAN SIGN and GREATER-THAN
+ * SIGN in a Swiss German; German; or French Mac
+ * layout on ANSI keyboards.
+ *}
+ SDL_SCANCODE_COMMA = 54;
+ SDL_SCANCODE_PERIOD = 55;
+ SDL_SCANCODE_SLASH = 56;
+
+ SDL_SCANCODE_CAPSLOCK = 57;
+
+ SDL_SCANCODE_F1 = 58;
+ SDL_SCANCODE_F2 = 59;
+ SDL_SCANCODE_F3 = 60;
+ SDL_SCANCODE_F4 = 61;
+ SDL_SCANCODE_F5 = 62;
+ SDL_SCANCODE_F6 = 63;
+ SDL_SCANCODE_F7 = 64;
+ SDL_SCANCODE_F8 = 65;
+ SDL_SCANCODE_F9 = 66;
+ SDL_SCANCODE_F10 = 67;
+ SDL_SCANCODE_F11 = 68;
+ SDL_SCANCODE_F12 = 69;
+
+ SDL_SCANCODE_PRINTSCREEN = 70;
+ SDL_SCANCODE_SCROLLLOCK = 71;
+ SDL_SCANCODE_PAUSE = 72;
+ SDL_SCANCODE_INSERT = 73; {**< insert on PC; help on some Mac keyboards (but
+ does send code 73; not 117) *}
+ SDL_SCANCODE_HOME = 74;
+ SDL_SCANCODE_PAGEUP = 75;
+ SDL_SCANCODE_DELETE = 76;
+ SDL_SCANCODE_END = 77;
+ SDL_SCANCODE_PAGEDOWN = 78;
+ SDL_SCANCODE_RIGHT = 79;
+ SDL_SCANCODE_LEFT = 80;
+ SDL_SCANCODE_DOWN = 81;
+ SDL_SCANCODE_UP = 82;
+
+ SDL_SCANCODE_NUMLOCKCLEAR = 83; {**< num lock on PC; clear on Mac keyboards
+ *}
+ SDL_SCANCODE_KP_DIVIDE = 84;
+ SDL_SCANCODE_KP_MULTIPLY = 85;
+ SDL_SCANCODE_KP_MINUS = 86;
+ SDL_SCANCODE_KP_PLUS = 87;
+ SDL_SCANCODE_KP_ENTER = 88;
+ SDL_SCANCODE_KP_1 = 89;
+ SDL_SCANCODE_KP_2 = 90;
+ SDL_SCANCODE_KP_3 = 91;
+ SDL_SCANCODE_KP_4 = 92;
+ SDL_SCANCODE_KP_5 = 93;
+ SDL_SCANCODE_KP_6 = 94;
+ SDL_SCANCODE_KP_7 = 95;
+ SDL_SCANCODE_KP_8 = 96;
+ SDL_SCANCODE_KP_9 = 97;
+ SDL_SCANCODE_KP_0 = 98;
+ SDL_SCANCODE_KP_PERIOD = 99;
+
+ SDL_SCANCODE_NONUSBACKSLASH = 100; {**< This is the additional key that ISO
+ * keyboards have over ANSI ones;
+ * located between left shift and Y.
+ * Produces GRAVE ACCENT and TILDE in a
+ * US or UK Mac layout; REVERSE SOLIDUS
+ * (backslash) and VERTICAL LINE in a
+ * US or UK Windows layout; and
+ * LESS-THAN SIGN and GREATER-THAN SIGN
+ * in a Swiss German; German; or French
+ * layout. *}
+ SDL_SCANCODE_APPLICATION = 101; {**< windows contextual menu; compose *}
+ SDL_SCANCODE_POWER = 102; {**< The USB document says this is a status flag;
+ * not a physical key - but some Mac keyboards
+ * do have a power key. *}
+ SDL_SCANCODE_KP_EQUALS = 103;
+ SDL_SCANCODE_F13 = 104;
+ SDL_SCANCODE_F14 = 105;
+ SDL_SCANCODE_F15 = 106;
+ SDL_SCANCODE_F16 = 107;
+ SDL_SCANCODE_F17 = 108;
+ SDL_SCANCODE_F18 = 109;
+ SDL_SCANCODE_F19 = 110;
+ SDL_SCANCODE_F20 = 111;
+ SDL_SCANCODE_F21 = 112;
+ SDL_SCANCODE_F22 = 113;
+ SDL_SCANCODE_F23 = 114;
+ SDL_SCANCODE_F24 = 115;
+ SDL_SCANCODE_EXECUTE = 116;
+ SDL_SCANCODE_HELP = 117;
+ SDL_SCANCODE_MENU = 118;
+ SDL_SCANCODE_SELECT = 119;
+ SDL_SCANCODE_STOP = 120;
+ SDL_SCANCODE_AGAIN = 121; {**< redo *}
+ SDL_SCANCODE_UNDO = 122;
+ SDL_SCANCODE_CUT = 123;
+ SDL_SCANCODE_COPY = 124;
+ SDL_SCANCODE_PASTE = 125;
+ SDL_SCANCODE_FIND = 126;
+ SDL_SCANCODE_MUTE = 127;
+ SDL_SCANCODE_VOLUMEUP = 128;
+ SDL_SCANCODE_VOLUMEDOWN = 129;
+ {* not sure whether there's a reason to enable these *}
+ {* SDL_SCANCODE_LOCKINGCAPSLOCK = 130; *}
+ {* SDL_SCANCODE_LOCKINGNUMLOCK = 131; *}
+ {* SDL_SCANCODE_LOCKINGSCROLLLOCK = 132; *}
+ SDL_SCANCODE_KP_COMMA = 133;
+ SDL_SCANCODE_KP_EQUALSAS400 = 134;
+
+ SDL_SCANCODE_INTERNATIONAL1 = 135; {**< used on Asian keyboards; see footnotes in USB doc *}
+ SDL_SCANCODE_INTERNATIONAL2 = 136;
+ SDL_SCANCODE_INTERNATIONAL3 = 137; {**< Yen *}
+ SDL_SCANCODE_INTERNATIONAL4 = 138;
+ SDL_SCANCODE_INTERNATIONAL5 = 139;
+ SDL_SCANCODE_INTERNATIONAL6 = 140;
+ SDL_SCANCODE_INTERNATIONAL7 = 141;
+ SDL_SCANCODE_INTERNATIONAL8 = 142;
+ SDL_SCANCODE_INTERNATIONAL9 = 143;
+ SDL_SCANCODE_LANG1 = 144; {**< Hangul{English toggle *}
+ SDL_SCANCODE_LANG2 = 145; {**< Hanja conversion *}
+ SDL_SCANCODE_LANG3 = 146; {**< Katakana *}
+ SDL_SCANCODE_LANG4 = 147; {**< Hiragana *}
+ SDL_SCANCODE_LANG5 = 148; {**< Zenkaku{Hankaku *}
+ SDL_SCANCODE_LANG6 = 149; {**< reserved *}
+ SDL_SCANCODE_LANG7 = 150; {**< reserved *}
+ SDL_SCANCODE_LANG8 = 151; {**< reserved *}
+ SDL_SCANCODE_LANG9 = 152; {**< reserved *}
+
+ SDL_SCANCODE_ALTERASE = 153; {**< Erase-Eaze *}
+ SDL_SCANCODE_SYSREQ = 154;
+ SDL_SCANCODE_CANCEL = 155;
+ SDL_SCANCODE_CLEAR = 156;
+ SDL_SCANCODE_PRIOR = 157;
+ SDL_SCANCODE_RETURN2 = 158;
+ SDL_SCANCODE_SEPARATOR = 159;
+ SDL_SCANCODE_OUT = 160;
+ SDL_SCANCODE_OPER = 161;
+ SDL_SCANCODE_CLEARAGAIN = 162;
+ SDL_SCANCODE_CRSEL = 163;
+ SDL_SCANCODE_EXSEL = 164;
+
+ SDL_SCANCODE_KP_00 = 176;
+ SDL_SCANCODE_KP_000 = 177;
+ SDL_SCANCODE_THOUSANDSSEPARATOR = 178;
+ SDL_SCANCODE_DECIMALSEPARATOR = 179;
+ SDL_SCANCODE_CURRENCYUNIT = 180;
+ SDL_SCANCODE_CURRENCYSUBUNIT = 181;
+ SDL_SCANCODE_KP_LEFTPAREN = 182;
+ SDL_SCANCODE_KP_RIGHTPAREN = 183;
+ SDL_SCANCODE_KP_LEFTBRACE = 184;
+ SDL_SCANCODE_KP_RIGHTBRACE = 185;
+ SDL_SCANCODE_KP_TAB = 186;
+ SDL_SCANCODE_KP_BACKSPACE = 187;
+ SDL_SCANCODE_KP_A = 188;
+ SDL_SCANCODE_KP_B = 189;
+ SDL_SCANCODE_KP_C = 190;
+ SDL_SCANCODE_KP_D = 191;
+ SDL_SCANCODE_KP_E = 192;
+ SDL_SCANCODE_KP_F = 193;
+ SDL_SCANCODE_KP_XOR = 194;
+ SDL_SCANCODE_KP_POWER = 195;
+ SDL_SCANCODE_KP_PERCENT = 196;
+ SDL_SCANCODE_KP_LESS = 197;
+ SDL_SCANCODE_KP_GREATER = 198;
+ SDL_SCANCODE_KP_AMPERSAND = 199;
+ SDL_SCANCODE_KP_DBLAMPERSAND = 200;
+ SDL_SCANCODE_KP_VERTICALBAR = 201;
+ SDL_SCANCODE_KP_DBLVERTICALBAR = 202;
+ SDL_SCANCODE_KP_COLON = 203;
+ SDL_SCANCODE_KP_HASH = 204;
+ SDL_SCANCODE_KP_SPACE = 205;
+ SDL_SCANCODE_KP_AT = 206;
+ SDL_SCANCODE_KP_EXCLAM = 207;
+ SDL_SCANCODE_KP_MEMSTORE = 208;
+ SDL_SCANCODE_KP_MEMRECALL = 209;
+ SDL_SCANCODE_KP_MEMCLEAR = 210;
+ SDL_SCANCODE_KP_MEMADD = 211;
+ SDL_SCANCODE_KP_MEMSUBTRACT = 212;
+ SDL_SCANCODE_KP_MEMMULTIPLY = 213;
+ SDL_SCANCODE_KP_MEMDIVIDE = 214;
+ SDL_SCANCODE_KP_PLUSMINUS = 215;
+ SDL_SCANCODE_KP_CLEAR = 216;
+ SDL_SCANCODE_KP_CLEARENTRY = 217;
+ SDL_SCANCODE_KP_BINARY = 218;
+ SDL_SCANCODE_KP_OCTAL = 219;
+ SDL_SCANCODE_KP_DECIMAL = 220;
+ SDL_SCANCODE_KP_HEXADECIMAL = 221;
+
+ SDL_SCANCODE_LCTRL = 224;
+ SDL_SCANCODE_LSHIFT = 225;
+ SDL_SCANCODE_LALT = 226; {**< alt; option *}
+ SDL_SCANCODE_LGUI = 227; {**< windows; command (apple); meta *}
+ SDL_SCANCODE_RCTRL = 228;
+ SDL_SCANCODE_RSHIFT = 229;
+ SDL_SCANCODE_RALT = 230; {**< alt gr; option *}
+ SDL_SCANCODE_RGUI = 231; {**< windows; command (apple); meta *}
+
+ SDL_SCANCODE_MODE = 257; {**< I'm not sure if this is really not covered
+ * by any of the above; but since there's a
+ * special KMOD_MODE for it I'm adding it here
+ *}
+
+ {*Usage page $07*}
+
+ {**
+ * Usage page $0C
+ *
+ * These values are mapped from usage page $0C (USB consumer page).
+ *}
+
+ SDL_SCANCODE_AUDIONEXT = 258;
+ SDL_SCANCODE_AUDIOPREV = 259;
+ SDL_SCANCODE_AUDIOSTOP = 260;
+ SDL_SCANCODE_AUDIOPLAY = 261;
+ SDL_SCANCODE_AUDIOMUTE = 262;
+ SDL_SCANCODE_MEDIASELECT = 263;
+ SDL_SCANCODE_WWW = 264;
+ SDL_SCANCODE_MAIL = 265;
+ SDL_SCANCODE_CALCULATOR = 266;
+ SDL_SCANCODE_COMPUTER = 267;
+ SDL_SCANCODE_AC_SEARCH = 268;
+ SDL_SCANCODE_AC_HOME = 269;
+ SDL_SCANCODE_AC_BACK = 270;
+ SDL_SCANCODE_AC_FORWARD = 271;
+ SDL_SCANCODE_AC_STOP = 272;
+ SDL_SCANCODE_AC_REFRESH = 273;
+ SDL_SCANCODE_AC_BOOKMARKS = 274;
+
+ {*Usage page $0C*}
+
+ {**
+ * Walther keys
+ *
+ * These are values that Christian Walther added (for mac keyboard?).
+ *}
+
+ SDL_SCANCODE_BRIGHTNESSDOWN = 275;
+ SDL_SCANCODE_BRIGHTNESSUP = 276;
+ SDL_SCANCODE_DISPLAYSWITCH = 277; {**< display mirroring{dual display
+ switch; video mode switch *}
+ SDL_SCANCODE_KBDILLUMTOGGLE = 278;
+ SDL_SCANCODE_KBDILLUMDOWN = 279;
+ SDL_SCANCODE_KBDILLUMUP = 280;
+ SDL_SCANCODE_EJECT = 281;
+ SDL_SCANCODE_SLEEP = 282;
+
+ SDL_SCANCODE_APP1 = 283;
+ SDL_SCANCODE_APP2 = 284;
+
+ {*Walther keys*}
+
+ {* Add any other keys here. *}
+
+ SDL_NUM_SCANCODES = 512; {**< not a key, just marks the number of scancodes
+ for array bounds *}
+
+type
+ PSDL_ScanCode = ^TSDL_ScanCode;
+ TSDL_ScanCode = DWord;
+
+ //from "sdl_keycode.h"
+
+
+ {**
+ * The SDL virtual key representation.
+ *
+ * Values of this type are used to represent keyboard keys using the current
+ * layout of the keyboard. These values include Unicode values representing
+ * the unmodified character that would be generated by pressing the key, or
+ * an SDLK_* constant for those keys that do not generate characters.
+ *}
+ PSDL_KeyCode = ^TSDL_KeyCode;
+ TSDL_KeyCode = SInt32;
+
+const
+ SDLK_SCANCODE_MASK = 1 shl 30;
+
+ SDLK_UNKNOWN = 0;
+
+ SDLK_RETURN = '\r';
+ SDLK_ESCAPE = '\033';
+ SDLK_BACKSPACE = '\b';
+ SDLK_TAB = '\t';
+ SDLK_SPACE = ' ';
+ SDLK_EXCLAIM = '!';
+ SDLK_QUOTEDBL = '"';
+ SDLK_HASH = '#';
+ SDLK_PERCENT = '%';
+ SDLK_DOLLAR = '$';
+ SDLK_AMPERSAND = '&';
+ SDLK_QUOTE = '\';
+ SDLK_LEFTPAREN = '(';
+ SDLK_RIGHTPAREN = ')';
+ SDLK_ASTERISK = '*';
+ SDLK_PLUS = '+';
+ SDLK_COMMA = ';';
+ SDLK_MINUS = '-';
+ SDLK_PERIOD = '.';
+ SDLK_SLASH = '/';
+ SDLK_0 = '0';
+ SDLK_1 = '1';
+ SDLK_2 = '2';
+ SDLK_3 = '3';
+ SDLK_4 = '4';
+ SDLK_5 = '5';
+ SDLK_6 = '6';
+ SDLK_7 = '7';
+ SDLK_8 = '8';
+ SDLK_9 = '9';
+ SDLK_COLON = ':';
+ SDLK_SEMICOLON = ';';
+ SDLK_LESS = '<';
+ SDLK_EQUALS = '=';
+ SDLK_GREATER = '>';
+ SDLK_QUESTION = '?';
+ SDLK_AT = '@';
+ {*
+ Skip uppercase letters
+ *}
+ SDLK_LEFTBRACKET = '[';
+ SDLK_BACKSLASH = '\\';
+ SDLK_RIGHTBRACKET = ']';
+ SDLK_CARET = '^';
+ SDLK_UNDERSCORE = '_';
+ SDLK_BACKQUOTE = '`';
+ SDLK_a = 'a';
+ SDLK_b = 'b';
+ SDLK_c = 'c';
+ SDLK_d = 'd';
+ SDLK_e = 'e';
+ SDLK_f = 'f';
+ SDLK_g = 'g';
+ SDLK_h = 'h';
+ SDLK_i = 'i';
+ SDLK_j = 'j';
+ SDLK_k = 'k';
+ SDLK_l = 'l';
+ SDLK_m = 'm';
+ SDLK_n = 'n';
+ SDLK_o = 'o';
+ SDLK_p = 'p';
+ SDLK_q = 'q';
+ SDLK_r = 'r';
+ SDLK_s = 's';
+ SDLK_t = 't';
+ SDLK_u = 'u';
+ SDLK_v = 'v';
+ SDLK_w = 'w';
+ SDLK_x = 'x';
+ SDLK_y = 'y';
+ SDLK_z = 'z';
+
+ SDLK_CAPSLOCK = SDL_SCANCODE_CAPSLOCK or SDLK_SCANCODE_MASK;
+
+ SDLK_F1 = SDL_SCANCODE_F1 or SDLK_SCANCODE_MASK;
+ SDLK_F2 = SDL_SCANCODE_F2 or SDLK_SCANCODE_MASK;
+ SDLK_F3 = SDL_SCANCODE_F3 or SDLK_SCANCODE_MASK;
+ SDLK_F4 = SDL_SCANCODE_F4 or SDLK_SCANCODE_MASK;
+ SDLK_F5 = SDL_SCANCODE_F5 or SDLK_SCANCODE_MASK;
+ SDLK_F6 = SDL_SCANCODE_F6 or SDLK_SCANCODE_MASK;
+ SDLK_F7 = SDL_SCANCODE_F7 or SDLK_SCANCODE_MASK;
+ SDLK_F8 = SDL_SCANCODE_F8 or SDLK_SCANCODE_MASK;
+ SDLK_F9 = SDL_SCANCODE_F9 or SDLK_SCANCODE_MASK;
+ SDLK_F10 = SDL_SCANCODE_F10 or SDLK_SCANCODE_MASK;
+ SDLK_F11 = SDL_SCANCODE_F11 or SDLK_SCANCODE_MASK;
+ SDLK_F12 = SDL_SCANCODE_F12 or SDLK_SCANCODE_MASK;
+
+ SDLK_PRINTSCREEN = SDL_SCANCODE_PRINTSCREEN or SDLK_SCANCODE_MASK;
+ SDLK_SCROLLLOCK = SDL_SCANCODE_SCROLLLOCK or SDLK_SCANCODE_MASK;
+ SDLK_PAUSE = SDL_SCANCODE_PAUSE or SDLK_SCANCODE_MASK;
+ SDLK_INSERT = SDL_SCANCODE_INSERT or SDLK_SCANCODE_MASK;
+ SDLK_HOME = SDL_SCANCODE_HOME or SDLK_SCANCODE_MASK;
+ SDLK_PAGEUP = SDL_SCANCODE_PAGEUP or SDLK_SCANCODE_MASK;
+ SDLK_DELETE = '\177';
+ SDLK_END = SDL_SCANCODE_END or SDLK_SCANCODE_MASK;
+ SDLK_PAGEDOWN = SDL_SCANCODE_PAGEDOWN or SDLK_SCANCODE_MASK;
+ SDLK_RIGHT = SDL_SCANCODE_RIGHT or SDLK_SCANCODE_MASK;
+ SDLK_LEFT = SDL_SCANCODE_LEFT or SDLK_SCANCODE_MASK;
+ SDLK_DOWN = SDL_SCANCODE_DOWN or SDLK_SCANCODE_MASK;
+ SDLK_UP = SDL_SCANCODE_UP or SDLK_SCANCODE_MASK;
+
+ SDLK_NUMLOCKCLEAR = SDL_SCANCODE_NUMLOCKCLEAR or SDLK_SCANCODE_MASK;
+ SDLK_KP_DIVIDE = SDL_SCANCODE_KP_DIVIDE or SDLK_SCANCODE_MASK;
+ SDLK_KP_MULTIPLY = SDL_SCANCODE_KP_MULTIPLY or SDLK_SCANCODE_MASK;
+ SDLK_KP_MINUS = SDL_SCANCODE_KP_MINUS or SDLK_SCANCODE_MASK;
+ SDLK_KP_PLUS = SDL_SCANCODE_KP_PLUS or SDLK_SCANCODE_MASK;
+ SDLK_KP_ENTER = SDL_SCANCODE_KP_ENTER or SDLK_SCANCODE_MASK;
+ SDLK_KP_1 = SDL_SCANCODE_KP_1 or SDLK_SCANCODE_MASK;
+ SDLK_KP_2 = SDL_SCANCODE_KP_2 or SDLK_SCANCODE_MASK;
+ SDLK_KP_3 = SDL_SCANCODE_KP_3 or SDLK_SCANCODE_MASK;
+ SDLK_KP_4 = SDL_SCANCODE_KP_4 or SDLK_SCANCODE_MASK;
+ SDLK_KP_5 = SDL_SCANCODE_KP_5 or SDLK_SCANCODE_MASK;
+ SDLK_KP_6 = SDL_SCANCODE_KP_6 or SDLK_SCANCODE_MASK;
+ SDLK_KP_7 = SDL_SCANCODE_KP_7 or SDLK_SCANCODE_MASK;
+ SDLK_KP_8 = SDL_SCANCODE_KP_8 or SDLK_SCANCODE_MASK;
+ SDLK_KP_9 = SDL_SCANCODE_KP_9 or SDLK_SCANCODE_MASK;
+ SDLK_KP_0 = SDL_SCANCODE_KP_0 or SDLK_SCANCODE_MASK;
+ SDLK_KP_PERIOD = SDL_SCANCODE_KP_PERIOD or SDLK_SCANCODE_MASK;
+
+ SDLK_APPLICATION = SDL_SCANCODE_APPLICATION or SDLK_SCANCODE_MASK;
+ SDLK_POWER = SDL_SCANCODE_POWER or SDLK_SCANCODE_MASK;
+ SDLK_KP_EQUALS = SDL_SCANCODE_KP_EQUALS or SDLK_SCANCODE_MASK;
+ SDLK_F13 = SDL_SCANCODE_F13 or SDLK_SCANCODE_MASK;
+ SDLK_F14 = SDL_SCANCODE_F14 or SDLK_SCANCODE_MASK;
+ SDLK_F15 = SDL_SCANCODE_F15 or SDLK_SCANCODE_MASK;
+ SDLK_F16 = SDL_SCANCODE_F16 or SDLK_SCANCODE_MASK;
+ SDLK_F17 = SDL_SCANCODE_F17 or SDLK_SCANCODE_MASK;
+ SDLK_F18 = SDL_SCANCODE_F18 or SDLK_SCANCODE_MASK;
+ SDLK_F19 = SDL_SCANCODE_F19 or SDLK_SCANCODE_MASK;
+ SDLK_F20 = SDL_SCANCODE_F20 or SDLK_SCANCODE_MASK;
+ SDLK_F21 = SDL_SCANCODE_F21 or SDLK_SCANCODE_MASK;
+ SDLK_F22 = SDL_SCANCODE_F22 or SDLK_SCANCODE_MASK;
+ SDLK_F23 = SDL_SCANCODE_F23 or SDLK_SCANCODE_MASK;
+ SDLK_F24 = SDL_SCANCODE_F24 or SDLK_SCANCODE_MASK;
+ SDLK_EXECUTE = SDL_SCANCODE_EXECUTE or SDLK_SCANCODE_MASK;
+ SDLK_HELP = SDL_SCANCODE_HELP or SDLK_SCANCODE_MASK;
+ SDLK_MENU = SDL_SCANCODE_MENU or SDLK_SCANCODE_MASK;
+ SDLK_SELECT = SDL_SCANCODE_SELECT or SDLK_SCANCODE_MASK;
+ SDLK_STOP = SDL_SCANCODE_STOP or SDLK_SCANCODE_MASK;
+ SDLK_AGAIN = SDL_SCANCODE_AGAIN or SDLK_SCANCODE_MASK;
+ SDLK_UNDO = SDL_SCANCODE_UNDO or SDLK_SCANCODE_MASK;
+ SDLK_CUT = SDL_SCANCODE_CUT or SDLK_SCANCODE_MASK;
+ SDLK_COPY = SDL_SCANCODE_COPY or SDLK_SCANCODE_MASK;
+ SDLK_PASTE = SDL_SCANCODE_PASTE or SDLK_SCANCODE_MASK;
+ SDLK_FIND = SDL_SCANCODE_FIND or SDLK_SCANCODE_MASK;
+ SDLK_MUTE = SDL_SCANCODE_MUTE or SDLK_SCANCODE_MASK;
+ SDLK_VOLUMEUP = SDL_SCANCODE_VOLUMEUP or SDLK_SCANCODE_MASK;
+ SDLK_VOLUMEDOWN = SDL_SCANCODE_VOLUMEDOWN or SDLK_SCANCODE_MASK;
+ SDLK_KP_COMMA = SDL_SCANCODE_KP_COMMA or SDLK_SCANCODE_MASK;
+ SDLK_KP_EQUALSAS400 = SDL_SCANCODE_KP_EQUALSAS400 or SDLK_SCANCODE_MASK;
+
+ SDLK_ALTERASE = SDL_SCANCODE_ALTERASE or SDLK_SCANCODE_MASK;
+ SDLK_SYSREQ = SDL_SCANCODE_SYSREQ or SDLK_SCANCODE_MASK;
+ SDLK_CANCEL = SDL_SCANCODE_CANCEL or SDLK_SCANCODE_MASK;
+ SDLK_CLEAR = SDL_SCANCODE_CLEAR or SDLK_SCANCODE_MASK;
+ SDLK_PRIOR = SDL_SCANCODE_PRIOR or SDLK_SCANCODE_MASK;
+ SDLK_RETURN2 = SDL_SCANCODE_RETURN2 or SDLK_SCANCODE_MASK;
+ SDLK_SEPARATOR = SDL_SCANCODE_SEPARATOR or SDLK_SCANCODE_MASK;
+ SDLK_OUT = SDL_SCANCODE_OUT or SDLK_SCANCODE_MASK;
+ SDLK_OPER = SDL_SCANCODE_OPER or SDLK_SCANCODE_MASK;
+ SDLK_CLEARAGAIN = SDL_SCANCODE_CLEARAGAIN or SDLK_SCANCODE_MASK;
+ SDLK_CRSEL = SDL_SCANCODE_CRSEL or SDLK_SCANCODE_MASK;
+ SDLK_EXSEL = SDL_SCANCODE_EXSEL or SDLK_SCANCODE_MASK;
+
+ SDLK_KP_00 = SDL_SCANCODE_KP_00 or SDLK_SCANCODE_MASK;
+ SDLK_KP_000 = SDL_SCANCODE_KP_000 or SDLK_SCANCODE_MASK;
+ SDLK_THOUSANDSSEPARATOR = SDL_SCANCODE_THOUSANDSSEPARATOR or SDLK_SCANCODE_MASK;
+ SDLK_DECIMALSEPARATOR = SDL_SCANCODE_DECIMALSEPARATOR or SDLK_SCANCODE_MASK;
+ SDLK_CURRENCYUNIT = SDL_SCANCODE_CURRENCYUNIT or SDLK_SCANCODE_MASK;
+ SDLK_CURRENCYSUBUNIT = SDL_SCANCODE_CURRENCYSUBUNIT or SDLK_SCANCODE_MASK;
+ SDLK_KP_LEFTPAREN = SDL_SCANCODE_KP_LEFTPAREN or SDLK_SCANCODE_MASK;
+ SDLK_KP_RIGHTPAREN = SDL_SCANCODE_KP_RIGHTPAREN or SDLK_SCANCODE_MASK;
+ SDLK_KP_LEFTBRACE = SDL_SCANCODE_KP_LEFTBRACE or SDLK_SCANCODE_MASK;
+ SDLK_KP_RIGHTBRACE = SDL_SCANCODE_KP_RIGHTBRACE or SDLK_SCANCODE_MASK;
+ SDLK_KP_TAB = SDL_SCANCODE_KP_TAB or SDLK_SCANCODE_MASK;
+ SDLK_KP_BACKSPACE = SDL_SCANCODE_KP_BACKSPACE or SDLK_SCANCODE_MASK;
+ SDLK_KP_A = SDL_SCANCODE_KP_A or SDLK_SCANCODE_MASK;
+ SDLK_KP_B = SDL_SCANCODE_KP_B or SDLK_SCANCODE_MASK;
+ SDLK_KP_C = SDL_SCANCODE_KP_C or SDLK_SCANCODE_MASK;
+ SDLK_KP_D = SDL_SCANCODE_KP_D or SDLK_SCANCODE_MASK;
+ SDLK_KP_E = SDL_SCANCODE_KP_E or SDLK_SCANCODE_MASK;
+ SDLK_KP_F = SDL_SCANCODE_KP_F or SDLK_SCANCODE_MASK;
+ SDLK_KP_XOR = SDL_SCANCODE_KP_XOR or SDLK_SCANCODE_MASK;
+ SDLK_KP_POWER = SDL_SCANCODE_KP_POWER or SDLK_SCANCODE_MASK;
+ SDLK_KP_PERCENT = SDL_SCANCODE_KP_PERCENT or SDLK_SCANCODE_MASK;
+ SDLK_KP_LESS = SDL_SCANCODE_KP_LESS or SDLK_SCANCODE_MASK;
+ SDLK_KP_GREATER = SDL_SCANCODE_KP_GREATER or SDLK_SCANCODE_MASK;
+ SDLK_KP_AMPERSAND = SDL_SCANCODE_KP_AMPERSAND or SDLK_SCANCODE_MASK;
+ SDLK_KP_DBLAMPERSAND = SDL_SCANCODE_KP_DBLAMPERSAND or SDLK_SCANCODE_MASK;
+ SDLK_KP_VERTICALBAR = SDL_SCANCODE_KP_VERTICALBAR or SDLK_SCANCODE_MASK;
+ SDLK_KP_DBLVERTICALBAR = SDL_SCANCODE_KP_DBLVERTICALBAR or SDLK_SCANCODE_MASK;
+ SDLK_KP_COLON = SDL_SCANCODE_KP_COLON or SDLK_SCANCODE_MASK;
+ SDLK_KP_HASH = SDL_SCANCODE_KP_HASH or SDLK_SCANCODE_MASK;
+ SDLK_KP_SPACE = SDL_SCANCODE_KP_SPACE or SDLK_SCANCODE_MASK;
+ SDLK_KP_AT = SDL_SCANCODE_KP_AT or SDLK_SCANCODE_MASK;
+ SDLK_KP_EXCLAM = SDL_SCANCODE_KP_EXCLAM or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMSTORE = SDL_SCANCODE_KP_MEMSTORE or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMRECALL = SDL_SCANCODE_KP_MEMRECALL or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMCLEAR = SDL_SCANCODE_KP_MEMCLEAR or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMADD = SDL_SCANCODE_KP_MEMADD or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMSUBTRACT = SDL_SCANCODE_KP_MEMSUBTRACT or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMMULTIPLY = SDL_SCANCODE_KP_MEMMULTIPLY or SDLK_SCANCODE_MASK;
+ SDLK_KP_MEMDIVIDE = SDL_SCANCODE_KP_MEMDIVIDE or SDLK_SCANCODE_MASK;
+ SDLK_KP_PLUSMINUS = SDL_SCANCODE_KP_PLUSMINUS or SDLK_SCANCODE_MASK;
+ SDLK_KP_CLEAR = SDL_SCANCODE_KP_CLEAR or SDLK_SCANCODE_MASK;
+ SDLK_KP_CLEARENTRY = SDL_SCANCODE_KP_CLEARENTRY or SDLK_SCANCODE_MASK;
+ SDLK_KP_BINARY = SDL_SCANCODE_KP_BINARY or SDLK_SCANCODE_MASK;
+ SDLK_KP_OCTAL = SDL_SCANCODE_KP_OCTAL or SDLK_SCANCODE_MASK;
+ SDLK_KP_DECIMAL = SDL_SCANCODE_KP_DECIMAL or SDLK_SCANCODE_MASK;
+ SDLK_KP_HEXADECIMAL = SDL_SCANCODE_KP_HEXADECIMAL or SDLK_SCANCODE_MASK;
+
+ SDLK_LCTRL = SDL_SCANCODE_LCTRL or SDLK_SCANCODE_MASK;
+ SDLK_LSHIFT = SDL_SCANCODE_LSHIFT or SDLK_SCANCODE_MASK;
+ SDLK_LALT = SDL_SCANCODE_LALT or SDLK_SCANCODE_MASK;
+ SDLK_LGUI = SDL_SCANCODE_LGUI or SDLK_SCANCODE_MASK;
+ SDLK_RCTRL = SDL_SCANCODE_RCTRL or SDLK_SCANCODE_MASK;
+ SDLK_RSHIFT = SDL_SCANCODE_RSHIFT or SDLK_SCANCODE_MASK;
+ SDLK_RALT = SDL_SCANCODE_RALT or SDLK_SCANCODE_MASK;
+ SDLK_RGUI = SDL_SCANCODE_RGUI or SDLK_SCANCODE_MASK;
+
+ SDLK_MODE = SDL_SCANCODE_MODE or SDLK_SCANCODE_MASK;
+
+ SDLK_AUDIONEXT = SDL_SCANCODE_AUDIONEXT or SDLK_SCANCODE_MASK;
+ SDLK_AUDIOPREV = SDL_SCANCODE_AUDIOPREV or SDLK_SCANCODE_MASK;
+ SDLK_AUDIOSTOP = SDL_SCANCODE_AUDIOSTOP or SDLK_SCANCODE_MASK;
+ SDLK_AUDIOPLAY = SDL_SCANCODE_AUDIOPLAY or SDLK_SCANCODE_MASK;
+ SDLK_AUDIOMUTE = SDL_SCANCODE_AUDIOMUTE or SDLK_SCANCODE_MASK;
+ SDLK_MEDIASELECT = SDL_SCANCODE_MEDIASELECT or SDLK_SCANCODE_MASK;
+ SDLK_WWW = SDL_SCANCODE_WWW or SDLK_SCANCODE_MASK;
+ SDLK_MAIL = SDL_SCANCODE_MAIL or SDLK_SCANCODE_MASK;
+ SDLK_CALCULATOR = SDL_SCANCODE_CALCULATOR or SDLK_SCANCODE_MASK;
+ SDLK_COMPUTER = SDL_SCANCODE_COMPUTER or SDLK_SCANCODE_MASK;
+ SDLK_AC_SEARCH = SDL_SCANCODE_AC_SEARCH or SDLK_SCANCODE_MASK;
+ SDLK_AC_HOME = SDL_SCANCODE_AC_HOME or SDLK_SCANCODE_MASK;
+ SDLK_AC_BACK = SDL_SCANCODE_AC_BACK or SDLK_SCANCODE_MASK;
+ SDLK_AC_FORWARD = SDL_SCANCODE_AC_FORWARD or SDLK_SCANCODE_MASK;
+ SDLK_AC_STOP = SDL_SCANCODE_AC_STOP or SDLK_SCANCODE_MASK;
+ SDLK_AC_REFRESH = SDL_SCANCODE_AC_REFRESH or SDLK_SCANCODE_MASK;
+ SDLK_AC_BOOKMARKS = SDL_SCANCODE_AC_BOOKMARKS or SDLK_SCANCODE_MASK;
+
+ SDLK_BRIGHTNESSDOWN = SDL_SCANCODE_BRIGHTNESSDOWN or SDLK_SCANCODE_MASK;
+ SDLK_BRIGHTNESSUP = SDL_SCANCODE_BRIGHTNESSUP or SDLK_SCANCODE_MASK;
+ SDLK_DISPLAYSWITCH = SDL_SCANCODE_DISPLAYSWITCH or SDLK_SCANCODE_MASK;
+ SDLK_KBDILLUMTOGGLE = SDL_SCANCODE_KBDILLUMTOGGLE or SDLK_SCANCODE_MASK;
+ SDLK_KBDILLUMDOWN = SDL_SCANCODE_KBDILLUMDOWN or SDLK_SCANCODE_MASK;
+ SDLK_KBDILLUMUP = SDL_SCANCODE_KBDILLUMUP or SDLK_SCANCODE_MASK;
+ SDLK_EJECT = SDL_SCANCODE_EJECT or SDLK_SCANCODE_MASK;
+ SDLK_SLEEP = SDL_SCANCODE_SLEEP or SDLK_SCANCODE_MASK;
+
+ {**
+ * Enumeration of valid key mods (possibly OR'd together).
+ *}
+
+ KMOD_NONE = $0000;
+ KMOD_LSHIFT = $0001;
+ KMOD_RSHIFT = $0002;
+ KMOD_LCTRL = $0040;
+ KMOD_RCTRL = $0080;
+ KMOD_LALT = $0100;
+ KMOD_RALT = $0200;
+ KMOD_LGUI = $0400;
+ KMOD_RGUI = $0800;
+ KMOD_NUM = $1000;
+ KMOD_CAPS = $2000;
+ KMOD_MODE = $4000;
+ KMOD_RESERVED = $8000;
+
+type
+ PSDL_KeyMod = ^TSDL_KeyMod;
+ TSDL_KeyMod = Word;
+
+const
+ KMOD_CTRL = KMOD_LCTRL or KMOD_RCTRL;
+ KMOD_SHIFT = KMOD_LSHIFT or KMOD_RSHIFT;
+ KMOD_ALT = KMOD_LALT or KMOD_RALT;
+ KMOD_GUI = KMOD_LGUI or KMOD_RGUI;
--- /dev/null
+//from "sdl_shape.h"
+
+{** SDL_shape.h
+ *
+ * Header file for the shaped window API.
+ *}
+const
+ SDL_NONSHAPEABLE_WINDOW = -1;
+ SDL_INVALID_SHAPE_ARGUMENT = -2;
+ SDL_WINDOW_LACKS_SHAPE = -3;
+
+type
+ PPSDL_Window = ^PSDL_Window;
+ PSDL_Window = ^TSDL_Window;
+
+ {** An enum denoting the specific type of contents present in an SDL_WindowShapeParams union. *}
+ TWindowShapeMode = ({** The default mode, a binarized alpha cutoff of 1. *}
+ ShapeModeDefault,
+ {** A binarized alpha cutoff with a given integer value. *}
+ ShapeModeBinarizeAlpha,
+ {** A binarized alpha cutoff with a given integer value, but with the opposite comparison. *}
+ ShapeModeReverseBinarizeAlpha,
+ {** A color key is applied. *}
+ ShapeModeColorKey);
+
+//#define SDL_SHAPEMODEALPHA(mode) (mode == ShapeModeDefault || mode == ShapeModeBinarizeAlpha || mode == ShapeModeReverseBinarizeAlpha)
+
+ {** A union containing parameters for shaped windows. *}
+ TSDL_WindowShapeParams = record
+ case Integer of
+ {** a cutoff alpha value for binarization of the window shape's alpha channel. *}
+ 0: (binarizationCutoff: UInt8;);
+ 1: (colorKey: TSDL_Color;);
+ end;
+
+ {** A struct that tags the SDL_WindowShapeParams union with an enum describing the type of its contents. *}
+ PSDL_WindowShapeMode = ^TSDL_WindowShapeMode;
+ TSDL_WindowShapeMode = record
+ {** The mode of these window-shape parameters. *}
+ mode: TWindowShapeMode;
+ {** Window-shape parameters. *}
+ parameters: TSDL_WindowShapeParams;
+ end;
--- /dev/null
+//from "sdl_surface.h"
+
+const
+ {**
+ * Surface flags
+ *
+ * These are the currently supported flags for the ::SDL_surface.
+ *
+ * Used internally (read-only).
+ *}
+
+ SDL_SWSURFACE = 0; {**< Just here for compatibility *}
+ SDL_PREALLOC = $00000001; {**< Surface uses preallocated memory *}
+ SDL_RLEACCEL = $00000002; {**< Surface is RLE encoded *}
+ SDL_DONTFREE = $00000004; {**< Surface is referenced internally *}
+
+ {*Surface flags*}
+
+ {**
+ * Evaluates to true if the surface needs to be locked before access.
+ *}
+
+ //SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
+
+type
+ {**
+ * A collection of pixels used in software blitting.
+ *
+ * This structure should be treated as read-only, except for \c pixels,
+ * which, if not NULL, contains the raw pixel data for the surface.
+ *}
+
+ PSDL_BlitMap = ^TSDL_BlitMap;
+ TSDL_BlitMap = record
+ map: Pointer;
+ end;
+
+ PSDL_Surface = ^TSDL_Surface;
+ TSDL_Surface = record
+ flags: UInt32; {**< Read-only *}
+ format: PSDL_PixelFormat; {**< Read-only *}
+ w, h: SInt32; {**< Read-only *}
+ pitch: SInt32; {**< Read-only *}
+ pixels: Pointer; {**< Read-write *}
+
+ {** Application data associated with the surface *}
+ userdata: Pointer; {**< Read-write *}
+
+ {** information needed for surfaces requiring locks *}
+ locked: SInt32; {**< Read-only *}
+ lock_data: Pointer; {**< Read-only *}
+
+ {** clipping information *}
+ clip_rect: PSDL_Rect; {**< Read-only *}
+
+ {** info for fast blit mapping to other surfaces *}
+ map: Pointer; {**< Private *} //SDL_BlitMap
+
+ {** Reference count -- used when freeing surface *}
+ refcount: SInt32; {**< Read-mostly *}
+ end;
+
+ {**
+ * The type of function used for surface blitting functions.
+ *}
+
+ TSDL_Blit = function(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32;
+
+ {**
+ * Allocate and free an RGB surface.
+ *
+ * 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.
+ *
+ * flags The flags are obsolete and should be set to 0.
+ *}
+
+function SDL_CreateRGBSurface(flags: UInt32; width: SInt32; height: SInt32; depth: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurface' {$ENDIF} {$ENDIF};
+function SDL_CreateRGBSurfaceFrom(pixels: Pointer; width: SInt32; height: SInt32; depth: SInt32; pitch: SInt32; Rmask: UInt32; Gmask: UInt32; Bmask: UInt32; Amask: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRGBSurfaceFrom' {$ENDIF} {$ENDIF};
+procedure SDL_FreeSurface(surface: PSDL_Surface) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FreeSurface' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the palette used by a surface.
+ *
+ * 0, or -1 if the surface format doesn't use a palette.
+ *
+ * A single palette can be shared with many surfaces.
+ *}
+
+function SDL_SetSurfacePalette(surface: PSDL_Surface; palette: PSDL_Palette): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfacePalette' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *
+ * 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.
+ *
+ * SDL_UnlockSurface()
+ *}
+
+function SDL_LockSurface(surface: PSDL_Surface): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockSurface' {$ENDIF} {$ENDIF};
+
+ {** SDL_LockSurface() *}
+
+procedure SDL_UnlockSurface(surface: PSDL_Surface) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UnlockSurface' {$ENDIF} {$ENDIF};
+
+ {**
+ * Load a surface from a seekable SDL data stream (memory or file).
+ *
+ * If freesrc is non-zero, the stream will be closed after being read.
+ *
+ * The new surface should be freed with SDL_FreeSurface().
+ *
+ * the new surface, or NULL if there was an error.
+ *}
+
+function SDL_LoadBMP_RW(src: PSDL_RWops; freesrc: SInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadBMP_RW' {$ENDIF} {$ENDIF};
+
+ {**
+ * Load a surface from a file.
+ *
+ * Convenience macro.
+ *}
+
+function SDL_LoadBMP(_file: PAnsiChar): PSDL_Surface;
+
+ {**
+ * Save a surface to a seekable SDL data stream (memory or file).
+ *
+ * If freedst is non-zero, the stream will be closed after being written.
+ *
+ * 0 if successful or -1 if there was an error.
+ *}
+
+function SDL_SaveBMP_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LoadBMP_RW' {$ENDIF} {$ENDIF};
+
+ {**
+ * Save a surface to a file.
+ *
+ * Convenience macro.
+ *}
+ {
+ #define SDL_SaveBMP(surface, file) \
+ SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
+ }
+
+ {**
+ * Sets the RLE acceleration hint for a surface.
+ *
+ * 0 on success, or -1 if the surface is not valid
+ *
+ * If RLE is enabled, colorkey and alpha blending blits are much faster,
+ * but the surface must be locked before directly accessing the pixels.
+ *}
+
+function SDL_SetSurfaceRLE(surface: PSDL_Surface; flag: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceRLE' {$ENDIF} {$ENDIF};
+
+ {**
+ * Sets the color key (transparent pixel) in a blittable surface.
+ *
+ * surface The surface to update
+ * flag Non-zero to enable colorkey and 0 to disable colorkey
+ * key The transparent pixel in the native surface format
+ *
+ * 0 on success, or -1 if the surface is not valid
+ *
+ * You can pass SDL_RLEACCEL to enable RLE accelerated blits.
+ *}
+
+function SDL_SetColorKey(surface: PSDL_Surface; flag: SInt32; key: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetColorKey' {$ENDIF} {$ENDIF};
+
+ {**
+ * Gets the color key (transparent pixel) in a blittable surface.
+ *
+ * surface The surface to update
+ * key A pointer filled in with the transparent pixel in the native
+ * surface format
+ *
+ * 0 on success, or -1 if the surface is not valid or colorkey is not
+ * enabled.
+ *}
+
+function SDL_GetColorKey(surface: PSDL_Surface; key: PUInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetColorKey' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set an additional color value used in blit operations.
+ *
+ * surface The surface to update.
+ * r The red color value multiplied into blit operations.
+ * g The green color value multiplied into blit operations.
+ * b The blue color value multiplied into blit operations.
+ *
+ * 0 on success, or -1 if the surface is not valid.
+ *
+ * SDL_GetSurfaceColorMod()
+ *}
+
+function SDL_SetSurfaceColorMod(surface: PSDL_Surface; r: UInt8; g: UInt8; b: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceColorMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the additional color value used in blit operations.
+ *
+ * surface The surface to query.
+ * r A pointer filled in with the current red color value.
+ * g A pointer filled in with the current green color value.
+ * b A pointer filled in with the current blue color value.
+ *
+ * 0 on success, or -1 if the surface is not valid.
+ *
+ * SDL_SetSurfaceColorMod()
+ *}
+
+function SDL_GetSurfaceColorMod(surface: PSDL_Surface; r: PUInt8; g: PUInt8; b: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceColorMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set an additional alpha value used in blit operations.
+ *
+ * surface The surface to update.
+ * alpha The alpha value multiplied into blit operations.
+ *
+ * 0 on success, or -1 if the surface is not valid.
+ *
+ * SDL_GetSurfaceAlphaMod()
+ *}
+
+function SDL_SetSurfaceAlphaMod(surface: PSDL_Surface; alpha: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceAlphaMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the additional alpha value used in blit operations.
+ *
+ * surface The surface to query.
+ * alpha A pointer filled in with the current alpha value.
+ *
+ * 0 on success, or -1 if the surface is not valid.
+ *
+ * SDL_SetSurfaceAlphaMod()
+ *}
+
+function SDL_GetSurfaceAlphaMod(surface: PSDL_Surface; alpha: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceAlphaMod' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the blend mode used for blit operations.
+ *
+ * surface The surface to update.
+ * blendMode ::SDL_BlendMode to use for blit blending.
+ *
+ * 0 on success, or -1 if the parameters are not valid.
+ *
+ * SDL_GetSurfaceBlendMode()
+ *}
+
+function SDL_SetSurfaceBlendMode(surface: PSDL_Surface; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetSurfaceBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the blend mode used for blit operations.
+ *
+ * surface The surface to query.
+ * blendMode A pointer filled in with the current blend mode.
+ *
+ * 0 on success, or -1 if the surface is not valid.
+ *
+ * SDL_SetSurfaceBlendMode()
+ *}
+
+function SDL_GetSurfaceBlendMode(surface: PSDL_Surface; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetSurfaceBlendMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+
+function SDL_SetClipRect(surface: PSDL_Surface; const rect: PSDL_Rect): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetClipRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+
+procedure SDL_GetClipRect(surface: PSDL_Surface; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetClipRect' {$ENDIF} {$ENDIF};
+
+ {**
+ * 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.
+ *}
+
+function SDL_ConvertSurface(src: PSDL_Surface; fmt: PSDL_PixelFormat; flags: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertSurface' {$ENDIF} {$ENDIF};
+function SDL_ConvertSurfaceFormat(src: PSDL_Surface; pixel_format: UInt32; flags: UInt32): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertSurfaceFormat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Copy a block of pixels of one format to another format
+ *
+ * 0 on success, or -1 if there was an error
+ *}
+
+function SDL_ConvertPixels(width: SInt32; height: SInt32; src_format: UInt32; const src: Pointer; src_pitch: SInt32; dst_format: UInt32; dst: Pointer; dst_pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ConvertPixels' {$ENDIF} {$ENDIF};
+
+ {**
+ * Performs a fast fill of the given rectangle with color.
+ *
+ * If rect 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.
+ *
+ * 0 on success, or -1 on error.
+ *}
+
+function SDL_FillRect(dst: PSDL_Surface; const rect: PSDL_Rect; color: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FillRect' {$ENDIF} {$ENDIF};
+function SDL_FillRects(dst: PSDL_Surface; const rects: PSDL_Rect; count: SInt32; color: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_FillRects' {$ENDIF} {$ENDIF};
+
+ {**
+ * Performs a fast blit from the source surface to the destination surface.
+ *
+ * This assumes that the source and destination rectangles are
+ * the same size. If either \c srcrect or \c 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 source per-surface alpha value.
+ 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.r
+ *
+ * You should call SDL_BlitSurface() unless you know exactly how SDL
+ * blitting works internally and how to use the other blit functions.
+ *}
+
+ {**
+ * This is the public blit function, SDL_BlitSurface(), and it performs
+ * rectangle validation and clipping before passing it to SDL_LowerBlit()
+ *}
+
+function SDL_UpperBlit(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpperBlit' {$ENDIF} {$ENDIF};
+
+ //SDL_BlitSurface = SDL_UpperBlit;
+
+ {**
+ * This is a semi-private blit function and it performs low-level surface
+ * blitting only.
+ *}
+
+function SDL_LowerBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LowerBlit' {$ENDIF} {$ENDIF};
+
+ {**
+ * Perform a fast, low quality, stretch blit between two surfaces of the
+ * same pixel format.
+ *
+ * This function uses a static buffer, and is not thread-safe.
+ *}
+
+function SDL_SoftStretch(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; const dstrect: PSDL_Surface): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SoftStretch' {$ENDIF} {$ENDIF};
+
+ //SDL_BlitScaled = SDL_UpperBlitScaled;
+
+ {**
+ * This is the public scaled blit function, SDL_BlitScaled(), and it performs
+ * rectangle validation and clipping before passing it to SDL_LowerBlitScaled()
+ *}
+
+function SDL_UpperBlitScaled(src: PSDL_Surface; const srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpperBlitScaled' {$ENDIF} {$ENDIF};
+
+ {**
+ * This is a semi-private blit function and it performs low-level surface
+ * scaled blitting only.
+ *}
+
+function SDL_LowerBlitScaled(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LowerBlitScaled' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_thread.h"
+
+{* The SDL thread structure, defined in SDL_thread.c *}
+//todo!
+type
+ {* The SDL thread priority
+ *
+ * Note: On many systems you require special privileges to set high priority.
+ *}
+
+ TSDL_ThreadPriority = (SDL_THREAD_PRIORITY_LOW,
+ SDL_THREAD_PRIORITY_NORMAL,
+ SDL_THREAD_PRIORITY_HIGH);
+
+ {* The function passed to SDL_CreateThread()
+ It is passed a void* user context parameter and returns an int.
+ *}
+ PSDL_ThreadFunction = ^TSDL_ThreadFunction;
+ TSDL_ThreadFunction = function(data: Pointer): Integer; cdecl;
+
+ {* The SDL thread ID *}
+ TSDL_ThreadID = LongWord;
+ {
+ PSDL_Thread = Pointer;
+ }
+
+ PSDL_Thread = ^TSDL_Thread;
+ TSDL_Thread = record
+ threadid: TSDL_ThreadID;
+ handle: THandle;
+ status: SInt32;
+ errbuf: TSDL_Error;
+ name: PAnsiChar;
+ data: Pointer;
+ end;
+
+ TSDL_TLSID = Cardinal;
+
+{$IFDEF WINDOWS}
+ {**
+ * SDL_thread.h
+ *
+ * We compile SDL into a DLL. This means, that it's the DLL which
+ * creates a new thread for the calling process with the SDL_CreateThread()
+ * API. There is a problem with this, that only the RTL of the SDL.DLL will
+ * be initialized for those threads, and not the RTL of the calling
+ * application!
+ *
+ * To solve this, we make a little hack here.
+ *
+ * We'll always use the caller's _beginthread() and _endthread() APIs to
+ * start a new thread. This way, if it's the SDL.DLL which uses this API,
+ * then the RTL of SDL.DLL will be used to create the new thread, and if it's
+ * the application, then the RTL of the application will be used.
+ *
+ * So, in short:
+ * Always use the _beginthread() and _endthread() of the calling runtime
+ * library!
+ *}
+{$DEFINE SDL_PASSED_BEGINTHREAD_ENDTHREAD}
+
+type
+ {$IFNDEF DELPHI16UP}
+ TThreadID = Cardinal;
+ {$ENDIF}
+
+ TpfnSDL_CurrentBeginThread = function(SecurityAttributes: Pointer; StackSize: LongWord; ThreadFunc: TThreadFunc; Parameter: Pointer; CreationFlags: LongWord; var ThreadId: TThreadID): Integer;
+
+ TpfnSDL_CurrentEndThread = procedure(ExitCode: Integer);
+
+ {**
+ * Create a thread.
+ *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer; pfnBeginThread: TpfnSDL_CurrentBeginThread; pfnEndThread: TpfnSDL_CurrentEndThread): PSDL_Thread; cdecl; overload; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateThread' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a thread.
+ *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; overload;
+
+{$ELSE}
+
+ {**
+ * Create a thread.
+ *
+ * Thread naming is a little complicated: Most systems have very small
+ * limits for the string length (BeOS has 32 bytes, Linux currently has 16,
+ * Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
+ * have to see what happens with your system's debugger. The name should be
+ * UTF-8 (but using the naming limits of C identifiers is a better bet).
+ * There are no requirements for thread naming conventions, so long as the
+ * string is null-terminated UTF-8, but these guidelines are helpful in
+ * choosing a name:
+ *
+ * http://stackoverflow.com/questions/149932/naming-conventions-for-threads
+ *
+ * If a system imposes requirements, SDL will try to munge the string for
+ * it (truncate, etc), but the original string contents will be available
+ * from SDL_GetThreadName().
+ *}
+function SDL_CreateThread(fn: TSDL_ThreadFunction; name: PAnsiChar; data: Pointer): PSDL_Thread; cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateThread' {$ENDIF} {$ENDIF};
+
+{$ENDIF}
+
+ {**
+ * Get the thread name, as it was specified in SDL_CreateThread().
+ * This function returns a pointer to a UTF-8 string that names the
+ * specified thread, or NULL if it doesn't have a name. This is internal
+ * memory, not to be free()'d by the caller, and remains valid until the
+ * specified thread is cleaned up by SDL_WaitThread().
+ *}
+function SDL_GetThreadName(thread: PSDL_Thread): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetThreadName' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get the thread identifier for the current thread.
+ *}
+function SDL_ThreadID: TSDL_ThreadID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ThreadID' {$ENDIF}{$ENDIF};
+
+ {**
+ * Get the thread identifier for the specified thread.
+ *
+ * Equivalent to SDL_ThreadID() if the specified thread is NULL.
+ *}
+function SDL_GetThreadID(thread: PSDL_Thread): TSDL_ThreadID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetThreadID' {$ENDIF}{$ENDIF};
+
+ {**
+ * Set the priority for the current thread
+ *}
+function SDL_SetThreadPriority(priority: TSDL_ThreadPriority): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetThreadPriority' {$ENDIF}{$ENDIF};
+
+ {**
+ * 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.
+ *}
+procedure SDL_WaitThread(thread: PSDL_Thread; status: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_WaitThread' {$ENDIF}{$ENDIF};
+
+ {**
+ * Create an identifier that is globally visible to all threads but refers to data that is thread-specific.
+ *
+ * The newly created thread local storage identifier, or 0 on error
+ *
+ * static SDL_SpinLock tls_lock;
+ * static SDL_TLSID thread_local_storage;
+ *
+ * void SetMyThreadData(void *value)
+ * {
+ * if (!thread_local_storage) {
+ * SDL_AtomicLock(&tls_lock);
+ * if (!thread_local_storage) {
+ * thread_local_storage = SDL_TLSCreate();
+ * } {
+ * SDL_AtomicUnLock(&tls_lock);
+ * } {
+ * SDL_TLSSet(thread_local_storage, value);
+ * } {
+ *
+ * void *GetMyThreadData(void)
+ * {
+ * return SDL_TLSGet(thread_local_storage);
+ * }{
+ *
+ * SDL_TLSGet()
+ * SDL_TLSSet()
+ *}
+function SDL_TLSCreate: TSDL_TLSID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSCreate' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the value associated with a thread local storage ID for the current thread.
+ *
+ * id The thread local storage ID
+ *
+ * The value associated with the ID for the current thread, or NULL if no value has been set.
+ *
+ * SDL_TLSCreate()
+ * SDL_TLSSet()
+ *}
+function SDL_TLSGet(id: TSDL_TLSID): Pointer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSGet' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the value associated with a thread local storage ID for the current thread.
+ *
+ * id The thread local storage ID
+ * value The value to associate with the ID for the current thread
+ * destructor_ A function called when the thread exits, to free the value.
+ *
+ * 0 on success, -1 on error
+ *
+ * SDL_TLSCreate()
+ * SDL_TLSGet()
+ *}
+function SDL_TLSSet(id: TSDL_TLSID; value: Pointer; destructor_: Pointer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_TLSSet' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_timer.h"
+
+ {**
+ * Get the number of milliseconds since the SDL library initialization.
+ *
+ * This value wraps if the program runs for more than ~49 days.
+ *}
+function SDL_GetTicks: UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTicks' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the current value of the high resolution counter
+ *}
+function SDL_GetPerformanceCounter: UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPerformanceCounter' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the count per second of the high resolution counter
+ *}
+function SDL_GetPerformanceFrequency: UInt64 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetPerformanceFrequency' {$ENDIF} {$ENDIF};
+
+ {**
+ * Wait a specified number of milliseconds before returning.
+ *}
+procedure SDL_Delay(ms: UInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_Delay' {$ENDIF} {$ENDIF};
+
+ {**
+ * Function prototype for the 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.
+ *}
+
+type
+ TSDL_TimerCallback = function(interval: UInt32; param: Pointer): UInt32;
+
+ {**
+ * Definition of the timer ID type.
+ *}
+ TSDL_TimerID = SInt32;
+
+ {**
+ * Add a new timer to the pool of timers already running.
+ *
+ * A timer ID, or NULL when an error occurs.
+ *}
+function SDL_AddTimer(interval: UInt32; callback: TSDL_TimerCallback; param: Pointer): TSDL_TimerID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_AddTimer' {$ENDIF} {$ENDIF};
+
+ {**
+ * Remove a timer knowing its ID.
+ *
+ * A boolean value indicating success or failure.
+ *
+ * It is not safe to remove a timer multiple times.
+ *}
+function SDL_RemoveTimer(id: TSDL_TimerID): Boolean cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RemoveTimer' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_touch.h"
+
+type
+ PSDL_TouchID = ^TSDL_TouchID;
+ TSDL_TouchID = SInt64;
+
+ PSDL_FingerID = ^TSDL_FingerID;
+ TSDL_FingerID = SInt64;
+
+ PSDL_Finger = ^TSDL_Finger;
+ TSDL_Finger = record
+ id: TSDL_FingerID;
+ x: Float;
+ y: Float;
+ pressure: Float;
+ end;
+
+{* Used as the device ID for mouse events simulated with touch input *}
+const
+ SDL_TOUCH_MOUSEID = UInt32(-1);
+
+ {* Function prototypes *}
+
+ {**
+ * Get the number of registered touch devices.
+ *}
+function SDL_GetNumTouchDevices: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumTouchDevices' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the touch ID with the given index, or 0 if the index is invalid.
+ *}
+function SDL_GetTouchDevice(index: SInt32): TSDL_TouchID cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTouchDevice' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the number of active fingers for a given touch device.
+ *}
+function SDL_GetNumTouchFingers(touchID: TSDL_TouchID): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumTouchFingers' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the finger object of the given touch, with the given index.
+ *}
+function SDL_GetTouchFinger(touchID: TSDL_TouchID; index: SInt32): PSDL_Finger cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTouchFinger' {$ENDIF} {$ENDIF};
+
--- /dev/null
+//types from SDLtype_s.h / SDL_stdinc.h
+type
+
+ TSDL_Bool = (SDL_FALSE,SDL_TRUE);
+
+ DWord = LongWord;
+
+ PUInt8Array = ^TUInt8Array;
+ PUInt8 = ^UInt8;
+ PPUInt8 = ^PUInt8;
+ UInt8 = Byte;
+ {$EXTERNALSYM UInt8}
+ TUInt8Array = array [0..MAXINT shr 1] of UInt8;
+
+ PUInt16 = ^UInt16;
+ UInt16 = word;
+ {$EXTERNALSYM UInt16}
+
+ PSInt8 = ^SInt8;
+ SInt8 = Shortint;
+ {$EXTERNALSYM SInt8}
+
+ PSInt16 = ^SInt16;
+ SInt16 = smallint;
+ {$EXTERNALSYM SInt16}
+
+ PUInt32 = ^UInt32;
+ UInt32 = Cardinal;
+ {$EXTERNALSYM UInt32}
+
+ SInt32 = LongInt;
+ {$EXTERNALSYM SInt32}
+
+ PFloat = ^Float;
+ PInt = ^LongInt;
+
+ PShortInt = ^ShortInt;
+
+ {$IFNDEF Has_Int64}
+ PUInt64 = ^UInt64;
+ UInt64 = record
+ hi: UInt32;
+ lo: UInt32;
+ end;
+ {$EXTERNALSYM UInt64}
+
+ PInt64 = ^Int64;
+ Int64 = record
+ hi: UInt32;
+ lo: UInt32;
+ end;
+ {$EXTERNALSYM Int64}
+
+ PSInt64 = ^SInt64;
+ SInt64 = Int64;
+ {$EXTERNALSYM SInt64}
+ {$ELSE}
+ PSInt64 = ^SInt64;
+ SInt64 = Int64;
+ {$ENDIF}
+
+ {$IFNDEF WIN64}
+ size_t = UInt32;
+ {$ELSE}
+ size_t = UInt64;
+ {$ENDIF}
+ {$EXTERNALSYM SIZE_T}
+
+ Float = Single;
+ {$EXTERNALSYM Float}
--- /dev/null
+//from "sdl_version.h"
+
+ {**
+ * Information the version of SDL in use.
+ *
+ * Represents the library's version as three levels: major revision
+ * (increments with massive changes, additions, and enhancements),
+ * minor revision (increments with backwards-compatible changes to the
+ * major revision), and patchlevel (increments with fixes to the minor
+ * revision).
+ *
+ * SDL_VERSION
+ * SDL_GetVersion
+ *}
+type
+ PSDL_Version = ^TSDL_Version;
+ TSDL_Version = record
+ major, {**< major version *}
+ minor, {**< minor version *}
+ patch: UInt8; {**< update version *}
+ end;
+
+{* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
+*}
+const
+ SDL_MAJOR_VERSION = 2;
+ SDL_MINOR_VERSION = 0;
+ SDL_PATCHLEVEL = 0;
+
+{**
+ * Macro to determine SDL version program was compiled against.
+ *
+ * This macro fills in a SDL_version structure with the version of the
+ * library you compiled against. This is determined by what header the
+ * compiler uses. Note that if you dynamically linked the library, you might
+ * have a slightly newer or older version at runtime. That version can be
+ * determined with SDL_GetVersion(), which, unlike SDL_VERSION(),
+ * is not a macro.
+ *
+ * x A pointer to a SDL_version struct to initialize.
+ *
+ * SDL_version
+ * SDL_GetVersion
+ *}
+procedure SDL_VERSION(x: PSDL_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.
+ *}
+function SDL_VERSIONNUM(X,Y,Z: UInt32): Cardinal;
+
+ {**
+ * This is the version number macro for the current SDL version.
+ *}
+function SDL_COMPILEDVERSION: Cardinal;
+
+ {**
+ * This macro will evaluate to true if compiled with SDL at least X.Y.Z.
+ *}
+function SDL_VERSION_ATLEAST(X,Y,Z: Cardinal): Boolean;
+
+ {**
+ * Get the version of SDL that is linked against your program.
+ *
+ * If you are linking to SDL dynamically, then it is possible that the
+ * current version will be different than the version you compiled against.
+ * This function returns the current version, while SDL_VERSION() is a
+ * macro that tells you what version you compiled with.
+ *
+ *
+ * compiled: TSDL_Version;
+ * linked: TSDL_Version;
+ *
+ * SDL_VERSION(@compiled);
+ * SDL_GetVersion(@linked);
+ * WriteLn('We compiled against SDL version: ' +
+ * IntToStr(compiled.major) +
+ * IntToStr(compiled.minor) +
+ * IntToStr(compiled.patch));
+ * WriteLn('But we linked against SDL version:' +
+ * IntToStr(compiled.major) +
+ * IntToStr(compiled.minor) +
+ * IntToStr(compiled.patch));
+ *
+ *
+ * This function may be called safely at any time, even before SDL_Init().
+ *
+ * SDL_VERSION
+ *}
+procedure SDL_GetVersion(ver: PSDL_Version) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetVersion' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the code revision of SDL that is linked against your program.
+ *
+ * Returns an arbitrary string (a hash value) uniquely identifying the
+ * exact revision of the SDL library in use, and is only useful in comparing
+ * against other revisions. It is NOT an incrementing number.
+ *}
+function SDL_GetRevision: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRevision' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the revision number of SDL that is linked against your program.
+ *
+ * Returns a number uniquely identifying the exact revision of the SDL
+ * library in use. It is an incrementing number based on commits to
+ * hg.libsdl.org.
+ *}
+function SDL_GetRevisionNumber: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRevisionNumber' {$ENDIF} {$ENDIF};
--- /dev/null
+//from "sdl_video.h"
+
+ {**
+ * The structure that defines a display mode
+ *
+ * SDL_GetNumDisplayModes()
+ * SDL_GetDisplayMode()
+ * SDL_GetDesktopDisplayMode()
+ * SDL_GetCurrentDisplayMode()
+ * SDL_GetClosestDisplayMode()
+ * SDL_SetWindowDisplayMode()
+ * SDL_GetWindowDisplayMode()
+ *}
+
+ PSDL_DisplayMode = ^TSDL_DisplayMode;
+ TSDL_DisplayMode = record
+ format: UInt32; {**< pixel format *}
+ w: SInt32; {**< width *}
+ h: SInt32; {**< height *}
+ refresh_rate: SInt32; {**< refresh rate (or zero for unspecified) *}
+ driverdata: Pointer; {**< driver-specific data, initialize to 0 *}
+ end;
+
+ {* Define the SDL window-shaper structure *}
+ PSDL_WindowShaper = ^TSDL_WindowShaper;
+ TSDL_WindowShaper = record
+ {* The window associated with the shaper *}
+ window: PSDL_Window;
+
+ {* The user's specified coordinates for the window, for once we give it a shape. *}
+ userx,usery: UInt32;
+
+ {* The parameters for shape calculation. *}
+ mode: TSDL_WindowShapeMode;
+
+ {* Has this window been assigned a shape? *}
+ hasshape: TSDL_Bool;
+
+ driverdata: Pointer;
+ end;
+
+ PSDL_WindowUserData = ^TSDL_WindowUserData;
+ TSDL_WindowUserData = record
+ name: PAnsiChar;
+ data: Pointer;
+ next: PSDL_WindowUserData;
+ end;
+
+ {* Define the SDL window structure, corresponding to toplevel windows *}
+ TSDL_Window = record
+ magic: Pointer;
+ id: UInt32;
+ title: PAnsiChar;
+ x,y: SInt32;
+ w,h: SInt32;
+ min_w, min_h: SInt32;
+ max_w, max_h: SInt32;
+ flags: UInt32;
+
+ {* Stored position and size for windowed mode * }
+ windowed: TSDL_Rect;
+
+ fullscreen_mode: TSDL_DisplayMode;
+
+ brightness: Float;
+ gamma: PUInt16;
+ saved_gamma: PUInt16; {* (just offset into gamma) *}
+
+ surface: PSDL_Surface;
+ surface_valid: TSDL_Bool;
+
+ shaper: PSDL_WindowShaper;
+
+ data: PSDL_WindowUserData;
+
+ driverdata: Pointer;
+
+ prev: PSDL_Window;
+ next: PSDL_Window;
+ end;
+
+ {**
+ * Get the shape parameters of a shaped window.
+ *
+ * window The shaped window whose parameters should be retrieved.
+ * shape_mode An empty shape-mode structure to fill, or NULL to check whether the window has a shape.
+ *
+ * 0 if the window has a shape and, provided shape_mode was not NULL, shape_mode has been filled with the mode
+ * data, SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped window, or SDL_WINDOW_LACKS_SHAPE if
+ * the SDL_Window* given is a shapeable window currently lacking a shape.
+ *
+ * SDL_WindowShapeMode
+ * SDL_SetWindowShape
+ *}
+function SDL_GetShapedWindowMode(window: PSDL_Window; shape_mode: TSDL_WindowShapeMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetShapedWindowMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the shape and parameters of a shaped window.
+ *
+ * window The shaped window whose parameters should be set.
+ * shape A surface encoding the desired shape for the window.
+ * shape_mode The parameters to set for the shaped window.
+ *
+ * 0 on success, SDL_INVALID_SHAPE_ARGUMENT on invalid an invalid shape argument, or SDL_NONSHAPEABLE_WINDOW
+ * if the SDL_Window* given does not reference a valid shaped window.
+ *
+ * SDL_WindowShapeMode
+ * SDL_GetShapedWindowMode.
+ *}
+function SDL_SetWindowShape(window: PSDL_Window; shape: PSDL_Surface; shape_mode: PSDL_WindowShapeMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowShape' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a window that can be shaped with the specified position, dimensions, and flags.
+ *
+ * title The title of the window, in UTF-8 encoding.
+ * x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ * ::SDL_WINDOWPOS_UNDEFINED.
+ * y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ * ::SDL_WINDOWPOS_UNDEFINED.
+ * w The width of the window.
+ * h The height of the window.
+ * flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with any of the following:
+ * SDL_WINDOW_OPENGL, SDL_WINDOW_INPUT_GRABBED,
+ * SDL_WINDOW_SHOWN, SDL_WINDOW_RESIZABLE,
+ * SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED,
+ * SDL_WINDOW_BORDERLESS is always set, and SDL_WINDOW_FULLSCREEN is always unset.
+ *
+ * The window created, or NULL if window creation failed.
+ *
+ * SDL_DestroyWindow()
+ *}
+function SDL_CreateShapedWindow(title: PAnsiChar; x: UInt32; y: UInt32; w: UInt32; h: UInt32; flags: UInt32): PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateShapedWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return whether the given window is a shaped window.
+ *
+ * window The window to query for being shaped.
+ *
+ * SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if the window is unshaped or NULL.
+ * SDL_CreateShapedWindow
+ *}
+function SDL_IsShapedWindow(window: PSDL_Window): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsShapedWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * The type used to identify a window
+ *
+ * SDL_CreateWindow()
+ * SDL_CreateWindowFrom()
+ * SDL_DestroyWindow()
+ * SDL_GetWindowData()
+ * SDL_GetWindowFlags()
+ * SDL_GetWindowGrab()
+ * SDL_GetWindowPosition()
+ * SDL_GetWindowSize()
+ * SDL_GetWindowTitle()
+ * SDL_HideWindow()
+ * SDL_MaximizeWindow()
+ * SDL_MinimizeWindow()
+ * SDL_RaiseWindow()
+ * SDL_RestoreWindow()
+ * SDL_SetWindowData()
+ * SDL_SetWindowFullscreen()
+ * SDL_SetWindowGrab()
+ * SDL_SetWindowIcon()
+ * SDL_SetWindowPosition()
+ * SDL_SetWindowSize()
+ * SDL_SetWindowBordered()
+ * SDL_SetWindowTitle()
+ * SDL_ShowWindow()
+ *}
+
+const
+ {**
+ * The flags on a window
+ *
+ * SDL_GetWindowFlags()
+ *}
+
+ SDL_WINDOW_FULLSCREEN = $00000001; {**< fullscreen window *}
+ SDL_WINDOW_OPENGL = $00000002; {**< window usable with OpenGL context *}
+ SDL_WINDOW_SHOWN = $00000004; {**< window is visible *}
+ SDL_WINDOW_HIDDEN = $00000008; {**< window is not visible *}
+ SDL_WINDOW_BORDERLESS = $00000010; {**< no window decoration *}
+ SDL_WINDOW_RESIZABLE = $00000020; {**< window can be resized *}
+ SDL_WINDOW_MINIMIZED = $00000040; {**< window is minimized *}
+ SDL_WINDOW_MAXIMIZED = $00000080; {**< window is maximized *}
+ SDL_WINDOW_INPUT_GRABBED = $00000100; {**< window has grabbed input focus *}
+ SDL_WINDOW_INPUT_FOCUS = $00000200; {**< window has input focus *}
+ SDL_WINDOW_MOUSE_FOCUS = $00000400; {**< window has mouse focus *}
+ SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN or $00001000;
+ SDL_WINDOW_FOREIGN = $00000800; {**< window not created by SDL *}
+
+type
+ TSDL_WindowFlags = DWord;
+
+function SDL_WindowPos_IsUndefined(X: Variant): Variant;
+function SDL_WindowPos_IsCentered(X: Variant): Variant;
+
+const
+ {**
+ * Used to indicate that you don't care what the window position is.
+ *}
+
+ SDL_WINDOWPOS_UNDEFINED_MASK = $1FFF0000;
+ SDL_WINDOWPOS_UNDEFINED = SDL_WINDOWPOS_UNDEFINED_MASK or 0;
+
+
+ {**
+ * Used to indicate that the window position should be centered.
+ *}
+
+ SDL_WINDOWPOS_CENTERED_MASK = $2FFF0000;
+ SDL_WINDOWPOS_CENTERED = SDL_WINDOWPOS_CENTERED_MASK or 0;
+
+ {**
+ * Event subtype for window events
+ *}
+
+ SDL_WINDOWEVENT_NONE = 0; {**< Never used *}
+ SDL_WINDOWEVENT_SHOWN = 1; {**< Window has been shown *}
+ SDL_WINDOWEVENT_HIDDEN = 2; {**< Window has been hidden *}
+ SDL_WINDOWEVENT_EXPOSED = 3; {**< Window has been exposed and should be redrawn *}
+ SDL_WINDOWEVENT_MOVED = 4; {**< Window has been moved to data1; data2 *}
+ SDL_WINDOWEVENT_RESIZED = 5; {**< Window has been resized to data1xdata2 *}
+ SDL_WINDOWEVENT_SIZE_CHANGED = 6; {**< The window size has changed; either as a result of an API call or through the system or user changing the window size. *}
+ SDL_WINDOWEVENT_MINIMIZED = 7; {**< Window has been minimized *}
+ SDL_WINDOWEVENT_MAXIMIZED = 8; {**< Window has been maximized *}
+ SDL_WINDOWEVENT_RESTORED = 9; {**< Window has been restored to normal size and position *}
+ SDL_WINDOWEVENT_ENTER = 10; {**< Window has gained mouse focus *}
+ SDL_WINDOWEVENT_LEAVE = 11; {**< Window has lost mouse focus *}
+ SDL_WINDOWEVENT_FOCUS_GAINED = 12; {**< Window has gained keyboard focus *}
+ SDL_WINDOWEVENT_FOCUS_LOST = 13; {**< Window has lost keyboard focus *}
+ SDL_WINDOWEVENT_CLOSE = 14; {**< The window manager requests that the window be closed *}
+
+type
+ TSDL_WindowEventID = DWord;
+
+ {**
+ * An opaque handle to an OpenGL context.
+ *}
+
+ TSDL_GLContext = Pointer;
+
+ {**
+ * OpenGL configuration attributes
+ *}
+
+const
+ SDL_GL_RED_SIZE = 0;
+ SDL_GL_GREEN_SIZE = 1;
+ SDL_GL_BLUE_SIZE = 2;
+ SDL_GL_ALPHA_SIZE = 3;
+ SDL_GL_BUFFER_SIZE = 4;
+ SDL_GL_DOUBLEBUFFER = 5;
+ SDL_GL_DEPTH_SIZE = 6;
+ SDL_GL_STENCIL_SIZE = 7;
+ SDL_GL_ACCUM_RED_SIZE = 8;
+ SDL_GL_ACCUM_GREEN_SIZE = 9;
+ SDL_GL_ACCUM_BLUE_SIZE = 10;
+ SDL_GL_ACCUM_ALPHA_SIZE = 11;
+ SDL_GL_STEREO = 12;
+ SDL_GL_MULTISAMPLEBUFFERS = 13;
+ SDL_GL_MULTISAMPLESAMPLES = 14;
+ SDL_GL_ACCELERATED_VISUAL = 15;
+ SDL_GL_RETAINED_BACKING = 16;
+ SDL_GL_CONTEXT_MAJOR_VERSION = 17;
+ SDL_GL_CONTEXT_MINOR_VERSION = 18;
+ SDL_GL_CONTEXT_EGL = 19;
+ SDL_GL_CONTEXT_FLAGS = 20;
+ SDL_GL_CONTEXT_PROFILE_MASK = 21;
+ SDL_GL_SHARE_WITH_CURRENT_CONTEXT = 22;
+
+type
+ TSDL_GLattr = DWord;
+
+const
+ SDL_GL_CONTEXT_PROFILE_CORE = $0001;
+ SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = $0002;
+ SDL_GL_CONTEXT_PROFILE_ES = $0004;
+
+type
+ TSDL_GLprofile = DWord;
+
+const
+ SDL_GL_CONTEXT_DEBUG_FLAG = $0001;
+ SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = $0002;
+ SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG = $0004;
+ SDL_GL_CONTEXT_RESET_ISOLATION_FLAG = $0008;
+
+type
+ TSDL_GLcontextFlag = DWord;
+
+ {* Function prototypes *}
+
+ {**
+ * Get the number of video drivers compiled into SDL
+ *
+ * SDL_GetVideoDriver()
+ *}
+
+function SDL_GetNumVideoDrivers: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumVideoDrivers' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the name of a built in video driver.
+ *
+ * The video drivers are presented in the order in which they are
+ * normally checked during initialization.
+ *
+ * SDL_GetNumVideoDrivers()
+ *}
+
+function SDL_GetVideoDriver(index: SInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetVideoDriver' {$ENDIF} {$ENDIF};
+
+ {**
+ * Initialize the video subsystem, optionally specifying a video driver.
+ *
+ * driver_name Initialize a specific driver by name, or nil for the
+ * default video driver.
+ *
+ * 0 on success, -1 on error
+ *
+ * This function initializes the video subsystem; setting up a connection
+ * to the window manager, etc, and determines the available display modes
+ * and pixel formats, but does not initialize a window or graphics mode.
+ *
+ * SDL_VideoQuit()
+ *}
+
+function SDL_VideoInit(const driver_name: PAnsiChar): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_VideoInit' {$ENDIF} {$ENDIF};
+
+ {**
+ * Shuts down the video subsystem.
+ *
+ * function closes all windows, and restores the original video mode.
+ *
+ * SDL_VideoInit()
+ *}
+procedure SDL_VideoQuit cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_VideoQuit' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the name of the currently initialized video driver.
+ *
+ * The name of the current video driver or nil if no driver
+ * has been initialized
+ *
+ * SDL_GetNumVideoDrivers()
+ * SDL_GetVideoDriver()
+ *}
+
+function SDL_GetCurrentVideoDriver: PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCurrentVideoDriver' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the number of available video displays.
+ *
+ * SDL_GetDisplayBounds()
+ *}
+
+function SDL_GetNumVideoDisplays: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumVideoDisplays' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the name of a display in UTF-8 encoding
+ *
+ * The name of a display, or nil for an invalid display index.
+ *
+ * SDL_GetNumVideoDisplays()
+ *}
+
+function SDL_GetDisplayName(displayIndex: SInt32): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetDisplayName' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the desktop area represented by a display, with the primary
+ * display located at 0,0
+ *
+ * 0 on success, or -1 if the index is out of range.
+ *
+ * SDL_GetNumVideoDisplays()
+ *}
+
+function SDL_GetDisplayBounds(displayIndex: SInt32; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetDisplayBounds' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns the number of available display modes.
+ *
+ * SDL_GetDisplayMode()
+ *}
+
+function SDL_GetNumDisplayModes(displayIndex: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumDisplayModes' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill in information about a specific display mode.
+ *
+ * The display modes are sorted in this priority:
+ * bits per pixel -> more colors to fewer colors
+ * width -> largest to smallest
+ * height -> largest to smallest
+ * refresh rate -> highest to lowest
+ *
+ * SDL_GetNumDisplayModes()
+ *}
+
+function SDL_GetDisplayMode(displayIndex: SInt32; modeIndex: SInt32; mode: PSDL_DisplayMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetDisplayMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill in information about the desktop display mode.
+ *}
+
+function SDL_GetDesktopDisplayMode(displayIndex: SInt32; mode: PSDL_DisplayMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetDesktopDisplayMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill in information about the current display mode.
+ *}
+
+function SDL_GetCurrentDisplayMode(displayIndex: SInt32; mode: PSDL_DisplayMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetCurrentDisplayIndex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the closest match to the requested display mode.
+ *
+ * mode The desired display mode
+ * closest A pointer to a display mode to be filled in with the closest
+ * match of the available display modes.
+ *
+ * The passed in value closest, or nil if no matching video mode
+ * was available.
+ *
+ * The available display modes are scanned, and closest is filled in with the
+ * closest mode matching the requested mode and returned. The mode format and
+ * refresh_rate default to the desktop mode if they are 0. The modes are
+ * scanned with size being first priority, format being second priority, and
+ * finally checking the refresh_rate. If all the available modes are too
+ * small, then nil is returned.
+ *
+ * SDL_GetNumDisplayModes()
+ * SDL_GetDisplayMode()
+ *}
+
+function SDL_GetClosestDisplayMode(displayIndex: SInt32; const mode: PSDL_DisplayMode; closest: PSDL_DisplayMode): PSDL_DisplayMode cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetClosestDisplayMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the display index associated with a window.
+ *
+ * the display index of the display containing the center of the
+ * window, or -1 on error.
+ *}
+
+function SDL_GetWindowDisplayIndex(window: PSDL_Window): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowDisplayIndex' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the display mode used when a fullscreen window is visible.
+ *
+ * By default the window's dimensions and the desktop format and refresh rate
+ * are used.
+ *
+ * mode The mode to use, or nil for the default mode.
+ *
+ * 0 on success, or -1 if setting the display mode failed.
+ *
+ * SDL_GetWindowDisplayMode()
+ * SDL_SetWindowFullscreen()
+ *}
+
+function SDL_SetWindowDisplayMode(window: PSDL_Window; const mode: PSDL_DisplayMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowDisplayMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Fill in information about the display mode used when a fullscreen
+ * window is visible.
+ *
+ * SDL_SetWindowDisplayMode()
+ * SDL_SetWindowFullscreen()
+ *}
+
+function SDL_GetWindowDisplayMode(window: PSDL_Window; mode: PSDL_DisplayMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowDisplayMode' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the pixel format associated with the window.
+ *}
+
+function SDL_GetWindowPixelFormat(window: PSDL_Window): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowPixelFormat' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create a window with the specified position, dimensions, and flags.
+ *
+ * title The title of the window, in UTF-8 encoding.
+ * x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ * ::SDL_WINDOWPOS_UNDEFINED.
+ * y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
+ * ::SDL_WINDOWPOS_UNDEFINED.
+ * w The width of the window.
+ * h The height of the window.
+ * flags The flags for the window, a mask of any of the following:
+ * ::SDL_WINDOW_FULLSCREEN, ::SDL_WINDOW_OPENGL,
+ * ::SDL_WINDOW_SHOWN, ::SDL_WINDOW_BORDERLESS,
+ * ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,
+ * ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_INPUT_GRABBED.
+ *
+ * The id of the window created, or zero if window creation failed.
+ *
+ * SDL_DestroyWindow()
+ *}
+
+function SDL_CreateWindow(const title: PAnsiChar; x: SInt32; y: SInt32; w: SInt32; h: SInt32; flags: UInt32): PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create an SDL window from an existing native window.
+ *
+ * data A pointer to driver-dependent window creation data
+ *
+ * The id of the window created, or zero if window creation failed.
+ *
+ * SDL_DestroyWindow()
+ *}
+
+function SDL_CreateWindowFrom(const data: Pointer): PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateWindowFrom' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the numeric ID of a window, for logging purposes.
+ *}
+
+function SDL_GetWindowID(window: PSDL_Window): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowID' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get a window from a stored ID, or nil if it doesn't exist.
+ *}
+
+function SDL_GetWindowFromID(id: UInt32): PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowFromID' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the window flags.
+ *}
+
+function SDL_GetWindowFlags(window: PSDL_Window): UInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowFlags' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the title of a window, in UTF-8 format.
+ *
+ * SDL_GetWindowTitle()
+ *}
+
+procedure SDL_SetWindowTitle(window: PSDL_Window; const title: PAnsiChar) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowTitle' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the title of a window, in UTF-8 format.
+ *
+ * SDL_SetWindowTitle()
+ *}
+
+function SDL_GetWindowTitle(window: PSDL_Window): PAnsiChar cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowTitle' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the icon for a window.
+ *
+ * icon The icon for the window.
+ *}
+
+procedure SDL_SetWindowIcon(window: PSDL_Window; icon: PSDL_Surface) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowIcon' {$ENDIF} {$ENDIF};
+
+ {**
+ * Associate an arbitrary named pointer with a window.
+ *
+ * window The window to associate with the pointer.
+ * name The name of the pointer.
+ * userdata The associated pointer.
+ *
+ * The previous value associated with 'name'
+ *
+ * The name is case-sensitive.
+ *
+ * SDL_GetWindowData()
+ *}
+
+function SDL_SetWindowData(window: PSDL_Window; const name: PAnsiChar; userdata: Pointer): Pointer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowData' {$ENDIF} {$ENDIF};
+
+ {**
+ * Retrieve the data pointer associated with a window.
+ *
+ * window The window to query.
+ * name The name of the pointer.
+ *
+ * The value associated with 'name'
+ *
+ * SDL_SetWindowData()
+ *}
+
+function SDL_GetWindowData(window: PSDL_Window; const name: PAnsiChar): Pointer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowData' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the position of a window.
+ *
+ * window The window to reposition.
+ * x The x coordinate of the window, SDL_WINDOWPOS_CENTERED, or
+ * SDL_WINDOWPOS_UNDEFINED.
+ * y The y coordinate of the window, SDL_WINDOWPOS_CENTERED, or
+ * SDL_WINDOWPOS_UNDEFINED.
+ *
+ * The window coordinate origin is the upper left of the display.
+ *
+ * SDL_GetWindowPosition()
+ *}
+
+procedure SDL_SetWindowPosition(window: PSDL_Window; x: SInt32; y: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowPosition' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the position of a window.
+ *
+ * x Pointer to variable for storing the x position, may be nil
+ * y Pointer to variable for storing the y position, may be nil
+ *
+ * SDL_SetWindowPosition()
+ *}
+
+procedure SDL_GetWindowPosition(window: PSDL_Window; x: PInt; y: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowPosition' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the size of a window's client area.
+ *
+ * w The width of the window, must be >0
+ * h The height of the window, must be >0
+ *
+ * You can't change the size of a fullscreen window, it automatically
+ * matches the size of the display mode.
+ *
+ * SDL_GetWindowSize()
+ *}
+
+procedure SDL_SetWindowSize(window: PSDL_Window; w: SInt32; h: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the size of a window's client area.
+ *
+ * w Pointer to variable for storing the width, may be nil
+ * h Pointer to variable for storing the height, may be nil
+ *
+ * SDL_SetWindowSize()
+ *}
+
+procedure SDL_GetWindowSize(window: PSDL_Window; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the minimum size of a window's client area.
+ *
+ * min_w The minimum width of the window, must be >0
+ * min_h The minimum height of the window, must be >0
+ *
+ * You can't change the minimum size of a fullscreen window, it
+ * automatically matches the size of the display mode.
+ *
+ * SDL_GetWindowMinimumSize()
+ * SDL_SetWindowMaximumSize()
+ *}
+
+procedure SDL_SetWindowMinimumSize(window: PSDL_Window; min_w: SInt32; min_h: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowMinimumSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the minimum size of a window's client area.
+ *
+ * w Pointer to variable for storing the minimum width, may be nil
+ * h Pointer to variable for storing the minimum height, may be nil
+ *
+ * SDL_GetWindowMaximumSize()
+ * SDL_SetWindowMinimumSize()
+ *}
+
+procedure SDL_GetWindowMinimumSize(window: PSDL_Window; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowMinimumSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the maximum size of a window's client area.
+ *
+ * max_w The maximum width of the window, must be >0
+ * max_h The maximum height of the window, must be >0
+ *
+ * You can't change the maximum size of a fullscreen window, it
+ * automatically matches the size of the display mode.
+ *
+ * SDL_GetWindowMaximumSize()
+ * SDL_SetWindowMinimumSize()
+ *}
+
+procedure SDL_SetWindowMaximumSize(window: PSDL_Window; max_w: SInt32; max_h: SInt32) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowMaximumSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the maximum size of a window's client area.
+ *
+ * w Pointer to variable for storing the maximum width, may be nil
+ * h Pointer to variable for storing the maximum height, may be nil
+ *
+ * SDL_GetWindowMinimumSize()
+ * SDL_SetWindowMaximumSize()
+ *}
+
+procedure SDL_GetWindowMaximumSize(window: PSDL_Window; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowMaximumSize' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the border state of a window.
+ *
+ * This will add or remove the window's SDL_WINDOW_BORDERLESS flag and
+ * add or remove the border from the actual window. This is a no-op if the
+ * window's border already matches the requested state.
+ *
+ * window The window of which to change the border state.
+ * bordered SDL_FALSE to remove border, SDL_TRUE to add border.
+ *
+ * You can't change the border state of a fullscreen window.
+ *
+ * SDL_GetWindowFlags()
+ *}
+
+procedure SDL_SetWindowBordered(window: PSDL_Window; bordered: TSDL_Bool) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowBordered' {$ENDIF} {$ENDIF};
+
+ {**
+ * Show a window.
+ *
+ * SDL_HideWindow()
+ *}
+
+procedure SDL_ShowWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_ShowWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Hide a window.
+ *
+ * SDL_ShowWindow()
+ *}
+
+procedure SDL_HideWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_HideWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Raise a window above other windows and set the input focus.
+ *}
+
+procedure SDL_RaiseWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RaiseWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Make a window as large as possible.
+ *
+ * SDL_RestoreWindow()
+ *}
+
+procedure SDL_MaximizeWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MaximizeWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Minimize a window to an iconic representation.
+ *
+ * SDL_RestoreWindow()
+ *}
+
+procedure SDL_MinimizeWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_MinimizeWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Restore the size and position of a minimized or maximized window.
+ *
+ * SDL_MaximizeWindow()
+ * SDL_MinimizeWindow()
+ *}
+
+procedure SDL_RestoreWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RestoreWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set a window's fullscreen state.
+ *
+ * 0 on success, or -1 if setting the display mode failed.
+ *
+ * SDL_SetWindowDisplayMode()
+ * SDL_GetWindowDisplayMode()
+ *}
+
+function SDL_SetWindowFullscreen(window: PSDL_Window; flags: UInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowFullscreen' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the SDL surface associated with the window.
+ *
+ * The window's framebuffer surface, or nil on error.
+ *
+ * A new surface will be created with the optimal format for the window,
+ * if necessary. This surface will be freed when the window is destroyed.
+ *
+ * You may not combine this with 3D or the rendering API on this window.
+ *
+ * SDL_UpdateWindowSurface()
+ * SDL_UpdateWindowSurfaceRects()
+ *}
+
+function SDL_GetWindowSurface(window: PSDL_Window): PSDL_Surface cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowSurface' {$ENDIF} {$ENDIF};
+
+ {**
+ * Copy the window surface to the screen.
+ *
+ * 0 on success, or -1 on error.
+ *
+ * SDL_GetWindowSurface()
+ * SDL_UpdateWindowSurfaceRects()
+ *}
+
+function SDL_UpdateWindowSurface(window: PSDL_Window): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateWindowSurface' {$ENDIF} {$ENDIF};
+
+ {**
+ * Copy a number of rectangles on the window surface to the screen.
+ *
+ * 0 on success, or -1 on error.
+ *
+ * SDL_GetWindowSurface()
+ * SDL_UpdateWindowSurfaceRect()
+ *}
+
+function SDL_UpdateWindowSurfaceRects(window: PSDL_Window; rects: PSDL_Rect; numrects: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateWindowSurfaceRects' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set a window's input grab mode.
+ *
+ * grabbed This is SDL_TRUE to grab input, and SDL_FALSE to release input.
+ *
+ * SDL_GetWindowGrab()
+ *}
+
+procedure SDL_SetWindowGrab(window: PSDL_Window; grabbed: TSDL_Bool) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowGrab' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get a window's input grab mode.
+ *
+ * This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise.
+ *
+ * SDL_SetWindowGrab()
+ *}
+
+function SDL_GetWindowGrab(window: PSDL_Window): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowGrab' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the brightness (gamma correction) for a window.
+ *
+ * 0 on success, or -1 if setting the brightness isn't supported.
+ *
+ * SDL_GetWindowBrightness()
+ * SDL_SetWindowGammaRamp()
+ *}
+
+function SDL_SetWindowBrightness(window: PSDL_Window; brightness: Float): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowBrightness' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the brightness (gamma correction) for a window.
+ *
+ * The last brightness value passed to SDL_SetWindowBrightness()
+ *
+ * SDL_SetWindowBrightness()
+ *}
+
+function SDL_GetWindowBrightness(window: PSDL_Window): Float cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowBrightness' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the gamma ramp for a window.
+ *
+ * red The translation table for the red channel, or nil.
+ * green The translation table for the green channel, or nil.
+ * blue The translation table for the blue channel, or nil.
+ *
+ * 0 on success, or -1 if gamma ramps are unsupported.
+ *
+ * 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.
+ *
+ * SDL_GetWindowGammaRamp()
+ *}
+
+function SDL_SetWindowGammaRamp(window: PSDL_Window; const red: PUInt16; const green: PUInt16; const blue: PUInt16): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetWindowGammaRamp' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the gamma ramp for a window.
+ *
+ * red A pointer to a 256 element array of 16-bit quantities to hold
+ * the translation table for the red channel, or nil.
+ * green A pointer to a 256 element array of 16-bit quantities to hold
+ * the translation table for the green channel, or nil.
+ * blue A pointer to a 256 element array of 16-bit quantities to hold
+ * the translation table for the blue channel, or nil.
+ *
+ * 0 on success, or -1 if gamma ramps are unsupported.
+ *
+ * SDL_SetWindowGammaRamp()
+ *}
+
+function SDL_GetWindowGammaRamp(window: PSDL_Window; red: PUInt16; green: PUInt16; blue: PUInt16): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetWindowGammaRamp' {$ENDIF} {$ENDIF};
+
+ {**
+ * Destroy a window.
+ *}
+
+procedure SDL_DestroyWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Returns whether the screensaver is currently enabled (default on).
+ *
+ * SDL_EnableScreenSaver()
+ * SDL_DisableScreenSaver()
+ *}
+
+function SDL_IsScreenSaverEnabled: TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_IsScreenSaverEnabled' {$ENDIF} {$ENDIF};
+
+ {**
+ * Allow the screen to be blanked by a screensaver
+ *
+ * SDL_IsScreenSaverEnabled()
+ * SDL_DisableScreenSaver()
+ *}
+
+procedure SDL_EnableScreenSaver cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_EnableScreenSaver' {$ENDIF} {$ENDIF};
+
+ {**
+ * Prevent the screen from being blanked by a screensaver
+ *
+ * SDL_IsScreenSaverEnabled()
+ * SDL_EnableScreenSaver()
+ *}
+
+procedure SDL_DisableScreenSaver cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DisableScreenSaver' {$ENDIF} {$ENDIF};
+
+ {**
+ * OpenGL support functions
+ *}
+
+ {**
+ * Dynamically load an OpenGL library.
+ *
+ * path The platform dependent OpenGL library name, or nil to open the
+ * default OpenGL library.
+ *
+ * 0 on success, or -1 if the library couldn't be loaded.
+ *
+ * This should be done after initializing the video driver, but before
+ * creating any OpenGL windows. If no OpenGL library is loaded, the default
+ * library will be loaded upon creation of the first OpenGL window.
+ *
+ * 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().
+ *
+ * SDL_GL_GetProcAddress()
+ * SDL_GL_UnloadLibrary()
+ *}
+
+function SDL_GL_LoadLibrary(const path: PAnsiChar): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_LoadLibrary' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the address of an OpenGL function.
+ *}
+
+function SDL_GL_GetProcAddress(const proc: PAnsiChar): Pointer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_GetProcAddress' {$ENDIF} {$ENDIF};
+
+ {**
+ * Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
+ *
+ * SDL_GL_LoadLibrary()
+ *}
+
+procedure SDL_GL_UnloadLibrary cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_UnloadLibrary' {$ENDIF} {$ENDIF};
+
+ {**
+ * Return true if an OpenGL extension is supported for the current
+ * context.
+ *}
+
+function SDL_GL_ExtensionSupported(const extension: PAnsiChar): TSDL_Bool cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_ExtensionSupported' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set an OpenGL window attribute before window creation.
+ *}
+
+function SDL_GL_SetAttribute(attr: TSDL_GLattr; value: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_SetAttribute' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the actual value for an attribute from the current context.
+ *}
+
+function SDL_GL_GetAttribute(attr: TSDL_GLattr; value: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_GetAttribute' {$ENDIF} {$ENDIF};
+
+ {**
+ * Create an OpenGL context for use with an OpenGL window, and make it
+ * current.
+ *
+ * SDL_GL_DeleteContext()
+ *}
+
+function SDL_GL_CreateContext(window: PSDL_Window): TSDL_GLContext cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_CreateContext' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set up an OpenGL context for rendering into an OpenGL window.
+ *
+ * The context must have been created with a compatible window.
+ *}
+
+function SDL_GL_MakeCurrent(window: PSDL_Window; context: TSDL_GLContext): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_MakeCurrent' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the currently active OpenGL window.
+ *}
+function SDL_GL_GetCurrentWindow: PSDL_Window cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_GetCurrentWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the currently active OpenGL context.
+ *}
+function SDL_GL_GetCurrentContext: TSDL_GLContext cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_GetCurrentContext' {$ENDIF} {$ENDIF};
+
+ {**
+ * Set the swap interval for the current OpenGL context.
+ *
+ * interval 0 for immediate updates, 1 for updates synchronized with the
+ * vertical retrace. If the system supports it, you may
+ * specify -1 to allow late swaps to happen immediately
+ * instead of waiting for the next retrace.
+ *
+ * 0 on success, or -1 if setting the swap interval is not supported.
+ *
+ * SDL_GL_GetSwapInterval()
+ *}
+
+function SDL_GL_SetSwapInterval(interval: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_SetSwapInterval' {$ENDIF} {$ENDIF};
+
+ {**
+ * Get the swap interval for the current OpenGL context.
+ *
+ * 0 if there is no vertical retrace synchronization, 1 if the buffer
+ * swap is synchronized with the vertical retrace, and -1 if late
+ * swaps happen immediately instead of waiting for the next retrace.
+ * If the system can't determine the swap interval, or there isn't a
+ * valid current context, this will return 0 as a safe default.
+ *
+ * SDL_GL_SetSwapInterval()
+ *}
+
+function SDL_GL_GetSwapInterval: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_GetSwapInterval' {$ENDIF} {$ENDIF};
+
+ {**
+ * Swap the OpenGL buffers for a window, if double-buffering is
+ * supported.
+ *}
+
+procedure SDL_GL_SwapWindow(window: PSDL_Window) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_SwapWindow' {$ENDIF} {$ENDIF};
+
+ {**
+ * Delete an OpenGL context.
+ *
+ * SDL_GL_CreateContext()
+ *}
+
+procedure SDL_GL_DeleteContext(context: TSDL_GLContext) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_DeleteContext' {$ENDIF} {$ENDIF};
+
+ {*OpenGL support functions*}
projects / sdl-headers.git / commitdiff