From cf7c2c61678b4d503863f4e02381077e04b765e7 Mon Sep 17 00:00:00 2001 From: Tim Blume Date: Sun, 5 Jan 2014 12:52:58 +0100 Subject: [PATCH] actual version --- LICENSE.txt | 24 ++ README.md | 4 + SDL2_image.pas | 185 +++++++++ SDL2_mixer.pas | 692 ++++++++++++++++++++++++++++++++ SDL2_net.pas | 482 ++++++++++++++++++++++ SDL2_ttf.pas | 297 ++++++++++++++ jedi.inc | 498 +++++++++++++++++++++++ sdl.inc | 62 +++ sdl2.pas | 367 +++++++++++++++++ sdlaudio.inc | 422 +++++++++++++++++++ sdlblendmode.inc | 15 + sdlerror.inc | 55 +++ sdlevents.inc | 762 +++++++++++++++++++++++++++++++++++ sdlgesture.inc | 35 ++ sdlhaptic.inc | 1157 +++++++++++++++++++++++++++++++++++++++++++++++++++++ sdlhints.inc | 31 ++ sdljoystick.inc | 185 +++++++++ sdlkeyboard.inc | 177 ++++++++ sdlloadso.inc | 20 + sdlmessagebox.inc | 108 +++++ sdlmouse.inc | 185 +++++++++ sdlmutex.inc | 194 +++++++++ sdlpixels.inc | 504 +++++++++++++++++++++++ sdlplatform.inc | 6 + sdlpower.inc | 26 ++ sdlrect.inc | 83 ++++ sdlrenderer.inc | 716 +++++++++++++++++++++++++++++++++ sdlrwops.inc | 188 +++++++++ sdlscancode.inc | 663 ++++++++++++++++++++++++++++++ sdlshape.inc | 43 ++ sdlsurface.inc | 440 ++++++++++++++++++++ sdlthread.inc | 193 +++++++++ sdltimer.inc | 56 +++ sdltouch.inc | 43 ++ sdltype.inc | 70 ++++ sdlversion.inc | 113 ++++++ sdlvideo.inc | 1044 +++++++++++++++++++++++++++++++++++++++++++++++ 37 files changed, 10145 insertions(+) create mode 100644 LICENSE.txt create mode 100644 README.md create mode 100644 SDL2_image.pas create mode 100644 SDL2_mixer.pas create mode 100644 SDL2_net.pas create mode 100644 SDL2_ttf.pas create mode 100644 jedi.inc create mode 100644 sdl.inc create mode 100644 sdl2.pas create mode 100644 sdlaudio.inc create mode 100644 sdlblendmode.inc create mode 100644 sdlerror.inc create mode 100644 sdlevents.inc create mode 100644 sdlgesture.inc create mode 100644 sdlhaptic.inc create mode 100644 sdlhints.inc create mode 100644 sdljoystick.inc create mode 100644 sdlkeyboard.inc create mode 100644 sdlloadso.inc create mode 100644 sdlmessagebox.inc create mode 100644 sdlmouse.inc create mode 100644 sdlmutex.inc create mode 100644 sdlpixels.inc create mode 100644 sdlplatform.inc create mode 100644 sdlpower.inc create mode 100644 sdlrect.inc create mode 100644 sdlrenderer.inc create mode 100644 sdlrwops.inc create mode 100644 sdlscancode.inc create mode 100644 sdlshape.inc create mode 100644 sdlsurface.inc create mode 100644 sdlthread.inc create mode 100644 sdltimer.inc create mode 100644 sdltouch.inc create mode 100644 sdltype.inc create mode 100644 sdlversion.inc create mode 100644 sdlvideo.inc diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..00d2e13 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,24 @@ +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 \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..9c5f9b9 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +Pascal-SDL-2-Headers +==================== + +This are the Pascal SDL 2 Headers. \ No newline at end of file diff --git a/SDL2_image.pas b/SDL2_image.pas new file mode 100644 index 0000000..aefa22a --- /dev/null +++ b/SDL2_image.pas @@ -0,0 +1,185 @@ +unit sdl2_image; + +{* + SDL_image: An example image loading library for use with SDL + Copyright (C) 1997-2013 Sam Lantinga + + 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. diff --git a/SDL2_mixer.pas b/SDL2_mixer.pas new file mode 100644 index 0000000..f1f2891 --- /dev/null +++ b/SDL2_mixer.pas @@ -0,0 +1,692 @@ +unit SDL2_mixer; + +{* + SDL_mixer: An audio mixer library based on the SDL library + Copyright (C) 1997-2013 Sam Lantinga + + 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. diff --git a/SDL2_net.pas b/SDL2_net.pas new file mode 100644 index 0000000..f8f1502 --- /dev/null +++ b/SDL2_net.pas @@ -0,0 +1,482 @@ +unit SDL2_net; + +{* + SDL_net: An example cross-platform network library for use with SDL + Copyright (C) 1997-2013 Sam Lantinga + Copyright (C) 2012 Simeon Maxein + + 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. + diff --git a/SDL2_ttf.pas b/SDL2_ttf.pas new file mode 100644 index 0000000..86ff0c2 --- /dev/null +++ b/SDL2_ttf.pas @@ -0,0 +1,297 @@ +unit sdl2_ttf; + +{* + SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts + Copyright (C) 2001-2013 Sam Lantinga + + 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. + diff --git a/jedi.inc b/jedi.inc new file mode 100644 index 0000000..d7b1daa --- /dev/null +++ b/jedi.inc @@ -0,0 +1,498 @@ +{ + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + 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} diff --git a/sdl.inc b/sdl.inc new file mode 100644 index 0000000..17b0b86 --- /dev/null +++ b/sdl.inc @@ -0,0 +1,62 @@ +//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}; + diff --git a/sdl2.pas b/sdl2.pas new file mode 100644 index 0000000..d2c4fb4 --- /dev/null +++ b/sdl2.pas @@ -0,0 +1,367 @@ +unit SDL2; + +{ + Simple DirectMedia Layer + Copyright (C) 1997-2013 Sam Lantinga + + 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. diff --git a/sdlaudio.inc b/sdlaudio.inc new file mode 100644 index 0000000..3c65aa1 --- /dev/null +++ b/sdlaudio.inc @@ -0,0 +1,422 @@ +//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}; + diff --git a/sdlblendmode.inc b/sdlblendmode.inc new file mode 100644 index 0000000..d655dc7 --- /dev/null +++ b/sdlblendmode.inc @@ -0,0 +1,15 @@ +//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 *} diff --git a/sdlerror.inc b/sdlerror.inc new file mode 100644 index 0000000..523e9cb --- /dev/null +++ b/sdlerror.inc @@ -0,0 +1,55 @@ +//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}; diff --git a/sdlevents.inc b/sdlevents.inc new file mode 100644 index 0000000..6b4cbf5 --- /dev/null +++ b/sdlevents.inc @@ -0,0 +1,762 @@ +//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}; diff --git a/sdlgesture.inc b/sdlgesture.inc new file mode 100644 index 0000000..b4640fd --- /dev/null +++ b/sdlgesture.inc @@ -0,0 +1,35 @@ +//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}; diff --git a/sdlhaptic.inc b/sdlhaptic.inc new file mode 100644 index 0000000..b0ef8f4 --- /dev/null +++ b/sdlhaptic.inc @@ -0,0 +1,1157 @@ +//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}; + diff --git a/sdlhints.inc b/sdlhints.inc new file mode 100644 index 0000000..e0d7a7e --- /dev/null +++ b/sdlhints.inc @@ -0,0 +1,31 @@ +//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 diff --git a/sdljoystick.inc b/sdljoystick.inc new file mode 100644 index 0000000..a2df058 --- /dev/null +++ b/sdljoystick.inc @@ -0,0 +1,185 @@ +//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}; diff --git a/sdlkeyboard.inc b/sdlkeyboard.inc new file mode 100644 index 0000000..90040aa --- /dev/null +++ b/sdlkeyboard.inc @@ -0,0 +1,177 @@ +//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}; diff --git a/sdlloadso.inc b/sdlloadso.inc new file mode 100644 index 0000000..b80c935 --- /dev/null +++ b/sdlloadso.inc @@ -0,0 +1,20 @@ +//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); diff --git a/sdlmessagebox.inc b/sdlmessagebox.inc new file mode 100644 index 0000000..2728f56 --- /dev/null +++ b/sdlmessagebox.inc @@ -0,0 +1,108 @@ +//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}; + diff --git a/sdlmouse.inc b/sdlmouse.inc new file mode 100644 index 0000000..906a331 --- /dev/null +++ b/sdlmouse.inc @@ -0,0 +1,185 @@ +//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: + * + * + * + * + * + * + *
data mask resulting pixel on screen
0 1 White
1 1 Black
0 0 Transparent
1 0 Inverted color if possible, black + * if not.
+ * + * 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); diff --git a/sdlmutex.inc b/sdlmutex.inc new file mode 100644 index 0000000..802ce98 --- /dev/null +++ b/sdlmutex.inc @@ -0,0 +1,194 @@ +//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}; diff --git a/sdlpixels.inc b/sdlpixels.inc new file mode 100644 index 0000000..9e81ca5 --- /dev/null +++ b/sdlpixels.inc @@ -0,0 +1,504 @@ +//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}; diff --git a/sdlplatform.inc b/sdlplatform.inc new file mode 100644 index 0000000..fe283c5 --- /dev/null +++ b/sdlplatform.inc @@ -0,0 +1,6 @@ +//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}; diff --git a/sdlpower.inc b/sdlpower.inc new file mode 100644 index 0000000..1e1bcb6 --- /dev/null +++ b/sdlpower.inc @@ -0,0 +1,26 @@ +//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}; diff --git a/sdlrect.inc b/sdlrect.inc new file mode 100644 index 0000000..b7837bd --- /dev/null +++ b/sdlrect.inc @@ -0,0 +1,83 @@ +//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}; diff --git a/sdlrenderer.inc b/sdlrenderer.inc new file mode 100644 index 0000000..d3654d2 --- /dev/null +++ b/sdlrenderer.inc @@ -0,0 +1,716 @@ +//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}; diff --git a/sdlrwops.inc b/sdlrwops.inc new file mode 100644 index 0000000..68ef905 --- /dev/null +++ b/sdlrwops.inc @@ -0,0 +1,188 @@ +//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 } diff --git a/sdlscancode.inc b/sdlscancode.inc new file mode 100644 index 0000000..792ddba --- /dev/null +++ b/sdlscancode.inc @@ -0,0 +1,663 @@ +//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; diff --git a/sdlshape.inc b/sdlshape.inc new file mode 100644 index 0000000..58ea469 --- /dev/null +++ b/sdlshape.inc @@ -0,0 +1,43 @@ +//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; diff --git a/sdlsurface.inc b/sdlsurface.inc new file mode 100644 index 0000000..02f8985 --- /dev/null +++ b/sdlsurface.inc @@ -0,0 +1,440 @@ +//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}; diff --git a/sdlthread.inc b/sdlthread.inc new file mode 100644 index 0000000..62efeff --- /dev/null +++ b/sdlthread.inc @@ -0,0 +1,193 @@ +//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}; diff --git a/sdltimer.inc b/sdltimer.inc new file mode 100644 index 0000000..65db677 --- /dev/null +++ b/sdltimer.inc @@ -0,0 +1,56 @@ +//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}; diff --git a/sdltouch.inc b/sdltouch.inc new file mode 100644 index 0000000..92b6a68 --- /dev/null +++ b/sdltouch.inc @@ -0,0 +1,43 @@ +//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}; + diff --git a/sdltype.inc b/sdltype.inc new file mode 100644 index 0000000..7ffdb0e --- /dev/null +++ b/sdltype.inc @@ -0,0 +1,70 @@ +//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} diff --git a/sdlversion.inc b/sdlversion.inc new file mode 100644 index 0000000..6417812 --- /dev/null +++ b/sdlversion.inc @@ -0,0 +1,113 @@ +//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}; diff --git a/sdlvideo.inc b/sdlvideo.inc new file mode 100644 index 0000000..bed5eed --- /dev/null +++ b/sdlvideo.inc @@ -0,0 +1,1044 @@ +//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*} -- 2.1.4