All Identifiers

float32 support

< As above, but big-endian byte order *

int32 support

< Unsigned 8-bit samples *

< Signed 8-bit samples *

Audio format flags

Defaults to LSB byte order.

"The following type designates an unsigned integer type [or signed respectivly] with the property that any valid pointer to void can be converted to this type, then converted back to a pointer to void, and the result will compare equal to the original pointer: uintptr_t" Source: https://pubs.opengroup.org/onlinepubs/000095399/basedefs/stdint.h.html

"The following type designates an unsigned integer type [or signed respectivly] with the property that any valid pointer to void can be converted to this type, then converted back to a pointer to void, and the result will compare equal to the original pointer: uintptr_t" Source: https://pubs.opengroup.org/onlinepubs/000095399/basedefs/stdint.h.html

"The following type designates an unsigned integer type [or signed respectivly] with the property that any valid pointer to void can be converted to this type, then converted back to a pointer to void, and the result will compare equal to the original pointer: uintptr_t" Source: https://pubs.opengroup.org/onlinepubs/000095399/basedefs/stdint.h.html

Ellipse

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.

General event structure

trackpad with relative device coordinates *

\brief Window flash operation

A rectangle, with the origin at the upper left. (floating point)

The gamecontroller structure used to identify an SDL game controller *

2.24.0 from "sdl_gesture.h"

An opaque handle to an OpenGL context.

SDL_Haptic

The haptic structure used to identify an SDL haptic.

SDL_HapticOpen SDL_HapticOpenFromJoystick SDL_HapticClose

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

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

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

/** \brief Add a function to watch a particular hint

\param name The hint to watch \param callback The function to call when the hint value changes \param userdata A pointer to pass to the callback function /

\brief Callback used for hit-testing.

\sa SDL_SetWindowHitTest

2.24.0 based on "sdl.h"

Joystick trackball motion event structure (event.jball.*)

Joystick button event structure (event.jbutton.*)

Joystick hat position change event structure (event.jhat.*)

A structure that encodes the stable unique id for a joystick device *

Keyboard button event structure (event.key.*)

Enumeration of valid key mods (possibly OR'd together).

2.24.0 based on SDL_locale.h

\brief The prototype for the log output function

Flags for SDL_MessageBoxButtonData.

A set of colors to use for message box dialogs

MessageBox structure containing title, text, window, etc.

Mouse button event structure (event.button.*)

Multiple Finger Gesture Event (event.mgesture.*)

Packed component layout. *

Pixel type. *

The basic state for the system's power supply.

A structure representing rendering state

Information on the capabilities of a render driver or context.

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 function passed to SDL_CreateThread().

\param data what was passed as `data` to SDL_CreateThread() \returns a value that can be reported through SDL_WaitThread().

The SDL thread priority.

SDL will make system changes as necessary in order to apply the thread priority. Code which attempts to control thread state related to priority should be aware that calling SDL_SetThreadPriority may alter such state. SDL_HINT_THREAD_PRIORITY_POLICY can be used to control aspects of this behavior.

\note On many systems you require special privileges to set high or time critical priority.

Definition of the timer ID type.

2.0.18 from "sdl_touch.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

Window state change event data (event.window.*)

The flags on a window

SDL_GetWindowFlags()

A union containing parameters for shaped windows. *

The internal structure containing font information *

Data types for all compilers

Data types for all compilers

Data types for all compilers

this is opaque to the outside world.

The condition variable type.

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.

\brief A handle representing an open HID device.

Rectangle

Specialized rotation functions

< Seek relative to current read point *

—< SDL2_gfxPrimitives.h >—

SDL2-for-Pascal: In C the following scancodes are or'd by a macro: SDL_SCANCODE_TO_KEYCODE(X) (X | SDLK_SCANCODE_MASK)

We convert the scancodes directly by: TSDL_KeyCode(X or SDLK_SCANCODE_MASK);

C: '\x7F'

C: '\\'

#define SDL_SCANCODE_TO_KEYCODE(X) (X | SDLK_SCANCODE_MASK) SDL2-for-Pascal: Not translated, see comment about this macro below.

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

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.

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.

Free a set of sockets allocated by SDL_NetAllocSocketSet() *

Get the addresses of network interfaces on this system. This returns the number of addresses saved in 'addresses'

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.

The maximum channels on a a UDP socket *

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.

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.

Close a TCP network socket *

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.

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.

Close a UDP network socket *

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.

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.

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.

Unbind all addresses from the given channel *

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.8.

Add a function which is called when an event is added to the queue.

Add a new timer to the pool of timers already running.

A timer ID, or NULL when an error occurs.

Create a palette structure with the specified number of color entries.

The palette entries are initialized to white.

\param ncolors represents the number of color entries in the color palette \returns a new SDL_Palette structure on success or NULL on failure (e.g. if there wasn't enough memory); call SDL_GetError() for more information.

\since This function is available since SDL 2.0.0.

\sa SDL_FreePalette

Transparency definitions

These define alpha as the opacity of a surface.

The application did enter the background and may not get CPU for some time. * Called on iOS in applicationDidEnterBackground() * Called on Android in onPause() *

The application is low on memory, free memory if possible. * Called on iOS in applicationDidReceiveMemoryWarning() * Called on Android in onLowMemory() *

The application is about to enter the background. * Called on iOS in applicationWillResignActive() * Called on Android in onPause() *

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.8.

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.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.8.

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

Decrement an atomic variable used as a reference count and check if it reached zero after decrementing.

Get the value of a pointer atomically.

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

Set a pointer to a new value atomically, and return the old value.

Unlock a spin lock by setting it to 0.

Always returns immediately.

Audio hotplug events

Use this function to initialize a particular audio driver.

This function is used internally, and should not be used unless you have a specific need to designate the audio driver you want to use. You should normally use SDL_Init() or SDL_InitSubSystem().

\param driver_name the name of the desired audio driver \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.

\sa SDL_AudioQuit

Get the number of converted/resampled bytes available.

The stream may be buffering data behind the scenes until it has enough to resample correctly, so this number might be lower than what you expect, or even be zero. Add more data or flush the stream if you need the data now.

\since This function is available since SDL 2.0.7.

\sa SDL_NewAudioStream \sa SDL_AudioStreamPut \sa SDL_AudioStreamGet \sa SDL_AudioStreamFlush \sa SDL_AudioStreamClear \sa SDL_FreeAudioStream

Tell the stream that you're done sending data, and anything being buffered should be converted/resampled and made available immediately.

It is legal to add more data to a stream after flushing, but there will be audio gaps in the output. Generally this is intended to signal the end of input, so the complete output becomes available.

\since This function is available since SDL 2.0.7.

\sa SDL_NewAudioStream \sa SDL_AudioStreamPut \sa SDL_AudioStreamGet \sa SDL_AudioStreamAvailable \sa SDL_AudioStreamClear \sa SDL_FreeAudioStream

Add data to be converted/resampled to the stream.

\param stream The stream the audio data is being added to \param buf A pointer to the audio data to add \param len The number of bytes to write to the stream \returns 0 on success, or -1 on error.

\since This function is available since SDL 2.0.7.

\sa SDL_NewAudioStream \sa SDL_AudioStreamGet \sa SDL_AudioStreamAvailable \sa SDL_AudioStreamFlush \sa SDL_AudioStreamClear \sa SDL_FreeAudioStream

Allow change flags

Which audio format changes are allowed when opening a device.

Audio flags

< 1-srcA, 1-srcA, 1-srcA, 1-srcA *

< dstA, dstA, dstA, dstA *

< srcA, srcA, srcA, srcA *

< 1-srcR, 1-srcG, 1-srcB, 1-srcA *

< no blending dstRGBA = srcRGBA *

< additive blending dstRGB = (srcRGB * srcA) + dstRGB dstA = dstA *

< min(dst, src) : supported by D3D11 *

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

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

Initialize an SDL_AudioCVT structure for conversion.

Before an SDL_AudioCVT structure can be used to convert audio data it must be initialized with source and destination information.

This function will zero out every field of the SDL_AudioCVT, so it must be called before the application fills in the final buffer information.

Once this function has returned successfully, and reported that a conversion is necessary, the application fills in the rest of the fields in SDL_AudioCVT, now that it knows how large a buffer it needs to allocate, and then can call SDL_ConvertAudio() to complete the conversion.

\param cvt an SDL_AudioCVT structure filled in with audio conversion information \param src_format the source format of the audio data; for more info see SDL_AudioFormat \param src_channels the number of channels in the source \param src_rate the frequency (sample-frames-per-second) of the source \param dst_format the destination format of the audio data; for more info see SDL_AudioFormat \param dst_channels the number of channels in the destination \param dst_rate the frequency (sample-frames-per-second) of the destination \returns 1 if the audio filter is prepared, 0 if no conversion is needed, or a negative error code on failure; call SDL_GetError() for more information.

\since This function is available since SDL 2.0.0.

\sa SDL_ConvertAudio

This is a guess for the cacheline size used for padding. Most x86 processors have a 64 byte cache line. The 64-bit PowerPC processors have a 128 byte cache line. We'll use the larger value to be generally safe.

Allocate a block of memory that can fit an array of nmemb elements, each of given size. The memory is initialized by setting every byte to 0.

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

\since This function is available since SDL 2.0.4.

Dismiss the composition window/IME without disabling the subsystem.

\since This function is available since SDL 2.0.22.

\sa SDL_StartTextInput \sa SDL_StopTextInput

Clear all hints.

This function is automatically called during SDL_Quit(), and deletes all callbacks without calling them and frees all memory associated with hints. If you're calling this from application code you probably want to call SDL_ResetHints() instead.

This function will be removed from the API the next time we rev the ABI.

\since This function is available since SDL 2.0.0.

\sa SDL_ResetHints

Clipboard events

Use this function to shut down audio processing and close the audio device.

The application should close open audio devices once they are no longer needed. Calling this function will wait until the device's audio callback is not running, release the audio hardware and then clean up internal state. No further audio will play from this device once this function returns.

This function may block briefly while pending audio data is played by the hardware, so that applications don't drop the last buffer of data they supplied.

The device ID is invalid as soon as the device is closed, and is eligible for reuse in a new SDL_OpenAudioDevice() call immediately.

\param dev an audio device previously opened with SDL_OpenAudioDevice()

\since This function is available since SDL 2.0.0.

\sa SDL_OpenAudioDevice

This is the version number macro for the current SDL version.

\brief Create a custom blend mode, which may or may not be supported by a given renderer

\param srcColorFactor source color factor \param dstColorFactor destination color factor \param colorOperation color operation \param srcAlphaFactor source alpha factor \param dstAlphaFactor destination alpha factor \param alphaOperation alpha operation

The result of the blend mode operation will be: dstRGB = dstRGB * dstColorFactor colorOperation srcRGB * srcColorFactor and dstA = dstA * dstAlphaFactor alphaOperation srcA * srcAlphaFactor

Restart one of the 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 or a certain time has passed.

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

The mutex must be locked before calling this function.

\param cond the condition variable to wait on \param mutex the mutex used to coordinate thread access \param ms the maximum time to wait, in milliseconds, or SDL_MUTEX_MAXWAIT to wait indefinitely \returns 0 if the condition variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not signaled in the allotted time, 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 axis motion

Game controller button released

A new Game controller has been inserted into the system

The controller mapping was updated

Game controller touchpad finger was moved

< PS4/PS5 touchpad button *

< Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button *

< Xbox Elite paddle P3 *