All Identifiers

AA Circle

AA Ellipse

AA Line

AA-Polygon

AA-Trigon

Arc

< As above, but big-endian byte order *

< 32-bit floating point samples *

< Unsigned 16-bit samples *

< As above, but big-endian byte order *

< 32-bit integer samples *

< As above, but big-endian byte order *

< Signed 16-bit samples *

Bezier

Filled rectangle (Box)

Circle

wchar_t is the "wide character" type of the C language. The size of this type is platform- and compiler-dependent.

While FPC does have it's own "wide character" type, System.WideChar, that one is defined as always being 16-bits, so we can't re-use it here.

When using FPC on Unices, the UnixType unit provides a wchar_t definition.

On other systems/compiler combos, let's just go by what the CPP reference wiki claims, i.e: - wchar_t is 16-bits on Windows - wchar_t is 32-bits on Linux "and many other non-Windows systems"

See: https://en.cppreference.com/w/cpp/language/types#Character_types

Filled Circle

Filled Ellipse

Filled Pie

Filled Polygon

Filled Trigon

! \brief Default rate of framerate controller in Hz (1/s).

! \brief Highest possible rate supported by framerate controller in Hz (1/s).

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.

Functions to detect a file type, given a seekable source *

This function gets the version of the dynamically linked SDL_image library.

Note that this function does NOT allocate a new TSDL_Version and fill it with info, but returns a pointer to a TSDL_Version residing inside dynlinked file.

As such, attempting to Dispose() of this memory will result in access violation.

Load an image directly into a render texture. *

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.

Line

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.

The default mixer has 8 simultaneous mixing channels *

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

Free an audio chunk previously loaded *

Get the Mix_Chunk currently associated with a mixer channel Returns NULL if it's an invalid channel, or there's no chunk associated.

Get a pointer to the user data for the current music hook *

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().

Finds the first available channel in a group of channels, returning -1 if none are available.

Assign several consecutive channels to a group *

Finds the "most recent" (i.e. last) sample playing in a group of channels *

Halt playing of a particular channel *

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.

Load a music file from an SDL_RWop object assuming a specific format *

Backwards compatibility *

Pause/Resume the music stream *

The same as above, but the sound is played at most 'ticks' milliseconds *

Find out what the actual audio device parameters are. This function returns 1 if the audio has been opened, 0 otherwise.

Load a wave file of the mixer format from a memory buffer *

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().

We'll use SDL for reporting errors *

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, MP3_MPG and MODPLUG music (set position in seconds), at the moment.

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().

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().

Synchro value is set by MikMod from modules while playing *

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().

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.

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.

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!

The different fading types supported *

// Removed in SDL2_mixer 2.0.2 MIX_INIT_MODPLUG = $00000004; MIX_INIT_FLUIDSYNTH = $00000020;

Array component order, low byte -> high byte. *

This function is called when the audio device needs more data.

\param userdata An application-specific parameter saved in the SDL_AudioSpec structure \param stream A pointer to the audio data buffer. \param 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.

You can choose to avoid callbacks and use SDL_QueueAudio() instead, if you like. Just open your audio device with a NULL callback.

Audio device event structure (event.adevice.*)

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.

Audio state

Get the current audio state.

\brief The normalized factor used to multiply pixel components

\brief The blend operation used when combining source and destination pixel components

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.

The SDL condition variable structure, defined in SDL_cond.c

Game controller button event structure (event.cbutton.*)

Game controller sensor event structure (event.csensor.*)

2.24.1 from "sdl_mouse.h"

\brief Event subtype for display events

< Display has been removed from the system *

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.

#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))

2.26.5 from "sdl_events.h"

\brief The structure that defines a point (floating point)

\sa SDL_EnclosePoints \sa SDL_PointInRect

The list of axes available from a controller

The list of buttons available from a controller

OpenGL configuration attributes

An SDL_GUID is a 128-bit identifier for an input device that identifies that device across runs of SDL programs on the same platform. If the device is detached and then re-attached to a different port, or if the base system is rebooted, the device should still report the same GUID.

GUIDs are as precise as possible but are not guaranteed to distinguish physically distinct but equivalent devices. For example, two game controllers from the same vendor with the same product ID and revision may have the same GUID.

GUIDs may be platform-dependent (i.e., the same device may report different GUIDs on different operating systems).

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

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

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

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

/** \brief An enumeration of hint priorities /

\brief Possible return values from the SDL_HitTest callback.

\sa SDL_HitTest

Joystick axis motion event structure (event.jaxis.*)

Joysick battery level change event structure (event.jbattery.*)

Joystick device event structure (event.jdevice.*)

The joystick structure used to identify an SDL joystick *

This is a unique ID for a joystick for the time it is connected to the system, and is never reused for the lifetime of the application. If the joystick is disconnected and reconnected, it will get a new ID.

The ID value starts at 0 and increments from there. The value -1 is an invalid ID.

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.

A special exception is the number keys at the top of the keyboard which always map to SDLK_0...SDLK_9, regardless of layout.

\brief The SDL keysym structure, used in key events.

\note If you are looking for translated character input, see the:: SDL_TEXTINPUT event.

\brief The predefined log categories

By default the application category is enabled at the INFO level, the assert category is enabled at the WARN level, test is enabled at the VERBOSE level and all other categories are enabled at the CRITICAL level.

\brief The predefined log priorities

Individual button data.

RGB value used in a message box color scheme

SDL_MessageBox flags. If supported will display warning icon, etc.

Mouse motion event structure (event.motion.*)

Mouse wheel event structure (event.wheel.*)

The SDL mutex structure, defined in SDL_sysmutex.c

Packed component order, high bit -> low bit. *

Everything in the pixel format structure is read-only.

\brief The structure that defines a point (integer)

\sa SDL_EnclosePoints \sa SDL_PointInRect

The "quit requested" event

\brief A rectangle, with the origin at the upper left (integer).

\sa SDL_RectEmpty \sa SDL_RectEquals \sa SDL_HasIntersection \sa SDL_IntersectRect \sa SDL_UnionRect \sa SDL_EnclosePoints

< The renderer supports rendering to texture *

Read-Only memory stream *

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: https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf

\brief SDL_sensor.h

In order to use these functions, SDL_Init() must have been called with the ::SDL_INIT_SENSOR flag. This causes SDL to scan the system for sensors, and load appropriate drivers.

This is a unique ID for a sensor for the time it is connected to the system, and is never reused for the lifetime of the application.

The ID value starts at 0 and increments from there. The value -1 is an invalid ID.

Atomic locks are efficient spinlocks using CPU instructions, but are vulnerable to starvation and can spin forever if a thread holding a lock has been terminated. For this reason you should minimize the code executed inside an atomic lock and never do expensive things like API or system calls while holding them.

The atomic locks are not safe to lock recursively.

Cursor types for SDL_CreateSystemCursor.

The custom window manager information structure.

When this structure is returned, it holds information about which low level system it is using, and will be one of SDL_SYSWM_TYPE.

Keyboard text editing event structure (event.edit.*)

Keyboard text input event structure (event.text.*)

The access pattern allowed for a texture.

The SDL thread ID *

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.

Thread local storage ID, 0 is the invalid ID *

Touch finger event structure (event.tfinger.*)

A user-defined event type (event.user.*)

2.0.14 from "sdl_video.h"

Event subtype for window events

A struct that tags the SDL_WindowShapeParams union with an enum describing the type of its contents. *

Direction flags

\sa TTF_SetFontDirection

Data types for all compilers

Data types for all compilers

Data types for all compilers

\brief An enum denoting the specific type of contents present in an SDL_WindowShapeParams union. *

\brief A handle representing an open HID device.

Rotozoom functions

Rounded-Corner Filled rectangle (Box)

Rounded-Corner Rectangle

< Seek from the beginning of data *

C: '\x1B'

C: '\r'

Skip uppercase letters

C: '\t'

C: '\b'

Allocate/resize/free a single UDP packet 'size' bytes long. The new packet is returned, or NULL if the function ran out of memory.

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.

Remove a socket from a set of sockets to be checked for available data *

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.

The maximum addresses bound to a single UDP socket channel *

Accept an incoming connection on the given server socket. The newly created socket is returned, or NULL if there was an error.

Get the IP address of the remote system associated with the socket. If the socket is a server socket, this function returns NULL.

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.

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.

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.

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.

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.

Set the percentage of simulated packet loss for packets sent on the socket. *

Calculate the arc cosine of x; that is, the value (in radians) whose cosine equals x.

\since This function is available since SDL 2.0.4.

Create an SDL_PixelFormat structure corresponding to a pixel format.

Returned structure may come from a shared global cache (i.e. not newly allocated), and hence should not be modified, especially the palette. Weird errors such as `Blit combination not supported` may occur.

\param pixel_format one of the SDL_PixelFormatEnum values \returns the new SDL_PixelFormat structure or NULL on failure; call SDL_GetError() for more information.

\since This function is available since SDL 2.0.0.

\sa SDL_FreeFormat

RWFrom functions*

The application is now interactive. * Called on iOS in applicationDidBecomeActive() * Called on Android in onResume() *

The application is being terminated by the OS. * Called on iOS in applicationWillTerminate() * Called on Android in onDestroy() *

The application is about to enter the foreground. * Called on iOS in applicationWillEnterForeground() * Called on Android in onResume() *

Calculate the arc sine of x; that is, the value (in radians) whose sine equals x.

\since This function is available since SDL 2.0.4.

Calculate the arc tangent of x; that is, the value (in radians) whose tangent equals x.

\since This function is available since SDL 2.0.4.

Calculate the arc tangent of y/x, using the signs of the two arguments to determine the quadrant of the result.

\since This function is available since SDL 2.0.8.

Add to an atomic variable, and return the old value.

This function also acts as a full memory barrier.

Set a pointer to a new value if it is currently an old value.

Get the value of an atomic variable.

Increment an atomic variable used as a reference count.

Set an atomic variable to a new value and return the old one.

This function also acts as a full memory barrier.

Try to lock a spin lock by setting it to a non-zero value.

\brief Upper limit of filters in SDL_AudioCVT

The maximum number of SDL_AudioFilter functions in SDL_AudioCVT is currently limited to 9. The SDL_AudioCVT.filters array has 10 pointers, one of which is the terminating NULL pointer.

A new audio device is available

Use this function to shut down audio if you initialized it with SDL_AudioInit().

This function is 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_Quit() or SDL_QuitSubSystem().

\since This function is available since SDL 2.0.0.

\sa SDL_AudioInit

Clear any pending data in the stream without converting it

\since This function is available since SDL 2.0.7.

\sa SDL_NewAudioStream \sa SDL_AudioStreamPut \sa SDL_AudioStreamGet \sa SDL_AudioStreamAvailable \sa SDL_AudioStreamFlush \sa SDL_FreeAudioStream

Get converted/resampled data from the stream

\param stream The stream the audio is being requested from \param buf A buffer to fill with audio data \param len The maximum number of bytes to fill \returns the number of bytes read from the stream, or -1 on error

\since This function is available since SDL 2.0.7.

\sa SDL_NewAudioStream \sa SDL_AudioStreamPut \sa SDL_AudioStreamAvailable \sa SDL_AudioStreamFlush \sa SDL_AudioStreamClear \sa SDL_FreeAudioStream

< 1-dstR, 1-dstG, 1-dstB, 1-dstA *

< 0, 0, 0, 0 *

< dstR, dstG, dstB, dstA *

< srcR, srcG, srcB, srcA *

< 1, 1, 1, 1 *

< alpha blending dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA)) dstA = srcA + (dstA * (1-srcA)) *

< color multiply dstRGB = (srcRGB * dstRGB) + (dstRGB * (1-srcA)) dstA = (srcA * dstA) + (dstA * (1-srcA)) *

< color modulate dstRGB = srcRGB * dstRGB dstA = dstA *

< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES

< dst + src: supported by all renderers *

SDL_surface.h uses #define to change all SDL_BlitSurfaceScaled() calls into SDL_UpperBlitScaled() calls. * Since Pascal macro support is very limited, we workaround by outright pointing SDL_BlitSurfaceScaled() to SDL_UpperBlitScaled().

Used as a mask when testing buttons in buttonstate. - Button 1: Left mouse button - Button 2: Middle mouse button - Button 3: Right mouse button

Pascal Conv.: For better performance instead of using the SDL_Button(X) macro, the following defines are implemented directly.

/** Calculate a 256 entry gamma ramp for a gamma value.

\param gamma a gamma value where 0.0 is black and 1.0 is identity \param ramp an array of 256 values filled in with the gamma ramp

\since This function is available since SDL 2.0.0.

\sa SDL_SetWindowGammaRamp

Capture the mouse and to track input outside an SDL window.

Capturing enables your app to obtain mouse events globally, instead of just within your window. Not all video targets support this function. When capturing is enabled, the current window will get all mouse events, but unlike relative mode, no change is made to the cursor and it is not restrained to your window.

This function may also deny mouse input to other windows–both those in your application and others on the system–so you should use this function sparingly, and in small bursts. For example, you might want to track the mouse while the user is dragging something, until the user releases a mouse button. It is not recommended that you capture the mouse for long periods of time, such as the entire time your app is running. For that, you should probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending on your goals.

While captured, mouse events still report coordinates relative to the current (foreground) window, but those coordinates may be outside the bounds of the window (including negative values). Capturing is only allowed for the foreground window. If the window loses focus while capturing, the capture will be disabled automatically.

While capturing is enabled, the current window will have the `SDL_WINDOW_MOUSE_CAPTURE` flag set.

Please note that as of SDL 2.0.22, SDL will attempt to "auto capture" the mouse while the user is pressing a button; this is to try and make mouse behavior more consistent between platforms, and deal with the common case of a user dragging the mouse outside of the window. This means that if you are calling SDL_CaptureMouse() only to deal with this situation, you no longer have to (although it is safe to do so). If this causes problems for your app, you can disable auto capture by setting the `SDL_HINT_MOUSE_AUTO_CAPTURE` hint to zero.

\param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable. \returns 0 on success or -1 if not supported; call SDL_GetError() for more information.

\since This function is available since SDL 2.0.4.

\sa SDL_GetGlobalMouseState

Calculate the smallest integral value that is not less than x.

\since This function is available since SDL 2.0.8.

\brief Clear the error message for the current thread

Drop any queued audio data waiting to be sent to the hardware.

Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For output devices, the hardware will start playing silence if more audio isn't queued. For capture devices, the hardware will start filling the empty queue with new data if the capture device isn't paused.

This will not prevent playback of queued audio that's already been sent to the hardware, as we can not undo that, so expect there to be some fraction of a second of audio that might still be heard. This can be useful if you want to, say, drop any pending music or any unprocessed microphone input during a level change in your game.

You may not queue or dequeue audio on a device that is using an application-supplied callback; calling this function on such a device always returns 0. You have to use the audio callback or queue audio, but not both.

You should not call SDL_LockAudio() on the device before clearing the queue; SDL handles locking internally for this function.

This function always succeeds and thus returns void.

\param dev the device ID of which to clear the audio queue

\since This function is available since SDL 2.0.4.

\sa SDL_GetQueuedAudioSize \sa SDL_QueueAudio \sa SDL_DequeueAudio

This function is a legacy means of closing the audio device.

This function is equivalent to calling...

```c SDL_CloseAudioDevice(1); ```

...and is only useful if you used the legacy SDL_OpenAudio() function.

\since This function is available since SDL 2.0.0.

\sa SDL_OpenAudio

Unused (do not remove) (needed in pascal?)

The compiler barrier prevents the compiler from reordering reads and writes to globally visible variables across the call.

Restart all threads that are waiting on the condition variable.

\param cond the condition variable to signal \returns 0 on success or a negative error code on failure; call SDL_GetError() for more information.

\since This function is available since SDL 2.0.0.

Wait until a condition variable is signaled.

This function unlocks the specified `mutex` and waits for another thread to call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable `cond`. Once the condition variable is signaled, the mutex is re-locked and the function returns.

The mutex must be locked before calling this function.

This function is the equivalent of calling SDL_CondWaitTimeout() with a time length of SDL_MUTEX_MAXWAIT.

\param cond the condition variable to wait on \param mutex the mutex used to coordinate thread access \returns 0 when it is signaled or a negative error code on failure; call SDL_GetError() for more information.

\since This function is available since SDL 2.0.0.

Game controller events

Game controller button pressed

An opened Game controller has been removed

Game controller touchpad finger was lifted

Game controller touchpad was touched

< Xbox Elite paddle P1 *

< Xbox Elite paddle P2 *

< Xbox Elite paddle P4 *