SDL_image.cs

Blizzardo1

May 9th, 2025

277

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

C# 58.35 KB | None | 0 0

raw download clone embed print report

/// <summary>
/// Animated image support
/// </summary>
/// <remarks>
/// Currently only animated GIFs and WEBP images are supported.
/// </remarks>
typedef struct IMG_Animation { int w; /**< The width of the frames */ int h; /**< The height of the frames */ int count; /**< The number of frames */ SDL_Surface **frames; /**< An array of frames */ int *delays; /**< An array of frame delays, in milliseconds */ } IMG_Animation;
/// <summary>
/// Dispose of an IMG_Animation and free its resources.
/// </summary>
/// <param name="anim">IMG_Animationto dispose of.
/// nint refers to a IMG_Animation*
/// <remarks>
/// The providedanimpointer is not valid once this call returns.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
void IMG_FreeAnimation(IMG_Animation *anim);
/// <summary>
/// Get last SDL_image error
/// </summary>
#define IMG_GetError SDL_GetError
/// <summary>
/// Initialize SDL_image.
/// </summary>
/// </param>
/// <remarks>
/// This function loads dynamic libraries that SDL_image needs, and prepares them for use. This must be the first function you call in SDL_image, and if it fails you should not continue with the library.
/// Flags should be one or more flags fromIMG_InitFlagsOR'd together. It returns the flags successfully initialized, or 0 on failure.
/// Currently, these flags are:
/// More flags may be added in a future SDL_image release.
/// This function may need to load external shared libraries to support various codecs, which means this function can fail to initialize that support on an otherwise-reasonable system if the library isn't available; this is not just a question of exceptional circumstances like running out of memory at startup!
/// Note that you may call this function more than once to initialize with additional flags. The return value will reflect both new flags that successfully initialized, and also include flags that had previously been initialized as well.
/// As this will return previously-initialized flags, it's legal to call this with zero (no flags set). This is a safe no-op that can be used to query the current initialization state without changing it at all.
/// Since this returns previously-initialized flags as well as new ones, and you can call this with zero, you should not check for a zero return value to determine an error condition. Instead, you should check to make sure all the flags you require are set in the return value. If you have a game with data in a specific format, this might be a fatal error. If you're a generic image displaying app, perhaps you are fine with only having JPG and PNG support and can live without WEBP, even if you request support for everything.
/// Unlike other SDL satellite libraries, calls toIMG_Initdo not stack; a single call toIMG_Quit() will deinitialize everything and does not have to be paired with a matchingIMG_Initcall. For that reason, it's considered best practices to have a singleIMG_InitandIMG_Quitcall in your program. While this isn't required, be aware of the risks of deviating from that behavior.
/// After initializing SDL_image, the app may begin to load images into SDL_Surfaces or SDL_Textures.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns all currently initialized flags.</returns>
int IMG_Init( int flags);
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Please refer to IMG_InitFlags for details.
/// </summary>
/// <summary>
/// Initialization flags
/// </summary>
typedef enum IMG_InitFlags { IMG_INIT_JPG = 0x00000001 , IMG_INIT_PNG = 0x00000002 , IMG_INIT_TIF = 0x00000004 , IMG_INIT_WEBP = 0x00000008 , IMG_INIT_JXL = 0x00000010 , IMG_INIT_AVIF = 0x00000020 } IMG_InitFlags;
/// <summary>
/// Detect AVIF image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is AVIF data, zero otherwise.</returns>
int IMG_isAVIF(SDL_RWops *src);
/// <summary>
/// Detect BMP image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is BMP data, zero otherwise.</returns>
int IMG_isBMP(SDL_RWops *src);
/// <summary>
/// Detect CUR image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is CUR data, zero otherwise.</returns>
int IMG_isCUR(SDL_RWops *src);
/// <summary>
/// Detect GIF image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is GIF data, zero otherwise.</returns>
int IMG_isGIF(SDL_RWops *src);
/// <summary>
/// Detect ICO image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is ICO data, zero otherwise.</returns>
int IMG_isICO(SDL_RWops *src);
/// <summary>
/// Detect JPG image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is JPG data, zero otherwise.</returns>
int IMG_isJPG(SDL_RWops *src);
/// <summary>
/// Detect JXL image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is JXL data, zero otherwise.</returns>
int IMG_isJXL(SDL_RWops *src);
/// <summary>
/// Detect LBM image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is LBM data, zero otherwise.</returns>
int IMG_isLBM(SDL_RWops *src);
/// <summary>
/// Detect PCX image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is PCX data, zero otherwise.</returns>
int IMG_isPCX(SDL_RWops *src);
/// <summary>
/// Detect PNG image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is PNG data, zero otherwise.</returns>
int IMG_isPNG(SDL_RWops *src);
/// <summary>
/// Detect PNM image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is PNM data, zero otherwise.</returns>
int IMG_isPNM(SDL_RWops *src);
/// <summary>
/// Detect QOI image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is QOI data, zero otherwise.</returns>
int IMG_isQOI(SDL_RWops *src);
/// <summary>
/// Detect SVG image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.2.
/// </remarks>
/// <returns>(int) Returns non-zero if this is SVG data, zero otherwise.</returns>
int IMG_isSVG(SDL_RWops *src);
/// <summary>
/// Detect TIFF image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is TIFF data, zero otherwise.</returns>
int IMG_isTIF(SDL_RWops *src);
/// <summary>
/// Detect WEBP image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is WEBP data, zero otherwise.</returns>
int IMG_isWEBP(SDL_RWops *src);
/// <summary>
/// Detect XCF image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is XCF data, zero otherwise.</returns>
int IMG_isXCF(SDL_RWops *src);
/// <summary>
/// Detect XPM image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is XPM data, zero otherwise.</returns>
int IMG_isXPM(SDL_RWops *src);
/// <summary>
/// Detect XV image data on a readable/seekable SDL_RWops.
/// </summary>
/// <param name="src">a seekable/readable SDL_RWops to provide image data.
/// nint refers to a SDL_RWops *
/// <remarks>
/// This function attempts to determine if a file is a given filetype, reading the least amount possible from the SDL_RWops (usually a few bytes).
/// There is no distinction made between "not the filetype in question" and basic i/o errors.
/// This function will always attempt to seek the RWops back to where it started when this function was called, but it will not report any errors in doing so, but assuming seeking works, this means you can immediately use this with a differentIMG_isTYPEfunction, or load the image without further seeking.
/// You do not need to call this function to load data; SDL_image can work to determine file type in many cases in its standard load functions.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns non-zero if this is XV data, zero otherwise.</returns>
int IMG_isXV(SDL_RWops *src);
/// <summary>
/// This function gets the version of the dynamically linked SDL_image library.
/// </summary>
/// <remarks>
/// it should NOT be used to fill a version structure, instead you should use the SDL_IMAGE_VERSION() macro.
/// </remarks>
/// <returns>(const SDL_version *) Returns SDL_image version.</returns>
const SDL_version * IMG_Linked_Version( void );
/// <summary>
/// Load an image from a filesystem path into a software surface.
/// </summary>
/// <param name="file">a path on the filesystem to load an image from.
/// nint refers to a const char *
/// <remarks>
/// An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use this if you plan to hand the data to something else or manipulate it further in code.
/// There are no guarantees about what format the new SDL_Surface data will be; in many cases, SDL_image will attempt to supply a surface that exactly matches the provided image, but in others it might have to convert (either because the image is in a format that SDL doesn't directly support or because it's compressed data that could reasonably uncompress to various formats and SDL_image had to pick one). You can inspect an SDL_Surface for its specifics, and use SDL_ConvertSurface to then migrate to any supported format.
/// 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);
/// There is a separate function to read files from an SDL_RWops, if you need an i/o abstraction to provide data from anywhere instead of a simple filesystem read; that function isIMG_Load_RW().
/// If you are using SDL's 2D rendering API, there is an equivalent call to load images directly into an SDL_Texture for use by the GPU without using a software surface: callIMG_LoadTexture() instead.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_Load( const char *file);
/// <summary>
/// Load an image from an SDL data source into a software surface.
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <remarks>
/// An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use this if you plan to hand the data to something else or manipulate it further in code.
/// There are no guarantees about what format the new SDL_Surface data will be; in many cases, SDL_image will attempt to supply a surface that exactly matches the provided image, but in others it might have to convert (either because the image is in a format that SDL doesn't directly support or because it's compressed data that could reasonably uncompress to various formats and SDL_image had to pick one). You can inspect an SDL_Surface for its specifics, and use SDL_ConvertSurface to then migrate to any supported format.
/// 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);
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// There is a separate function to read files from disk without having to deal with SDL_RWops:IMG_Load("filename.jpg")will call this function and manage those details for you, determining the file type from the filename's extension.
/// There is alsoIMG_LoadTyped_RW(), which is equivalent to this function except a file extension (like "BMP", "JPG", etc) can be specified, in case SDL_image cannot autodetect the file format.
/// If you are using SDL's 2D rendering API, there is an equivalent call to load images directly into an SDL_Texture for use by the GPU without using a software surface: callIMG_LoadTexture_RW() instead.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_Load_RW(SDL_RWops *src, int freesrc);
/// <summary>
/// Load an animation from a file.
/// </summary>
/// <param name="file">path on the filesystem containing an animated image.
/// nint refers to a const char *
/// <remarks>
/// When done with the returned animation, the app should dispose of it with a call toIMG_FreeAnimation().
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(IMG_Animation *) Returns a new IMG_Animation, or NULL on error.</returns>
IMG_Animation * IMG_LoadAnimation( const char *file);
/// <summary>
/// Load an animation from an SDL_RWops.
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <remarks>
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// When done with the returned animation, the app should dispose of it with a call toIMG_FreeAnimation().
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(IMG_Animation *) Returns a new IMG_Animation, or NULL on error.</returns>
IMG_Animation * IMG_LoadAnimation_RW(SDL_RWops *src, int freesrc);
/// <summary>
/// Load an animation from an SDL datasource
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <param name="type">a filename extension that represent this data ("GIF", etc).
/// nint refers to a const char *
/// <remarks>
/// Even though this function accepts a file type, SDL_image may still try other decoders that are capable of detecting file type from the contents of the image data, but may rely on the caller-provided type string for formats that it cannot autodetect. Iftypeis NULL, SDL_image will rely solely on its ability to guess the format.
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// When done with the returned animation, the app should dispose of it with a call toIMG_FreeAnimation().
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(IMG_Animation *) Returns a new IMG_Animation, or NULL on error.</returns>
IMG_Animation * IMG_LoadAnimationTyped_RW(SDL_RWops *src, int freesrc, const char *type);
/// <summary>
/// Load a AVIF image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a AVIF image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadAVIF_RW(SDL_RWops *src);
/// <summary>
/// Load a BMP image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a BMP image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadBMP_RW(SDL_RWops *src);
/// <summary>
/// Load a CUR image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a CUR image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadCUR_RW(SDL_RWops *src);
/// <summary>
/// Load a GIF image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a GIF image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadGIF_RW(SDL_RWops *src);
/// <summary>
/// Load a GIF animation directly.
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a GIF image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(IMG_Animation *) Returns a new IMG_Animation, or NULL on error.</returns>
IMG_Animation * IMG_LoadGIFAnimation_RW(SDL_RWops *src);
/// <summary>
/// Load a ICO image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a ICO image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadICO_RW(SDL_RWops *src);
/// <summary>
/// Load a JPG image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a JPG image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadJPG_RW(SDL_RWops *src);
/// <summary>
/// Load a JXL image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a JXL image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadJXL_RW(SDL_RWops *src);
/// <summary>
/// Load a LBM image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a LBM image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadLBM_RW(SDL_RWops *src);
/// <summary>
/// Load a PCX image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a PCX image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadPCX_RW(SDL_RWops *src);
/// <summary>
/// Load a PNG image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a PNG image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadPNG_RW(SDL_RWops *src);
/// <summary>
/// Load a PNM image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a PNM image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadPNM_RW(SDL_RWops *src);
/// <summary>
/// Load a QOI image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a QOI image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadQOI_RW(SDL_RWops *src);
/// <summary>
/// Load an SVG image, scaled to a specific size.
/// </summary>
/// <param name="src">an SDL_RWops to load SVG data from.
/// nint refers to a SDL_RWops *
/// </param>
/// </param>
/// <remarks>
/// Since SVG files are resolution-independent, you specify the size you would like the output image to be and it will be generated at those dimensions.
/// Either width or height may be 0 and the image will be auto-sized to preserve aspect ratio.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadSizedSVG_RW(SDL_RWops *src, int width, int height);
/// <summary>
/// Load a SVG image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a SVG image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.2.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadSVG_RW(SDL_RWops *src);
/// <summary>
/// Load an image from a filesystem path into a GPU texture.
/// </summary>
/// <param name="renderer">the SDL_Renderer to use to create the GPU texture.
/// nint refers to a SDL_Renderer *
/// <param name="file">a path on the filesystem to load an image from.
/// nint refers to a const char *
/// <remarks>
/// An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render API. This can be significantly more efficient than using a CPU-bound SDL_Surface if you don't need to manipulate the image directly after loading it.
/// If the loaded image has transparency or a colorkey, a texture with an alpha channel will be created. Otherwise, SDL_image will attempt to create an SDL_Texture in the most format that most reasonably represents the image data (but in many cases, this will just end up being 32-bit RGB or 32-bit RGBA).
/// There is a separate function to read files from an SDL_RWops, if you need an i/o abstraction to provide data from anywhere instead of a simple filesystem read; that function isIMG_LoadTexture_RW().
/// If you would rather decode an image to an SDL_Surface (a buffer of pixels in CPU memory), callIMG_Load() instead.
/// When done with the returned texture, the app should dispose of it with a call to SDL_DestroyTexture().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Texture *) Returns a new texture, or NULL on error.</returns>
SDL_Texture * IMG_LoadTexture(SDL_Renderer *renderer, const char *file);
/// <summary>
/// Load an image from an SDL data source into a GPU texture.
/// </summary>
/// <param name="renderer">the SDL_Renderer to use to create the GPU texture.
/// nint refers to a SDL_Renderer *
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <remarks>
/// An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render API. This can be significantly more efficient than using a CPU-bound SDL_Surface if you don't need to manipulate the image directly after loading it.
/// If the loaded image has transparency or a colorkey, a texture with an alpha channel will be created. Otherwise, SDL_image will attempt to create an SDL_Texture in the most format that most reasonably represents the image data (but in many cases, this will just end up being 32-bit RGB or 32-bit RGBA).
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// There is a separate function to read files from disk without having to deal with SDL_RWops:IMG_LoadTexture(renderer, "filename.jpg")will call this function and manage those details for you, determining the file type from the filename's extension.
/// There is alsoIMG_LoadTextureTyped_RW(), which is equivalent to this function except a file extension (like "BMP", "JPG", etc) can be specified, in case SDL_image cannot autodetect the file format.
/// If you would rather decode an image to an SDL_Surface (a buffer of pixels in CPU memory), callIMG_Load() instead.
/// When done with the returned texture, the app should dispose of it with a call to SDL_DestroyTexture().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Texture *) Returns a new texture, or NULL on error.</returns>
SDL_Texture * IMG_LoadTexture_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc);
/// <summary>
/// Load an image from an SDL data source into a GPU texture.
/// </summary>
/// <param name="renderer">the SDL_Renderer to use to create the GPU texture.
/// nint refers to a SDL_Renderer *
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <param name="type">a filename extension that represent this data ("BMP", "GIF", "PNG", etc).
/// nint refers to a const char *
/// <remarks>
/// An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render API. This can be significantly more efficient than using a CPU-bound SDL_Surface if you don't need to manipulate the image directly after loading it.
/// If the loaded image has transparency or a colorkey, a texture with an alpha channel will be created. Otherwise, SDL_image will attempt to create an SDL_Texture in the most format that most reasonably represents the image data (but in many cases, this will just end up being 32-bit RGB or 32-bit RGBA).
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// Even though this function accepts a file type, SDL_image may still try other decoders that are capable of detecting file type from the contents of the image data, but may rely on the caller-provided type string for formats that it cannot autodetect. Iftypeis NULL, SDL_image will rely solely on its ability to guess the format.
/// There is a separate function to read files from disk without having to deal with SDL_RWops:IMG_LoadTexture("filename.jpg")will call this function and manage those details for you, determining the file type from the filename's extension.
/// There is alsoIMG_LoadTexture_RW(), which is equivalent to this function except that it will rely on SDL_image to determine what type of data it is loading, much like passing a NULL for type.
/// If you would rather decode an image to an SDL_Surface (a buffer of pixels in CPU memory), callIMG_LoadTyped_RW() instead.
/// When done with the returned texture, the app should dispose of it with a call to SDL_DestroyTexture().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Texture *) Returns a new texture, or NULL on error.</returns>
SDL_Texture * IMG_LoadTextureTyped_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc, const char *type);
/// <summary>
/// Load a TGA image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a TGA image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadTGA_RW(SDL_RWops *src);
/// <summary>
/// Load a TIFF image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a TIFF image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadTIF_RW(SDL_RWops *src);
/// <summary>
/// Load an image from an SDL data source into a software surface.
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// </param>
/// <param name="type">a filename extension that represent this data ("BMP", "GIF", "PNG", etc).
/// nint refers to a const char *
/// <remarks>
/// An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use this if you plan to hand the data to something else or manipulate it further in code.
/// There are no guarantees about what format the new SDL_Surface data will be; in many cases, SDL_image will attempt to supply a surface that exactly matches the provided image, but in others it might have to convert (either because the image is in a format that SDL doesn't directly support or because it's compressed data that could reasonably uncompress to various formats and SDL_image had to pick one). You can inspect an SDL_Surface for its specifics, and use SDL_ConvertSurface to then migrate to any supported format.
/// 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);
/// Iffreesrcis non-zero, the RWops will be closed before returning, whether this function succeeds or not. SDL_image reads everything it needs from the RWops during this call in any case.
/// Even though this function accepts a file type, SDL_image may still try other decoders that are capable of detecting file type from the contents of the image data, but may rely on the caller-provided type string for formats that it cannot autodetect. Iftypeis NULL, SDL_image will rely solely on its ability to guess the format.
/// There is a separate function to read files from disk without having to deal with SDL_RWops:IMG_Load("filename.jpg")will call this function and manage those details for you, determining the file type from the filename's extension.
/// There is alsoIMG_Load_RW(), which is equivalent to this function except that it will rely on SDL_image to determine what type of data it is loading, much like passing a NULL for type.
/// If you are using SDL's 2D rendering API, there is an equivalent call to load images directly into an SDL_Texture for use by the GPU without using a software surface: callIMG_LoadTextureTyped_RW() instead.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, const char *type);
/// <summary>
/// Load a WEBP image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a WEBP image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadWEBP_RW(SDL_RWops *src);
/// <summary>
/// Load a WEBP animation directly.
/// </summary>
/// <param name="src">an SDL_RWops that data will be read from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a WEBP image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(IMG_Animation *) Returns a new IMG_Animation, or NULL on error.</returns>
IMG_Animation * IMG_LoadWEBPAnimation_RW(SDL_RWops *src);
/// <summary>
/// Load a XCF image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a XCF image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadXCF_RW(SDL_RWops *src);
/// <summary>
/// Load a XPM image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a XPM image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadXPM_RW(SDL_RWops *src);
/// <summary>
/// Load a XV image directly.
/// </summary>
/// <param name="src">an SDL_RWops to load image data from.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you know you definitely have a XV image, you can call this function, which will skip SDL_image's file format detection routines. Generally it's better to use the abstract interfaces; also, there is only an SDL_RWops interface available here.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_LoadXV_RW(SDL_RWops *src);
/// <summary>
/// Deinitialize SDL_image.
/// </summary>
/// <remarks>
/// This should be the last function you call in SDL_image, after freeing all other resources. This will unload any shared libraries it is using for various codecs.
/// After this call, a call toIMG_Init(0) will return 0 (no codecs loaded).
/// You can safely callIMG_Init() to reload various codec support after this call.
/// Unlike other SDL satellite libraries, calls toIMG_Initdo not stack; a single call toIMG_Quit() will deinitialize everything and does not have to be paired with a matchingIMG_Initcall. For that reason, it's considered best practices to have a singleIMG_InitandIMG_Quitcall in your program. While this isn't required, be aware of the risks of deviating from that behavior.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
void IMG_Quit( void );
/// <summary>
/// Load an XPM image from a memory array.
/// </summary>
/// <param name="xpm">a null-terminated array of strings that comprise XPM data.
/// nint refers to a char **
/// <remarks>
/// The returned surface will be an 8bpp indexed surface, if possible, otherwise it will be 32bpp. If you always want 32-bit data, useIMG_ReadXPMFromArrayToRGB888() instead.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_ReadXPMFromArray( char **xpm);
/// <summary>
/// Load an XPM image from a memory array.
/// </summary>
/// <param name="xpm">a null-terminated array of strings that comprise XPM data.
/// nint refers to a char **
/// <remarks>
/// The returned surface will always be a 32-bit RGB surface. If you want 8-bit indexed colors (and the XPM data allows it), useIMG_ReadXPMFromArray() instead.
/// When done with the returned surface, the app should dispose of it with a call to SDL_FreeSurface().
/// This function is available since SDL_image 2.6.0.
/// </remarks>
/// <returns>(SDL_Surface *) Returns a new SDL surface, or NULL on error.</returns>
SDL_Surface * IMG_ReadXPMFromArrayToRGB888( char **xpm);
/// <summary>
/// Save an SDL_Surface into a JPEG image file.
/// </summary>
/// <param name="surface">the SDL surface to save.
/// nint refers to a SDL_Surface *
/// <param name="file">path on the filesystem to write new file to.
/// nint refers to a const char *
/// </param>
/// <remarks>
/// If the file already exists, it will be overwritten.
/// This function is available since SDL_image 2.0.2.
/// </remarks>
/// <returns>(int) Returns 0 if successful, -1 on error.</returns>
int IMG_SaveJPG(SDL_Surface *surface, const char *file, int quality);
/// <summary>
/// Save an SDL_Surface into JPEG image data, via an SDL_RWops.
/// </summary>
/// <param name="surface">the SDL surface to save.
/// nint refers to a SDL_Surface *
/// <param name="dst">the SDL_RWops to save the image data to.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you just want to save to a filename, you can useIMG_SaveJPG() instead.
/// This function is available since SDL_image 2.0.2.
/// </remarks>
/// <returns>(int) Returns 0 if successful, -1 on error.</returns>
int IMG_SaveJPG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst, int quality);
/// <summary>
/// Save an SDL_Surface into a PNG image file.
/// </summary>
/// <param name="surface">the SDL surface to save.
/// nint refers to a SDL_Surface *
/// <param name="file">path on the filesystem to write new file to.
/// nint refers to a const char *
/// <remarks>
/// If the file already exists, it will be overwritten.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns 0 if successful, -1 on error.</returns>
int IMG_SavePNG(SDL_Surface *surface, const char *file);
/// <summary>
/// Save an SDL_Surface into PNG image data, via an SDL_RWops.
/// </summary>
/// <param name="surface">the SDL surface to save.
/// nint refers to a SDL_Surface *
/// <param name="dst">the SDL_RWops to save the image data to.
/// nint refers to a SDL_RWops *
/// <remarks>
/// If you just want to save to a filename, you can useIMG_SavePNG() instead.
/// This function is available since SDL_image 2.0.0.
/// </remarks>
/// <returns>(int) Returns 0 if successful, -1 on error.</returns>
int IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst);
/// <summary>
/// Report SDL_image errors
/// </summary>
#define IMG_SetError SDL_SetError
/// <summary>
/// This is the version number macro for the current SDL_image version.
/// </summary>
/// <remarks>
/// In versions higher than 2.9.0, the minor version overflows into the thousands digit: for example, 2.23.0 is encoded as 4300. This macro will not be available in SDL 3.x or SDL_image 3.x.
/// Deprecated, use SDL_IMAGE_VERSION_ATLEAST or SDL_IMAGE_VERSION instead.
/// </remarks>
#define SDL_IMAGE_COMPILEDVERSION \ SDL_VERSIONNUM(SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_PATCHLEVEL)
/// <summary>
/// Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
/// </summary>
#define SDL_IMAGE_MAJOR_VERSION 2
/// <summary>
/// This macro can be used to fill a version structure with the compile-time version of the SDL_image library.
/// </summary>
#define SDL_IMAGE_VERSION(X) \ { \ (X)->major = SDL_IMAGE_MAJOR_VERSION; \ (X)->minor = SDL_IMAGE_MINOR_VERSION; \ (X)->patch = SDL_IMAGE_PATCHLEVEL; \ }
/// <summary>
/// This macro will evaluate to true if compiled with SDL_image at least X.Y.Z.
/// </summary>
#define SDL_IMAGE_VERSION_ATLEAST(X, Y, Z) \ ((SDL_IMAGE_MAJOR_VERSION >= X) && \ (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION >= Y) && \ (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION > Y || SDL_IMAGE_PATCHLEVEL >= Z))

Tags: sdl2

Add Comment

Please, Sign In to add comment