actual version
[sdl-headers.git] / sdlrenderer.inc
1 //from "sdl_renderer.h"
2
3   {**
4    *  Flags used when creating a rendering context
5    *}
6 const
7   SDL_RENDERER_SOFTWARE = $00000001;          {**< The renderer is a software fallback *}
8   SDL_RENDERER_ACCELERATED = $00000002;       {**< The renderer uses hardware
9                                                    acceleration *}
10   SDL_RENDERER_PRESENTVSYNC = $00000004;      {**< Present is synchronized
11                                                    with the refresh rate *}
12   SDL_RENDERER_TARGETTEXTURE = $00000008;     {**< The renderer supports
13                                                    rendering to texture *}
14
15 type
16   PSDL_RendererFlags = ^TSDL_RendererFlags;
17   TSDL_RendererFlags = Word;
18
19   {**
20    *  Information on the capabilities of a render driver or context.
21    *}
22   PSDL_RendererInfo = ^TSDL_RendererInfo;
23   TSDL_RendererInfo = record  
24     name: PAnsiChar;                         {**< The name of the renderer *}
25     flags: UInt32;                           {**< Supported ::SDL_RendererFlags *}
26     num_texture_formats: UInt32;             {**< The number of available texture formats *}
27     texture_formats: array[0..15] of UInt32; {**< The available texture formats *}
28     max_texture_width: SInt32;               {**< The maximimum texture width *}
29     max_texture_height: SInt32;              {**< The maximimum texture height *}
30   end;
31
32   {**
33    *  The access pattern allowed for a texture.
34    *}
35 type
36   PSDL_TextureAccess = ^TSDL_TextureAccess;
37   TSDL_TextureAccess = (
38                         SDL_TEXTUREACCESS_STATIC,    {**< Changes rarely, not lockable *}
39                         SDL_TEXTUREACCESS_STREAMING, {**< Changes frequently, lockable *}
40                         SDL_TEXTUREACCESS_TARGET     {**< Texture can be used as a render target *}
41                         );
42
43   {**
44    *  The texture channel modulation used in SDL_RenderCopy().
45    *}
46   PSDL_TextureModulate = ^TSDL_TextureModulate;
47   TSDL_TextureModulate = (
48                           SDL_TEXTUREMODULATE_NONE,     {**< No modulation *}
49                           SDL_TEXTUREMODULATE_COLOR,    {**< srcC = srcC * color *}
50                           SDL_TEXTUREMODULATE_ALPHA     {**< srcA = srcA * alpha *}
51                           );
52
53   {**
54    *  Flip constants for SDL_RenderCopyEx
55    *}
56 type
57   PSDL_RendererFlip = ^TSDL_RendererFlip;
58   TSDL_RendererFlip = (SDL_FLIP_NONE,       {**< Do not flip *}
59                        SDL_FLIP_HORIZONTAL, {**< flip horizontally *}
60                        SDL_FLIP_VERTICAL    {**< flip vertically *}
61                        );
62
63   {**
64    *  A structure representing rendering state
65    *}
66
67   PPSDL_Renderer = ^PSDL_Renderer;
68   PSDL_Renderer = Pointer; //todo!
69
70   {**
71    *  An efficient driver-specific representation of pixel data
72    *}
73   PSDL_Texture = Pointer; //todo!
74
75   {* Function prototypes *}
76
77   {**
78    *  Get the number of 2D rendering drivers available for the current
79    *  display.
80    *
81    *  A render driver is a set of code that handles rendering and texture
82    *  management on a particular display.  Normally there is only one, but
83    *  some drivers may have several available with different capabilities.
84    *
85    *   SDL_GetRenderDriverInfo()
86    *   SDL_CreateRenderer()
87    *}
88 function SDL_GetNumRenderDrivers: SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetNumRenderDrivers' {$ENDIF} {$ENDIF};
89
90   {**
91    *  Get information about a specific 2D rendering driver for the current
92    *  display.
93    *
94    *   index The index of the driver to query information about.
95    *   info  A pointer to an SDL_RendererInfo struct to be filled with
96    *               information on the rendering driver.
97    *
98    *   0 on success, -1 if the index was out of range.
99    *
100    *   SDL_CreateRenderer()
101    *}
102 function SDL_GetRenderDriverInfo(index: SInt32; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDriverInfo' {$ENDIF} {$ENDIF};
103
104   {**
105    *  Create a window and default renderer
106    *
107    *   width    The width of the window
108    *   height   The height of the window
109    *   window_flags The flags used to create the window
110    *   window   A pointer filled with the window, or NULL on error
111    *   renderer A pointer filled with the renderer, or NULL on error
112    *
113    *   0 on success, or -1 on error
114    *}
115 function SDL_CreateWindowAndRenderer(width: SInt32; height: SInt32; window_flags: UInt32; window: PPSDL_Window; renderer: PPSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateWindowAndRenderer' {$ENDIF} {$ENDIF};
116
117   {**
118    *  Create a 2D rendering context for a window.
119    *
120    *   window The window where rendering is displayed.
121    *   index    The index of the rendering driver to initialize, or -1 to
122    *                  initialize the first one supporting the requested flags.
123    *   flags    ::SDL_RendererFlags.
124    *
125    *   A valid rendering context or NULL if there was an error.
126    *
127    *   SDL_CreateSoftwareRenderer()
128    *   SDL_GetRendererInfo()
129    *   SDL_DestroyRenderer()
130    *}
131 function SDL_CreateRenderer(window: PSDL_Window; index: SInt32; flags: UInt32): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateRenderer' {$ENDIF} {$ENDIF};
132
133   {**
134    *  Create a 2D software rendering context for a surface.
135    *
136    *   surface The surface where rendering is done.
137    *
138    *   A valid rendering context or NULL if there was an error.
139    *
140    *   SDL_CreateRenderer()
141    *   SDL_DestroyRenderer()
142    *}
143 function SDL_CreateSoftwareRenderer(surface: PSDL_Surface): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateSoftwareRenderer' {$ENDIF} {$ENDIF};
144
145   {**
146    *  Get the renderer associated with a window.
147    *}
148 function SDL_GetRenderer(window: PSDL_Window): PSDL_Renderer cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderer' {$ENDIF} {$ENDIF};
149
150   {**
151    *  Get information about a rendering context.
152    *}
153 function SDL_GetRendererInfo(renderer: PSDL_Renderer; info: PSDL_RendererInfo): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererInfo' {$ENDIF} {$ENDIF};
154
155   {**
156    *  Get the output size of a rendering context.
157    *}
158 function SDL_GetRendererOutputSize(renderer: PSDL_Renderer; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRendererOutputSize' {$ENDIF} {$ENDIF};
159
160   {**
161    *  Create a texture for a rendering context.
162    *
163    *   renderer The renderer.
164    *   format The format of the texture.
165    *   access One of the enumerated values in ::SDL_TextureAccess.
166    *   w      The width of the texture in pixels.
167    *   h      The height of the texture in pixels.
168    *
169    *   The created texture is returned, or 0 if no rendering context was
170    *   active,  the format was unsupported, or the width or height were out
171    *   of range.
172    *
173    *  SDL_QueryTexture()
174    *  SDL_UpdateTexture()
175    *  SDL_DestroyTexture()
176    *}
177 function SDL_CreateTexture(renderer: PSDL_Renderer; format: UInt32; access: SInt32; w: SInt32; h: SInt32): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTexture' {$ENDIF} {$ENDIF};
178
179   {**
180    *  Create a texture from an existing surface.
181    *
182    *   renderer The renderer.
183    *   surface The surface containing pixel data used to fill the texture.
184    *
185    *   The created texture is returned, or 0 on error.
186    *
187    *   The surface is not modified or freed by this function.
188    *
189    *   SDL_QueryTexture()
190    *   SDL_DestroyTexture()
191    *}
192 function SDL_CreateTextureFromSurface(renderer: PSDL_Renderer; surface: PSDL_Surface): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_CreateTextureFromSurface' {$ENDIF} {$ENDIF};
193
194   {**
195    *  Query the attributes of a texture
196    *
197    *   texture A texture to be queried.
198    *   format  A pointer filled in with the raw format of the texture.  The
199    *           actual format may differ, but pixel transfers will use this
200    *           format.
201    *   access  A pointer filled in with the actual access to the texture.
202    *   w       A pointer filled in with the width of the texture in pixels.
203    *   h       A pointer filled in with the height of the texture in pixels.
204    *
205    *   0 on success, or -1 if the texture is not valid.
206    *}
207 function SDL_QueryTexture(texture: PSDL_Texture; format: PUInt32; access: PInt; w: PInt; h: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_QueryTexture' {$ENDIF} {$ENDIF};
208
209   {**
210    *  Set an additional color value used in render copy operations.
211    *
212    *   texture The texture to update.
213    *   r       The red color value multiplied into copy operations.
214    *   g       The green color value multiplied into copy operations.
215    *   b       The blue color value multiplied into copy operations.
216    *
217    *   0 on success, or -1 if the texture is not valid or color modulation
218    *   is not supported.
219    *
220    *   SDL_GetTextureColorMod()
221    *}
222 function SDL_SetTextureColorMod(texture: PSDL_Texture; r: UInt8; g: UInt8; b: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureColorMod' {$ENDIF} {$ENDIF};
223
224   {**
225    *  Get the additional color value used in render copy operations.
226    *
227    *   texture The texture to query.
228    *   r         A pointer filled in with the current red color value.
229    *   g         A pointer filled in with the current green color value.
230    *   b         A pointer filled in with the current blue color value.
231    *
232    *   0 on success, or -1 if the texture is not valid.
233    *
234    *   SDL_SetTextureColorMod()
235    *}
236 function SDL_GetTextureColorMod(texture: PSDL_Texture; r: PUInt8; g: PUInt8; b: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureColorMod' {$ENDIF} {$ENDIF};
237
238   {**
239    *  Set an additional alpha value used in render copy operations.
240    *
241    *   texture The texture to update.
242    *   alpha     The alpha value multiplied into copy operations.
243    *
244    *   0 on success, or -1 if the texture is not valid or alpha modulation
245    *   is not supported.
246    *
247    *   SDL_GetTextureAlphaMod()
248    *}
249 function SDL_SetTextureAlphaMod(texture: PSDL_Texture; alpha: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureAlphaMod' {$ENDIF} {$ENDIF};
250
251   {**
252    *  Get the additional alpha value used in render copy operations.
253    *
254    *   texture The texture to query.
255    *   alpha     A pointer filled in with the current alpha value.
256    *
257    *   0 on success, or -1 if the texture is not valid.
258    *
259    *   SDL_SetTextureAlphaMod()
260    *}
261 function SDL_GetTextureAlphaMod(texture: PSDL_Texture; alpha: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureAlphaMod' {$ENDIF} {$ENDIF};
262
263   {**
264    *   Set the blend mode used for texture copy operations.
265    *
266    *   texture The texture to update.
267    *   blendMode ::SDL_BlendMode to use for texture blending.
268    *
269    *   0 on success, or -1 if the texture is not valid or the blend mode is
270    *   not supported.
271    *
272    *   If the blend mode is not supported, the closest supported mode is
273    *   chosen.
274    *
275    *   SDL_GetTextureBlendMode()
276    *}
277 function SDL_SetTextureBlendMode(texture: PSDL_Texture; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetTextureBlendMode' {$ENDIF} {$ENDIF};
278
279   {**
280    *  Get the blend mode used for texture copy operations.
281    *
282    *   texture   The texture to query.
283    *   blendMode A pointer filled in with the current blend mode.
284    *
285    *   0 on success, or -1 if the texture is not valid.
286    *
287    *   SDL_SetTextureBlendMode()
288    *}
289 function SDL_GetTextureBlendMode(texture: PSDL_Texture; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetTextureBlendMode' {$ENDIF} {$ENDIF};
290
291   {**
292    *  Update the given texture rectangle with new pixel data.
293    *
294    *   texture   The texture to update
295    *   rect      A pointer to the rectangle of pixels to update, or NULL to
296    *                   update the entire texture.
297    *   pixels    The raw pixel data.
298    *   pitch     The number of bytes between rows of pixel data.
299    *
300    *   0 on success, or -1 if the texture is not valid.
301    *
302    *   This is a fairly slow function.
303    *}
304 function SDL_UpdateTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_UpdateTexture' {$ENDIF} {$ENDIF};
305
306   {**
307    *  Lock a portion of the texture for write-only pixel access.
308    *
309    *   texture   The texture to lock for access, which was created with
310    *             SDL_TEXTUREACCESS_STREAMING.
311    *   rect      A pointer to the rectangle to lock for access. If the rect
312    *             is NULL, the entire texture will be locked.
313    *   pixels    This is filled in with a pointer to the locked pixels,
314    *             appropriately offset by the locked area.
315    *   pitch     This is filled in with the pitch of the locked pixels.
316    *
317    *   0 on success, or -1 if the texture is not valid or was not created with ::SDL_TEXTUREACCESS_STREAMING.
318    *
319    *   SDL_UnlockTexture()
320    *}
321 function SDL_LockTexture(texture: PSDL_Texture; rect: PSDL_Rect; pixels: PPointer; pitch: PInt): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
322
323   {**
324    *  Unlock a texture, uploading the changes to video memory, if needed.
325    *
326    *   SDL_LockTexture()
327    *}
328 procedure SDL_UnlockTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_LockTexture' {$ENDIF} {$ENDIF};
329
330   {**
331    *  Determines whether a window supports the use of render targets
332    *
333    *  renderer The renderer that will be checked
334    *
335    *  SDL_TRUE if supported, SDL_FALSE if not.
336    *}
337 function SDL_RenderTargetSupported(renderer: PSDL_Renderer): Boolean cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderTargetSupported' {$ENDIF} {$ENDIF};
338
339   {**
340    *  Set a texture as the current rendering target.
341    *
342    *  renderer The renderer.
343    *  texture The targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL for the default render target
344    *
345    *  0 on success, or -1 on error
346    *
347    *   SDL_GetRenderTarget()
348    *}
349 function SDL_SetRenderTarget(renderer: PSDL_Renderer; texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderTarget' {$ENDIF} {$ENDIF};
350
351   {**
352    *  Get the current render target or NULL for the default render target.
353    *
354    *  The current render target
355    *
356    *   SDL_SetRenderTarget()
357    *}
358 function SDL_GetRenderTarget(renderer: PSDL_Renderer): PSDL_Texture cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderTarget' {$ENDIF} {$ENDIF};
359
360   {**
361    *  Set device independent resolution for rendering
362    *
363    *   renderer The renderer for which resolution should be set.
364    *   w      The width of the logical resolution
365    *   h      The height of the logical resolution
366    *
367    *  This function uses the viewport and scaling functionality to allow a fixed logical
368    *  resolution for rendering, regardless of the actual output resolution.  If the actual
369    *  output resolution doesn't have the same aspect ratio the output rendering will be
370    *  centered within the output display.
371    *
372    *  If the output display is a window, mouse events in the window will be filtered
373    *  and scaled so they seem to arrive within the logical resolution.
374    *
375    *   If this function results in scaling or subpixel drawing by the
376    *   rendering backend, it will be handled using the appropriate
377    *   quality hints.
378    *
379    *   SDL_RenderGetLogicalSize()
380    *   SDL_RenderSetScale()
381    *   SDL_RenderSetViewport()
382    *}
383 function SDL_RenderSetLogicalSize(renderer: PSDL_Renderer; w: SInt32; h: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetLogicalSize' {$ENDIF} {$ENDIF};
384
385   {**
386    *  Get device independent resolution for rendering
387    *
388    *   renderer The renderer from which resolution should be queried.
389    *   w      A pointer filled with the width of the logical resolution
390    *   h      A pointer filled with the height of the logical resolution
391    *
392    *   SDL_RenderSetLogicalSize()
393    *}
394 procedure SDL_RenderGetLogicalSize(renderer: PSDL_Renderer; w: PInt; h: PInt) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetLogicalSize' {$ENDIF} {$ENDIF};
395
396   {**
397    *  Set the drawing area for rendering on the current target.
398    *
399    *   renderer The renderer for which the drawing area should be set.
400    *   rect The rectangle representing the drawing area, or NULL to set the viewport to the entire target.
401    *
402    *  The x,y of the viewport rect represents the origin for rendering.
403    *
404    *   0 on success, or -1 on error
405    *
406    *  If the window associated with the renderer is resized, the viewport is automatically reset.
407    *
408    *   SDL_RenderGetViewport()
409    *   SDL_RenderSetLogicalSize()
410    *}
411 function SDL_RenderSetViewport(renderer: PSDL_Renderer; const rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetViewport' {$ENDIF} {$ENDIF};
412
413   {**
414    *  Get the drawing area for the current target.
415    *
416    *   SDL_RenderSetViewport()
417    *}
418 procedure SDL_RenderGetViewport(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetViewport' {$ENDIF} {$ENDIF};
419
420   {**
421    *  Set the clip rectangle for the current target.
422    *
423    *   renderer The renderer for which clip rectangle should be set.
424    *   rect   A pointer to the rectangle to set as the clip rectangle, or
425    *          NULL to disable clipping.
426    *
427    *   0 on success, or -1 on error
428    *
429    *   SDL_RenderGetClipRect()
430    *}
431 function SDL_RenderSetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetClipRect' {$ENDIF} {$ENDIF};
432
433   {**
434    *  Get the clip rectangle for the current target.
435    *
436    *   renderer The renderer from which clip rectangle should be queried.
437    *   rect   A pointer filled in with the current clip rectangle, or
438    *          an empty rectangle if clipping is disabled.
439    *
440    *   SDL_RenderSetClipRect()
441    *}
442 procedure SDL_RenderGetClipRect(renderer: PSDL_Renderer; rect: PSDL_Rect) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetClipRect' {$ENDIF} {$ENDIF};
443
444   {**
445    *  Set the drawing scale for rendering on the current target.
446    *
447    *   renderer The renderer for which the drawing scale should be set.
448    *   scaleX The horizontal scaling factor
449    *   scaleY The vertical scaling factor
450    *
451    *  The drawing coordinates are scaled by the x/y scaling factors
452    *  before they are used by the renderer.  This allows resolution
453    *  independent drawing with a single coordinate system.
454    *
455    *  If this results in scaling or subpixel drawing by the
456    *  rendering backend, it will be handled using the appropriate
457    *  quality hints.  For best results use integer scaling factors.
458    *
459    *   SDL_RenderGetScale()
460    *   SDL_RenderSetLogicalSize()
461    *}
462 function SDL_RenderSetScale(renderer: PSDL_Renderer; scaleX: Float; scaleY: Float): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderSetScale' {$ENDIF} {$ENDIF};
463
464   {**
465    *  Get the drawing scale for the current target.
466    *
467    *   renderer The renderer from which drawing scale should be queried.
468    *   scaleX A pointer filled in with the horizontal scaling factor
469    *   scaleY A pointer filled in with the vertical scaling factor
470    *
471    *   SDL_RenderSetScale()
472    *}
473 procedure SDL_RenderGetScale(renderer: PSDL_Renderer; scaleX: PFloat; scaleY: PFloat) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderGetScale' {$ENDIF} {$ENDIF};
474
475   {**
476    *  Set the color used for drawing operations (Rect, Line and Clear).
477    *
478    *   renderer The renderer for which drawing color should be set.
479    *   r The red value used to draw on the rendering target.
480    *   g The green value used to draw on the rendering target.
481    *   b The blue value used to draw on the rendering target.
482    *   a The alpha value used to draw on the rendering target, usually
483    *     SDL_ALPHA_OPAQUE (255).
484    *
485    *   0 on success, or -1 on error
486    *}
487 function SDL_SetRenderDrawColor(renderer: PSDL_Renderer; r: UInt8; g: UInt8; b: UInt8; a: UInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawColor' {$ENDIF} {$ENDIF};
488
489   {**
490    *  Get the color used for drawing operations (Rect, Line and Clear).
491    *
492    *   renderer The renderer from which drawing color should be queried.
493    *   r A pointer to the red value used to draw on the rendering target.
494    *   g A pointer to the green value used to draw on the rendering target.
495    *   b A pointer to the blue value used to draw on the rendering target.
496    *   a A pointer to the alpha value used to draw on the rendering target,
497    *     usually SDL_ALPHA_OPAQUE (255).
498    *
499    *   0 on success, or -1 on error
500    *}
501 function SDL_GetRenderDrawColor(renderer: PSDL_Renderer; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawColor' {$ENDIF} {$ENDIF};
502
503   {**
504    *  Set the blend mode used for drawing operations (Fill and Line).
505    *
506    *   renderer The renderer for which blend mode should be set.
507    *   blendMode SDL_BlendMode to use for blending.
508    *
509    *   0 on success, or -1 on error
510    *
511    *   If the blend mode is not supported, the closest supported mode is
512    *        chosen.
513    *
514    *   SDL_GetRenderDrawBlendMode()
515    *}
516 function SDL_SetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: TSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_SetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
517
518   {**
519    *  Get the blend mode used for drawing operations.
520    *
521    *   renderer The renderer from which blend mode should be queried.
522    *   blendMode A pointer filled in with the current blend mode.
523    *
524    *   0 on success, or -1 on error
525    *
526    *   SDL_SetRenderDrawBlendMode()
527    *}
528 function SDL_GetRenderDrawBlendMode(renderer: PSDL_Renderer; blendMode: PSDL_BlendMode): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GetRenderDrawBlendMode' {$ENDIF} {$ENDIF};
529
530   {**
531    *  Clear the current rendering target with the drawing color
532    *
533    *  This function clears the entire rendering target, ignoring the viewport.
534    *
535    *   0 on success, or -1 on error
536    *}
537 function SDL_RenderClear(renderer: PSDL_Renderer): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderClear' {$ENDIF} {$ENDIF};
538
539   {**
540    *  Draw a point on the current rendering target.
541    *
542    *   renderer The renderer which should draw a point.
543    *   x The x coordinate of the point.
544    *   y The y coordinate of the point.
545    *
546    *   0 on success, or -1 on error
547    *}
548 function SDL_RenderDrawPoint(renderer: PSDL_Renderer; x: SInt32; y: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoint' {$ENDIF} {$ENDIF};
549
550   {**
551    *  Draw multiple points on the current rendering target.
552    *
553    *   renderer The renderer which should draw multiple points.
554    *   points The points to draw
555    *   count The number of points to draw
556    *
557    *   0 on success, or -1 on error
558    *}
559 function SDL_RenderDrawPoints(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawPoints' {$ENDIF} {$ENDIF};
560
561   {**
562    *  Draw a line on the current rendering target.
563    *
564    *   renderer The renderer which should draw a line.
565    *   x1 The x coordinate of the start point.
566    *   y1 The y coordinate of the start point.
567    *   x2 The x coordinate of the end point.
568    *   y2 The y coordinate of the end point.
569    *
570    *   0 on success, or -1 on error
571    *}
572 function SDL_RenderDrawLine(renderer: PSDL_Renderer; x1: SInt32; y1: SInt32; x2: SInt32; y2: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLine' {$ENDIF} {$ENDIF};
573
574   {**
575    *  \brief Draw a series of connected lines on the current rendering target.
576    *
577    *  \param renderer The renderer which should draw multiple lines.
578    *  \param points The points along the lines
579    *  \param count The number of points, drawing count-1 lines
580    *
581    *  \return 0 on success, or -1 on error
582    *}
583 function SDL_RenderDrawLines(renderer: PSDL_Renderer; points: PSDL_Point; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawLines' {$ENDIF} {$ENDIF};
584
585   {**
586    *  Draw a rectangle on the current rendering target.
587    *
588    *   renderer The renderer which should draw a rectangle.
589    *   rect A pointer to the destination rectangle, or NULL to outline the entire rendering target.
590    *
591    *   0 on success, or -1 on error
592    *}
593 function SDL_RenderDrawRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRect' {$ENDIF} {$ENDIF};
594
595   {**
596    *  Draw some number of rectangles on the current rendering target.
597    *
598    *   renderer The renderer which should draw multiple rectangles.
599    *   rects A pointer to an array of destination rectangles.
600    *   count The number of rectangles.
601    *
602    *   0 on success, or -1 on error
603    *}
604 function SDL_RenderDrawRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderDrawRects' {$ENDIF} {$ENDIF};
605
606   {**
607    *  Fill a rectangle on the current rendering target with the drawing color.
608    *
609    *   renderer The renderer which should fill a rectangle.
610    *   rect A pointer to the destination rectangle, or NULL for the entire
611    *        rendering target.
612    *
613    *   0 on success, or -1 on error
614    *}
615 function SDL_RenderFillRect(renderer: PSDL_Renderer; rect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRect' {$ENDIF} {$ENDIF};
616
617   {**
618    *  Fill some number of rectangles on the current rendering target with the drawing color.
619    *
620    *   renderer The renderer which should fill multiple rectangles.
621    *   rects A pointer to an array of destination rectangles.
622    *   count The number of rectangles.
623    *
624    *   0 on success, or -1 on error
625    *}
626 function SDL_RenderFillRects(renderer: PSDL_Renderer; rects: PSDL_Rect; count: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderFillRects' {$ENDIF} {$ENDIF};
627
628   {**
629    *  Copy a portion of the texture to the current rendering target.
630    *
631    *   renderer The renderer which should copy parts of a texture.
632    *   texture The source texture.
633    *   srcrect   A pointer to the source rectangle, or NULL for the entire
634    *             texture.
635    *   dstrect   A pointer to the destination rectangle, or NULL for the
636    *             entire rendering target.
637    *
638    *   0 on success, or -1 on error
639    *}
640 function SDL_RenderCopy(renderer: PSDL_Renderer; texture: PSDL_Texture; srcrect: PSDL_Rect; dstrect: PSDL_Rect): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopy' {$ENDIF} {$ENDIF};
641
642   {**
643    *  Copy a portion of the source texture to the current rendering target, rotating it by angle around the given center
644    *
645    *   renderer The renderer which should copy parts of a texture.
646    *   texture The source texture.
647    *   srcrect   A pointer to the source rectangle, or NULL for the entire
648    *                   texture.
649    *   dstrect   A pointer to the destination rectangle, or NULL for the
650    *                   entire rendering target.
651    *   angle    An angle in degrees that indicates the rotation that will be applied to dstrect
652    *   center   A pointer to a point indicating the point around which dstrect will be rotated (if NULL, rotation will be done aroud dstrect.w/2, dstrect.h/2)
653    *   flip     An SDL_RendererFlip value stating which flipping actions should be performed on the texture
654    *
655    *   0 on success, or -1 on error
656    *}
657 function SDL_RenderCopyEx(renderer: PSDL_Renderer; texture: PSDL_Texture; const srcrect: PSDL_Rect; dstrect: PSDL_Rect; angle: Double; center: PSDL_Point; flip: PSDL_RendererFlip): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderCopyEx' {$ENDIF} {$ENDIF};
658
659   {**
660    *  Read pixels from the current rendering target.
661    *
662    *   renderer The renderer from which pixels should be read.
663    *   rect   A pointer to the rectangle to read, or NULL for the entire
664    *                render target.
665    *   format The desired format of the pixel data, or 0 to use the format
666    *                of the rendering target
667    *   pixels A pointer to be filled in with the pixel data
668    *   pitch  The pitch of the pixels parameter.
669    *
670    *   0 on success, or -1 if pixel reading is not supported.
671    *
672    *   This is a very slow operation, and should not be used frequently.
673    *}
674 function SDL_RenderReadPixels(renderer: PSDL_Renderer; rect: PSDL_Rect; format: UInt32; pixels: Pointer; pitch: SInt32): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderReadPixels' {$ENDIF} {$ENDIF};
675
676   {**
677    *  Update the screen with rendering performed.
678    *}
679 procedure SDL_RenderPresent(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_RenderPresent' {$ENDIF} {$ENDIF};
680
681   {**
682    *  Destroy the specified texture.
683    *
684    *   SDL_CreateTexture()
685    *   SDL_CreateTextureFromSurface()
686    *}
687 procedure SDL_DestroyTexture(texture: PSDL_Texture) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyTexture' {$ENDIF} {$ENDIF};
688
689   {**
690    *  Destroy the rendering context for a window and free associated
691    *  textures.
692    *
693    *   SDL_CreateRenderer()
694    *}
695 procedure SDL_DestroyRenderer(renderer: PSDL_Renderer) cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_DestroyRenderer' {$ENDIF} {$ENDIF};
696
697   {**
698    *  Bind the texture to the current OpenGL/ES/ES2 context for use with
699    *  OpenGL instructions.
700    *
701    *   texture  The SDL texture to bind
702    *   texw     A pointer to a float that will be filled with the texture width
703    *   texh     A pointer to a float that will be filled with the texture height
704    *
705    *   0 on success, or -1 if the operation is not supported
706    *}
707 function SDL_GL_BindTexture(texture: PSDL_Texture; texw: PFloat; texh: PFloat): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_BindTexture' {$ENDIF} {$ENDIF};
708
709   {**
710    *  Unbind a texture from the current OpenGL/ES/ES2 context.
711    *
712    *   texture  The SDL texture to unbind
713    *
714    *   0 on success, or -1 if the operation is not supported
715    *}
716 function SDL_GL_UnbindTexture(texture: PSDL_Texture): SInt32 cdecl; external SDL_LibName {$IFDEF DELPHI} {$IFDEF MACOS} name '_SDL_GL_UnbindTexture' {$ENDIF} {$ENDIF};