From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/render/SDL_sysrender.h | 372 +++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/render/SDL_sysrender.h (limited to 'contrib/SDL-3.2.8/src/render/SDL_sysrender.h') diff --git a/contrib/SDL-3.2.8/src/render/SDL_sysrender.h b/contrib/SDL-3.2.8/src/render/SDL_sysrender.h new file mode 100644 index 0000000..9d39dfd --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/SDL_sysrender.h @@ -0,0 +1,372 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifndef SDL_sysrender_h_ +#define SDL_sysrender_h_ + +#include "../video/SDL_surface_c.h" + +#include "SDL_yuv_sw_c.h" + +// Set up for C function definitions, even when using C++ +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum SDL_TextureAddressMode +{ + SDL_TEXTURE_ADDRESS_AUTO, + SDL_TEXTURE_ADDRESS_CLAMP, + SDL_TEXTURE_ADDRESS_WRAP, +} SDL_TextureAddressMode; + +/** + * A rectangle, with the origin at the upper left (double precision). + */ +typedef struct SDL_DRect +{ + double x; + double y; + double w; + double h; +} SDL_DRect; + +// The SDL 2D rendering system + +typedef struct SDL_RenderDriver SDL_RenderDriver; + +// Rendering view state +typedef struct SDL_RenderViewState +{ + int pixel_w; + int pixel_h; + SDL_Rect viewport; + SDL_Rect pixel_viewport; + SDL_Rect clip_rect; + SDL_Rect pixel_clip_rect; + bool clipping_enabled; + SDL_FPoint scale; + + // Support for logical output coordinates + SDL_RendererLogicalPresentation logical_presentation_mode; + int logical_w, logical_h; + SDL_FRect logical_src_rect; + SDL_FRect logical_dst_rect; + SDL_FPoint logical_scale; + SDL_FPoint logical_offset; + + SDL_FPoint current_scale; // this is just `scale * logical_scale`, precalculated, since we use it a lot. +} SDL_RenderViewState; + +// Define the SDL texture structure +struct SDL_Texture +{ + // Public API definition + SDL_PixelFormat format; /**< The format of the texture, read-only */ + int w; /**< The width of the texture, read-only. */ + int h; /**< The height of the texture, read-only. */ + + int refcount; /**< Application reference count, used when freeing texture */ + + // Private API definition + SDL_Colorspace colorspace; // The colorspace of the texture + float SDR_white_point; // The SDR white point for this content + float HDR_headroom; // The HDR headroom needed by this content + SDL_TextureAccess access; // The texture access mode + SDL_BlendMode blendMode; // The texture blend mode + SDL_ScaleMode scaleMode; // The texture scale mode + SDL_FColor color; // Texture modulation values + SDL_RenderViewState view; // Target texture view state + + SDL_Renderer *renderer; + + // Support for formats not supported directly by the renderer + SDL_Texture *native; + SDL_SW_YUVTexture *yuv; + void *pixels; + int pitch; + SDL_Rect locked_rect; + SDL_Surface *locked_surface; // Locked region exposed as a SDL surface + + Uint32 last_command_generation; // last command queue generation this texture was in. + + SDL_PropertiesID props; + + void *internal; // Driver specific texture representation + + SDL_Texture *prev; + SDL_Texture *next; +}; + +typedef enum +{ + SDL_RENDERCMD_NO_OP, + SDL_RENDERCMD_SETVIEWPORT, + SDL_RENDERCMD_SETCLIPRECT, + SDL_RENDERCMD_SETDRAWCOLOR, + SDL_RENDERCMD_CLEAR, + SDL_RENDERCMD_DRAW_POINTS, + SDL_RENDERCMD_DRAW_LINES, + SDL_RENDERCMD_FILL_RECTS, + SDL_RENDERCMD_COPY, + SDL_RENDERCMD_COPY_EX, + SDL_RENDERCMD_GEOMETRY +} SDL_RenderCommandType; + +typedef struct SDL_RenderCommand +{ + SDL_RenderCommandType command; + union + { + struct + { + size_t first; + SDL_Rect rect; + } viewport; + struct + { + bool enabled; + SDL_Rect rect; + } cliprect; + struct + { + size_t first; + size_t count; + float color_scale; + SDL_FColor color; + SDL_BlendMode blend; + SDL_Texture *texture; + SDL_TextureAddressMode texture_address_mode; + } draw; + struct + { + size_t first; + float color_scale; + SDL_FColor color; + } color; + } data; + struct SDL_RenderCommand *next; +} SDL_RenderCommand; + +typedef struct SDL_VertexSolid +{ + SDL_FPoint position; + SDL_FColor color; +} SDL_VertexSolid; + +typedef enum +{ + SDL_RENDERLINEMETHOD_POINTS, + SDL_RENDERLINEMETHOD_LINES, + SDL_RENDERLINEMETHOD_GEOMETRY, +} SDL_RenderLineMethod; + +// Define the SDL renderer structure +struct SDL_Renderer +{ + void (*WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event); + bool (*GetOutputSize)(SDL_Renderer *renderer, int *w, int *h); + bool (*SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode); + bool (*CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props); + bool (*QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd); + bool (*QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd); + bool (*QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, + int count); + bool (*QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, + int count); + bool (*QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, + int count); + bool (*QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, + const SDL_FRect *srcrect, const SDL_FRect *dstrect); + bool (*QueueCopyEx)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, + const SDL_FRect *srcquad, const SDL_FRect *dstrect, + const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y); + bool (*QueueGeometry)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, + const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, + int num_vertices, const void *indices, int num_indices, int size_indices, + float scale_x, float scale_y); + + void (*InvalidateCachedState)(SDL_Renderer *renderer); + bool (*RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize); + bool (*UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, const void *pixels, + int pitch); +#ifdef SDL_HAVE_YUV + bool (*UpdateTextureYUV)(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *Uplane, int Upitch, + const Uint8 *Vplane, int Vpitch); + bool (*UpdateTextureNV)(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *UVplane, int UVpitch); +#endif + bool (*LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_Rect *rect, void **pixels, int *pitch); + void (*UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture); + void (*SetTextureScaleMode)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode); + bool (*SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture); + SDL_Surface *(*RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect); + bool (*RenderPresent)(SDL_Renderer *renderer); + void (*DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture); + + void (*DestroyRenderer)(SDL_Renderer *renderer); + + bool (*SetVSync)(SDL_Renderer *renderer, int vsync); + + void *(*GetMetalLayer)(SDL_Renderer *renderer); + void *(*GetMetalCommandEncoder)(SDL_Renderer *renderer); + + bool (*AddVulkanRenderSemaphores)(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore); + + // The current renderer info + const char *name; + SDL_PixelFormat *texture_formats; + int num_texture_formats; + bool software; + + // The window associated with the renderer + SDL_Window *window; + bool hidden; + + // Whether we should simulate vsync + bool wanted_vsync; + bool simulate_vsync; + Uint64 simulate_vsync_interval_ns; + Uint64 last_present; + + SDL_RenderViewState *view; + SDL_RenderViewState main_view; + + // The window pixel to point coordinate scale + SDL_FPoint dpi_scale; + + // The method of drawing lines + SDL_RenderLineMethod line_method; + + // The list of textures + SDL_Texture *textures; + SDL_Texture *target; + SDL_Mutex *target_mutex; + + SDL_Colorspace output_colorspace; + float SDR_white_point; + float HDR_headroom; + + float desired_color_scale; + float color_scale; + SDL_FColor color; /**< Color for drawing operations values */ + SDL_BlendMode blendMode; /**< The drawing blend mode */ + SDL_TextureAddressMode texture_address_mode; + + SDL_RenderCommand *render_commands; + SDL_RenderCommand *render_commands_tail; + SDL_RenderCommand *render_commands_pool; + Uint32 render_command_generation; + SDL_FColor last_queued_color; + float last_queued_color_scale; + SDL_Rect last_queued_viewport; + SDL_Rect last_queued_cliprect; + bool last_queued_cliprect_enabled; + bool color_queued; + bool viewport_queued; + bool cliprect_queued; + + void *vertex_data; + size_t vertex_data_used; + size_t vertex_data_allocation; + + // Shaped window support + bool transparent_window; + SDL_Surface *shape_surface; + SDL_Texture *shape_texture; + + SDL_PropertiesID props; + + SDL_Texture *debug_char_texture_atlas; + + bool destroyed; // already destroyed by SDL_DestroyWindow; just free this struct in SDL_DestroyRenderer. + + void *internal; + + SDL_Renderer *next; +}; + +// Define the SDL render driver structure +struct SDL_RenderDriver +{ + bool (*CreateRenderer)(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID props); + + const char *name; +}; + +// Not all of these are available in a given build. Use #ifdefs, etc. +extern SDL_RenderDriver D3D_RenderDriver; +extern SDL_RenderDriver D3D11_RenderDriver; +extern SDL_RenderDriver D3D12_RenderDriver; +extern SDL_RenderDriver GL_RenderDriver; +extern SDL_RenderDriver GLES2_RenderDriver; +extern SDL_RenderDriver METAL_RenderDriver; +extern SDL_RenderDriver VULKAN_RenderDriver; +extern SDL_RenderDriver PS2_RenderDriver; +extern SDL_RenderDriver PSP_RenderDriver; +extern SDL_RenderDriver SW_RenderDriver; +extern SDL_RenderDriver VITA_GXM_RenderDriver; +extern SDL_RenderDriver GPU_RenderDriver; + +// Clean up any renderers at shutdown +extern void SDL_QuitRender(void); + +// Add a supported texture format to a renderer +extern bool SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormat format); + +// Setup colorspace conversion +extern void SDL_SetupRendererColorspace(SDL_Renderer *renderer, SDL_PropertiesID props); + +// Colorspace conversion functions +extern bool SDL_RenderingLinearSpace(SDL_Renderer *renderer); +extern void SDL_ConvertToLinear(SDL_FColor *color); +extern void SDL_ConvertFromLinear(SDL_FColor *color); + +// Blend mode functions +extern SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode); +extern SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode); +extern SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode); +extern SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode); +extern SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode); +extern SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode); + +/* drivers call this during their Queue*() methods to make space in a array that are used + for a vertex buffer during RunCommandQueue(). Pointers returned here are only valid until + the next call, because it might be in an array that gets realloc()'d. */ +extern void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, size_t numbytes, size_t alignment, size_t *offset); + +// Let the video subsystem destroy a renderer without making its pointer invalid. +extern void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer); + +// Ends C function definitions when using C++ +#ifdef __cplusplus +} +#endif + +#endif // SDL_sysrender_h_ -- cgit v1.2.3