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_render.c | 5676 +++++++++++++++++++++++++++++ 1 file changed, 5676 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/render/SDL_render.c (limited to 'contrib/SDL-3.2.8/src/render/SDL_render.c') diff --git a/contrib/SDL-3.2.8/src/render/SDL_render.c b/contrib/SDL-3.2.8/src/render/SDL_render.c new file mode 100644 index 0000000..82ecb88 --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/SDL_render.c @@ -0,0 +1,5676 @@ +/* + 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" + +// The SDL 2D rendering system + +#include "SDL_sysrender.h" +#include "SDL_render_debug_font.h" +#include "software/SDL_render_sw_c.h" +#include "../events/SDL_windowevents_c.h" +#include "../video/SDL_pixels_c.h" +#include "../video/SDL_video_c.h" + +#ifdef SDL_PLATFORM_ANDROID +#include "../core/android/SDL_android.h" +#include "../video/android/SDL_androidevents.h" +#endif + +/* as a courtesy to iOS apps, we don't try to draw when in the background, as +that will crash the app. However, these apps _should_ have used +SDL_AddEventWatch to catch SDL_EVENT_WILL_ENTER_BACKGROUND events and stopped +drawing themselves. Other platforms still draw, as the compositor can use it, +and more importantly: drawing to render targets isn't lost. But I still think +this should probably be removed at some point in the future. --ryan. */ +#if defined(SDL_PLATFORM_IOS) || defined(SDL_PLATFORM_TVOS) || defined(SDL_PLATFORM_ANDROID) +#define DONT_DRAW_WHILE_HIDDEN 1 +#else +#define DONT_DRAW_WHILE_HIDDEN 0 +#endif + +#define SDL_PROP_WINDOW_RENDERER_POINTER "SDL.internal.window.renderer" +#define SDL_PROP_TEXTURE_PARENT_POINTER "SDL.internal.texture.parent" + +#define CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer, result) \ + if (!SDL_ObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER)) { \ + SDL_InvalidParamError("renderer"); \ + return result; \ + } + +#define CHECK_RENDERER_MAGIC(renderer, result) \ + CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer, result); \ + if ((renderer)->destroyed) { \ + SDL_SetError("Renderer's window has been destroyed, can't use further"); \ + return result; \ + } + +#define CHECK_TEXTURE_MAGIC(texture, result) \ + if (!SDL_ObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE)) { \ + SDL_InvalidParamError("texture"); \ + return result; \ + } + +// Predefined blend modes +#define SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, \ + srcAlphaFactor, dstAlphaFactor, alphaOperation) \ + (SDL_BlendMode)(((Uint32)(colorOperation) << 0) | \ + ((Uint32)(srcColorFactor) << 4) | \ + ((Uint32)(dstColorFactor) << 8) | \ + ((Uint32)(alphaOperation) << 16) | \ + ((Uint32)(srcAlphaFactor) << 20) | \ + ((Uint32)(dstAlphaFactor) << 24)) + +#define SDL_BLENDMODE_NONE_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_BLEND_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_ADD_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_MOD_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_COLOR, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD) + +#define SDL_BLENDMODE_MUL_FULL \ + SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_DST_COLOR, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \ + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD) + +#ifndef SDL_RENDER_DISABLED +static const SDL_RenderDriver *render_drivers[] = { +#ifdef SDL_VIDEO_RENDER_D3D11 + &D3D11_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_D3D12 + &D3D12_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_D3D + &D3D_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_METAL + &METAL_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_OGL + &GL_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_OGL_ES2 + &GLES2_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_PS2 + &PS2_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_PSP + &PSP_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_VITA_GXM + &VITA_GXM_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_VULKAN + &VULKAN_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_GPU + &GPU_RenderDriver, +#endif +#ifdef SDL_VIDEO_RENDER_SW + &SW_RenderDriver, +#endif + NULL +}; +#endif // !SDL_RENDER_DISABLED + +static SDL_Renderer *SDL_renderers; + +static const int rect_index_order[] = { 0, 1, 2, 0, 2, 3 }; + +void SDL_QuitRender(void) +{ + while (SDL_renderers) { + SDL_DestroyRenderer(SDL_renderers); + } +} + +bool SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormat format) +{ + SDL_PixelFormat *texture_formats = (SDL_PixelFormat *)SDL_realloc((void *)renderer->texture_formats, (renderer->num_texture_formats + 2) * sizeof(SDL_PixelFormat)); + if (!texture_formats) { + return false; + } + texture_formats[renderer->num_texture_formats++] = format; + texture_formats[renderer->num_texture_formats] = SDL_PIXELFORMAT_UNKNOWN; + renderer->texture_formats = texture_formats; + SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, texture_formats); + return true; +} + +void SDL_SetupRendererColorspace(SDL_Renderer *renderer, SDL_PropertiesID props) +{ + renderer->output_colorspace = (SDL_Colorspace)SDL_GetNumberProperty(props, SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER, SDL_COLORSPACE_SRGB); +} + +bool SDL_RenderingLinearSpace(SDL_Renderer *renderer) +{ + SDL_Colorspace colorspace; + + if (renderer->target) { + colorspace = renderer->target->colorspace; + } else { + colorspace = renderer->output_colorspace; + } + if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) { + return true; + } + return false; +} + +void SDL_ConvertToLinear(SDL_FColor *color) +{ + color->r = SDL_sRGBtoLinear(color->r); + color->g = SDL_sRGBtoLinear(color->g); + color->b = SDL_sRGBtoLinear(color->b); +} + +void SDL_ConvertFromLinear(SDL_FColor *color) +{ + color->r = SDL_sRGBfromLinear(color->r); + color->g = SDL_sRGBfromLinear(color->g); + color->b = SDL_sRGBfromLinear(color->b); +} + +static SDL_INLINE void DebugLogRenderCommands(const SDL_RenderCommand *cmd) +{ +#if 0 + unsigned int i = 1; + SDL_Log("Render commands to flush:"); + while (cmd) { + switch (cmd->command) { + case SDL_RENDERCMD_NO_OP: + SDL_Log(" %u. no-op", i++); + break; + + case SDL_RENDERCMD_SETVIEWPORT: + SDL_Log(" %u. set viewport (first=%u, rect={(%d, %d), %dx%d})", i++, + (unsigned int) cmd->data.viewport.first, + cmd->data.viewport.rect.x, cmd->data.viewport.rect.y, + cmd->data.viewport.rect.w, cmd->data.viewport.rect.h); + break; + + case SDL_RENDERCMD_SETCLIPRECT: + SDL_Log(" %u. set cliprect (enabled=%s, rect={(%d, %d), %dx%d})", i++, + cmd->data.cliprect.enabled ? "true" : "false", + cmd->data.cliprect.rect.x, cmd->data.cliprect.rect.y, + cmd->data.cliprect.rect.w, cmd->data.cliprect.rect.h); + break; + + case SDL_RENDERCMD_SETDRAWCOLOR: + SDL_Log(" %u. set draw color (first=%u, r=%d, g=%d, b=%d, a=%d, color_scale=%g)", i++, + (unsigned int) cmd->data.color.first, + (int) cmd->data.color.color.r, (int) cmd->data.color.color.g, + (int) cmd->data.color.color.b, (int) cmd->data.color.color.a, cmd->data.color.color_scale); + break; + + case SDL_RENDERCMD_CLEAR: + SDL_Log(" %u. clear (first=%u, r=%d, g=%d, b=%d, a=%d, color_scale=%g)", i++, + (unsigned int) cmd->data.color.first, + (int) cmd->data.color.color.r, (int) cmd->data.color.color.g, + (int) cmd->data.color.color.b, (int) cmd->data.color.color.a, cmd->data.color.color_scale); + break; + + case SDL_RENDERCMD_DRAW_POINTS: + SDL_Log(" %u. draw points (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale); + break; + + case SDL_RENDERCMD_DRAW_LINES: + SDL_Log(" %u. draw lines (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale); + break; + + case SDL_RENDERCMD_FILL_RECTS: + SDL_Log(" %u. fill rects (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale); + break; + + case SDL_RENDERCMD_COPY: + SDL_Log(" %u. copy (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture); + break; + + + case SDL_RENDERCMD_COPY_EX: + SDL_Log(" %u. copyex (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture); + break; + + case SDL_RENDERCMD_GEOMETRY: + SDL_Log(" %u. geometry (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++, + (unsigned int) cmd->data.draw.first, + (unsigned int) cmd->data.draw.count, + (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g, + (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a, + (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture); + break; + + } + cmd = cmd->next; + } +#endif +} + +static bool FlushRenderCommands(SDL_Renderer *renderer) +{ + bool result; + + SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL)); + + if (!renderer->render_commands) { // nothing to do! + SDL_assert(renderer->vertex_data_used == 0); + return true; + } + + DebugLogRenderCommands(renderer->render_commands); + + result = renderer->RunCommandQueue(renderer, renderer->render_commands, renderer->vertex_data, renderer->vertex_data_used); + + // Move the whole render command queue to the unused pool so we can reuse them next time. + if (renderer->render_commands_tail) { + renderer->render_commands_tail->next = renderer->render_commands_pool; + renderer->render_commands_pool = renderer->render_commands; + renderer->render_commands_tail = NULL; + renderer->render_commands = NULL; + } + renderer->vertex_data_used = 0; + renderer->render_command_generation++; + renderer->color_queued = false; + renderer->viewport_queued = false; + renderer->cliprect_queued = false; + return result; +} + +static bool FlushRenderCommandsIfTextureNeeded(SDL_Texture *texture) +{ + SDL_Renderer *renderer = texture->renderer; + if (texture->last_command_generation == renderer->render_command_generation) { + // the current command queue depends on this texture, flush the queue now before it changes + return FlushRenderCommands(renderer); + } + return true; +} + +bool SDL_FlushRenderer(SDL_Renderer *renderer) +{ + if (!FlushRenderCommands(renderer)) { + return false; + } + renderer->InvalidateCachedState(renderer); + return true; +} + +void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, size_t numbytes, size_t alignment, size_t *offset) +{ + const size_t needed = renderer->vertex_data_used + numbytes + alignment; + const size_t current_offset = renderer->vertex_data_used; + + const size_t aligner = (alignment && ((current_offset & (alignment - 1)) != 0)) ? (alignment - (current_offset & (alignment - 1))) : 0; + const size_t aligned = current_offset + aligner; + + if (renderer->vertex_data_allocation < needed) { + const size_t current_allocation = renderer->vertex_data ? renderer->vertex_data_allocation : 1024; + size_t newsize = current_allocation * 2; + void *ptr; + while (newsize < needed) { + newsize *= 2; + } + + ptr = SDL_realloc(renderer->vertex_data, newsize); + + if (!ptr) { + return NULL; + } + renderer->vertex_data = ptr; + renderer->vertex_data_allocation = newsize; + } + + if (offset) { + *offset = aligned; + } + + renderer->vertex_data_used += aligner + numbytes; + + return ((Uint8 *)renderer->vertex_data) + aligned; +} + +static SDL_RenderCommand *AllocateRenderCommand(SDL_Renderer *renderer) +{ + SDL_RenderCommand *result = NULL; + + result = renderer->render_commands_pool; + if (result) { + renderer->render_commands_pool = result->next; + result->next = NULL; + } else { + result = (SDL_RenderCommand *)SDL_calloc(1, sizeof(*result)); + if (!result) { + return NULL; + } + } + + SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL)); + if (renderer->render_commands_tail) { + renderer->render_commands_tail->next = result; + } else { + renderer->render_commands = result; + } + renderer->render_commands_tail = result; + + return result; +} + +static void UpdatePixelViewport(SDL_Renderer *renderer, SDL_RenderViewState *view) +{ + view->pixel_viewport.x = (int)SDL_floorf((view->viewport.x * view->current_scale.x) + view->logical_offset.x); + view->pixel_viewport.y = (int)SDL_floorf((view->viewport.y * view->current_scale.y) + view->logical_offset.y); + if (view->viewport.w >= 0) { + view->pixel_viewport.w = (int)SDL_ceilf(view->viewport.w * view->current_scale.x); + } else { + view->pixel_viewport.w = view->pixel_w; + } + if (view->viewport.h >= 0) { + view->pixel_viewport.h = (int)SDL_ceilf(view->viewport.h * view->current_scale.y); + } else { + view->pixel_viewport.h = view->pixel_h; + } +} + +static bool QueueCmdSetViewport(SDL_Renderer *renderer) +{ + bool result = true; + + SDL_Rect viewport = renderer->view->pixel_viewport; + + if (!renderer->viewport_queued || + SDL_memcmp(&viewport, &renderer->last_queued_viewport, sizeof(viewport)) != 0) { + SDL_RenderCommand *cmd = AllocateRenderCommand(renderer); + if (cmd) { + cmd->command = SDL_RENDERCMD_SETVIEWPORT; + cmd->data.viewport.first = 0; // render backend will fill this in. + SDL_copyp(&cmd->data.viewport.rect, &viewport); + result = renderer->QueueSetViewport(renderer, cmd); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } else { + SDL_copyp(&renderer->last_queued_viewport, &viewport); + renderer->viewport_queued = true; + } + } else { + result = false; + } + } + return result; +} + +static void UpdatePixelClipRect(SDL_Renderer *renderer, SDL_RenderViewState *view) +{ + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + view->pixel_clip_rect.x = (int)SDL_floorf(view->clip_rect.x * scale_x); + view->pixel_clip_rect.y = (int)SDL_floorf(view->clip_rect.y * scale_y); + view->pixel_clip_rect.w = (int)SDL_ceilf(view->clip_rect.w * scale_x); + view->pixel_clip_rect.h = (int)SDL_ceilf(view->clip_rect.h * scale_y); +} + +static bool QueueCmdSetClipRect(SDL_Renderer *renderer) +{ + bool result = true; + + const SDL_RenderViewState *view = renderer->view; + SDL_Rect clip_rect = view->pixel_clip_rect; + if (!renderer->cliprect_queued || + view->clipping_enabled != renderer->last_queued_cliprect_enabled || + SDL_memcmp(&clip_rect, &renderer->last_queued_cliprect, sizeof(clip_rect)) != 0) { + SDL_RenderCommand *cmd = AllocateRenderCommand(renderer); + if (cmd) { + cmd->command = SDL_RENDERCMD_SETCLIPRECT; + cmd->data.cliprect.enabled = view->clipping_enabled; + SDL_copyp(&cmd->data.cliprect.rect, &clip_rect); + SDL_copyp(&renderer->last_queued_cliprect, &clip_rect); + renderer->last_queued_cliprect_enabled = view->clipping_enabled; + renderer->cliprect_queued = true; + } else { + result = false; + } + } + return result; +} + +static bool QueueCmdSetDrawColor(SDL_Renderer *renderer, SDL_FColor *color) +{ + bool result = true; + + if (!renderer->color_queued || + color->r != renderer->last_queued_color.r || + color->g != renderer->last_queued_color.g || + color->b != renderer->last_queued_color.b || + color->a != renderer->last_queued_color.a) { + SDL_RenderCommand *cmd = AllocateRenderCommand(renderer); + result = false; + + if (cmd) { + cmd->command = SDL_RENDERCMD_SETDRAWCOLOR; + cmd->data.color.first = 0; // render backend will fill this in. + cmd->data.color.color_scale = renderer->color_scale; + cmd->data.color.color = *color; + result = renderer->QueueSetDrawColor(renderer, cmd); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } else { + renderer->last_queued_color = *color; + renderer->color_queued = true; + } + } + } + return result; +} + +static bool QueueCmdClear(SDL_Renderer *renderer) +{ + SDL_RenderCommand *cmd = AllocateRenderCommand(renderer); + if (!cmd) { + return false; + } + + cmd->command = SDL_RENDERCMD_CLEAR; + cmd->data.color.first = 0; + cmd->data.color.color_scale = renderer->color_scale; + cmd->data.color.color = renderer->color; + return true; +} + +static SDL_RenderCommand *PrepQueueCmdDraw(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype, SDL_Texture *texture) +{ + SDL_RenderCommand *cmd = NULL; + bool result = true; + SDL_FColor *color; + SDL_BlendMode blendMode; + + if (texture) { + color = &texture->color; + blendMode = texture->blendMode; + } else { + color = &renderer->color; + blendMode = renderer->blendMode; + } + + if (cmdtype != SDL_RENDERCMD_GEOMETRY) { + result = QueueCmdSetDrawColor(renderer, color); + } + + /* Set the viewport and clip rect directly before draws, so the backends + * don't have to worry about that state not being valid at draw time. */ + if (result && !renderer->viewport_queued) { + result = QueueCmdSetViewport(renderer); + } + if (result && !renderer->cliprect_queued) { + result = QueueCmdSetClipRect(renderer); + } + + if (result) { + cmd = AllocateRenderCommand(renderer); + if (cmd) { + cmd->command = cmdtype; + cmd->data.draw.first = 0; // render backend will fill this in. + cmd->data.draw.count = 0; // render backend will fill this in. + cmd->data.draw.color_scale = renderer->color_scale; + cmd->data.draw.color = *color; + cmd->data.draw.blend = blendMode; + cmd->data.draw.texture = texture; + cmd->data.draw.texture_address_mode = SDL_TEXTURE_ADDRESS_CLAMP; + } + } + return cmd; +} + +static bool QueueCmdDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, const int count) +{ + SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_POINTS, NULL); + bool result = false; + if (cmd) { + result = renderer->QueueDrawPoints(renderer, cmd, points, count); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + return result; +} + +static bool QueueCmdDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, const int count) +{ + SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_LINES, NULL); + bool result = false; + if (cmd) { + result = renderer->QueueDrawLines(renderer, cmd, points, count); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + return result; +} + +static bool QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, const int count) +{ + SDL_RenderCommand *cmd; + bool result = false; + const int use_rendergeometry = (!renderer->QueueFillRects); + + cmd = PrepQueueCmdDraw(renderer, (use_rendergeometry ? SDL_RENDERCMD_GEOMETRY : SDL_RENDERCMD_FILL_RECTS), NULL); + + if (cmd) { + if (use_rendergeometry) { + bool isstack1; + bool isstack2; + float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1); + int *indices = SDL_small_alloc(int, 6 * count, &isstack2); + + if (xy && indices) { + int i; + float *ptr_xy = xy; + int *ptr_indices = indices; + const int xy_stride = 2 * sizeof(float); + const int num_vertices = 4 * count; + const int num_indices = 6 * count; + const int size_indices = 4; + int cur_index = 0; + + for (i = 0; i < count; ++i) { + float minx, miny, maxx, maxy; + + minx = rects[i].x; + miny = rects[i].y; + maxx = rects[i].x + rects[i].w; + maxy = rects[i].y + rects[i].h; + + *ptr_xy++ = minx; + *ptr_xy++ = miny; + *ptr_xy++ = maxx; + *ptr_xy++ = miny; + *ptr_xy++ = maxx; + *ptr_xy++ = maxy; + *ptr_xy++ = minx; + *ptr_xy++ = maxy; + + *ptr_indices++ = cur_index + rect_index_order[0]; + *ptr_indices++ = cur_index + rect_index_order[1]; + *ptr_indices++ = cur_index + rect_index_order[2]; + *ptr_indices++ = cur_index + rect_index_order[3]; + *ptr_indices++ = cur_index + rect_index_order[4]; + *ptr_indices++ = cur_index + rect_index_order[5]; + cur_index += 4; + } + + result = renderer->QueueGeometry(renderer, cmd, NULL, + xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0, + num_vertices, indices, num_indices, size_indices, + 1.0f, 1.0f); + + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + SDL_small_free(xy, isstack1); + SDL_small_free(indices, isstack2); + + } else { + result = renderer->QueueFillRects(renderer, cmd, rects, count); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + } + return result; +} + +static bool QueueCmdCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect) +{ + SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY, texture); + bool result = false; + if (cmd) { + result = renderer->QueueCopy(renderer, cmd, texture, srcrect, dstrect); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + return result; +} + +static bool QueueCmdCopyEx(SDL_Renderer *renderer, 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) +{ + SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY_EX, texture); + bool result = false; + if (cmd) { + result = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip, scale_x, scale_y); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + return result; +} + +static bool QueueCmdGeometry(SDL_Renderer *renderer, 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, SDL_TextureAddressMode texture_address_mode) +{ + SDL_RenderCommand *cmd; + bool result = false; + cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_GEOMETRY, texture); + if (cmd) { + cmd->data.draw.texture_address_mode = texture_address_mode; + result = renderer->QueueGeometry(renderer, cmd, texture, + xy, xy_stride, + color, color_stride, uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + scale_x, scale_y); + if (!result) { + cmd->command = SDL_RENDERCMD_NO_OP; + } + } + return result; +} + +static void UpdateMainViewDimensions(SDL_Renderer *renderer) +{ + int window_w = 0, window_h = 0; + + if (renderer->window) { + SDL_GetWindowSize(renderer->window, &window_w, &window_h); + } + + SDL_GetRenderOutputSize(renderer, &renderer->main_view.pixel_w, &renderer->main_view.pixel_h); + + if (window_w > 0 && window_h > 0) { + renderer->dpi_scale.x = (float)renderer->main_view.pixel_w / window_w; + renderer->dpi_scale.y = (float)renderer->main_view.pixel_h / window_h; + } else { + renderer->dpi_scale.x = 1.0f; + renderer->dpi_scale.y = 1.0f; + } + UpdatePixelViewport(renderer, &renderer->main_view); +} + +static void UpdateColorScale(SDL_Renderer *renderer) +{ + float SDR_white_point; + if (renderer->target) { + SDR_white_point = renderer->target->SDR_white_point; + } else { + SDR_white_point = renderer->SDR_white_point; + } + renderer->color_scale = renderer->desired_color_scale * SDR_white_point; +} + +static void UpdateHDRProperties(SDL_Renderer *renderer) +{ + SDL_PropertiesID window_props; + SDL_PropertiesID renderer_props; + + window_props = SDL_GetWindowProperties(renderer->window); + if (!window_props) { + return; + } + + renderer_props = SDL_GetRendererProperties(renderer); + if (!renderer_props) { + return; + } + + if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) { + renderer->SDR_white_point = SDL_GetFloatProperty(window_props, SDL_PROP_WINDOW_SDR_WHITE_LEVEL_FLOAT, 1.0f); + renderer->HDR_headroom = SDL_GetFloatProperty(window_props, SDL_PROP_WINDOW_HDR_HEADROOM_FLOAT, 1.0f); + } else { + renderer->SDR_white_point = 1.0f; + renderer->HDR_headroom = 1.0f; + } + + if (renderer->HDR_headroom > 1.0f) { + SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, true); + } else { + SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, false); + } + SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT, renderer->SDR_white_point); + SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT, renderer->HDR_headroom); + + UpdateColorScale(renderer); +} + +static void UpdateLogicalPresentation(SDL_Renderer *renderer); + + +int SDL_GetNumRenderDrivers(void) +{ +#ifndef SDL_RENDER_DISABLED + return SDL_arraysize(render_drivers) - 1; +#else + return 0; +#endif +} + +const char *SDL_GetRenderDriver(int index) +{ +#ifndef SDL_RENDER_DISABLED + if (index < 0 || index >= SDL_GetNumRenderDrivers()) { + SDL_InvalidParamError("index"); + return NULL; + } + return render_drivers[index]->name; +#else + SDL_SetError("SDL not built with rendering support"); + return NULL; +#endif +} + +static bool SDL_RendererEventWatch(void *userdata, SDL_Event *event) +{ + SDL_Renderer *renderer = (SDL_Renderer *)userdata; + SDL_Window *window = renderer->window; + + if (renderer->WindowEvent) { + renderer->WindowEvent(renderer, &event->window); + } + + if (event->type == SDL_EVENT_WINDOW_RESIZED || + event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED || + event->type == SDL_EVENT_WINDOW_METAL_VIEW_RESIZED) { + SDL_RenderViewState *view = renderer->view; + renderer->view = &renderer->main_view; // only update the main_view (the window framebuffer) for window changes. + UpdateLogicalPresentation(renderer); + renderer->view = view; // put us back on whatever the current render target's actual view is. + } else if (event->type == SDL_EVENT_WINDOW_HIDDEN) { + renderer->hidden = true; + } else if (event->type == SDL_EVENT_WINDOW_SHOWN) { + if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) { + renderer->hidden = false; + } + } else if (event->type == SDL_EVENT_WINDOW_MINIMIZED) { + renderer->hidden = true; + } else if (event->type == SDL_EVENT_WINDOW_RESTORED || + event->type == SDL_EVENT_WINDOW_MAXIMIZED) { + if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) { + renderer->hidden = false; + } + } else if (event->type == SDL_EVENT_WINDOW_DISPLAY_CHANGED || + event->type == SDL_EVENT_WINDOW_HDR_STATE_CHANGED) { + UpdateHDRProperties(renderer); + } + return true; +} + +bool SDL_CreateWindowAndRenderer(const char *title, int width, int height, SDL_WindowFlags window_flags, SDL_Window **window, SDL_Renderer **renderer) +{ + bool hidden = (window_flags & SDL_WINDOW_HIDDEN) != 0; + + if (!window) { + return SDL_InvalidParamError("window"); + } + + if (!renderer) { + return SDL_InvalidParamError("renderer"); + } + + // Hide the window so if the renderer recreates it, we don't get a visual flash on screen + window_flags |= SDL_WINDOW_HIDDEN; + *window = SDL_CreateWindow(title, width, height, window_flags); + if (!*window) { + *renderer = NULL; + return false; + } + + *renderer = SDL_CreateRenderer(*window, NULL); + if (!*renderer) { + SDL_DestroyWindow(*window); + *window = NULL; + return false; + } + + if (!hidden) { + SDL_ShowWindow(*window); + } + + return true; +} + +#ifndef SDL_RENDER_DISABLED +static SDL_INLINE void VerifyDrawQueueFunctions(const SDL_Renderer *renderer) +{ + /* all of these functions are required to be implemented, even as no-ops, so we don't + have to check that they aren't NULL over and over. */ + SDL_assert(renderer->QueueSetViewport != NULL); + SDL_assert(renderer->QueueSetDrawColor != NULL); + SDL_assert(renderer->QueueDrawPoints != NULL); + SDL_assert(renderer->QueueDrawLines != NULL || renderer->QueueGeometry != NULL); + SDL_assert(renderer->QueueFillRects != NULL || renderer->QueueGeometry != NULL); + SDL_assert(renderer->QueueCopy != NULL || renderer->QueueGeometry != NULL); + SDL_assert(renderer->RunCommandQueue != NULL); +} + +static SDL_RenderLineMethod SDL_GetRenderLineMethod(void) +{ + const char *hint = SDL_GetHint(SDL_HINT_RENDER_LINE_METHOD); + + int method = 0; + if (hint) { + method = SDL_atoi(hint); + } + switch (method) { + case 1: + return SDL_RENDERLINEMETHOD_POINTS; + case 2: + return SDL_RENDERLINEMETHOD_LINES; + case 3: + return SDL_RENDERLINEMETHOD_GEOMETRY; + default: + return SDL_RENDERLINEMETHOD_POINTS; + } +} + +static void SDL_CalculateSimulatedVSyncInterval(SDL_Renderer *renderer, SDL_Window *window) +{ + SDL_DisplayID displayID = SDL_GetDisplayForWindow(window); + const SDL_DisplayMode *mode; + int refresh_num, refresh_den; + + if (displayID == 0) { + displayID = SDL_GetPrimaryDisplay(); + } + mode = SDL_GetDesktopDisplayMode(displayID); + if (mode && mode->refresh_rate_numerator > 0 && mode->refresh_rate_denominator > 0) { + refresh_num = mode->refresh_rate_numerator; + refresh_den = mode->refresh_rate_denominator; + } else { + // Pick a good default refresh rate + refresh_num = 60; + refresh_den = 1; + } + // Flip numerator and denominator to change from framerate to interval + renderer->simulate_vsync_interval_ns = (SDL_NS_PER_SECOND * refresh_den) / refresh_num; +} + +#endif // !SDL_RENDER_DISABLED + + +SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props) +{ +#ifndef SDL_RENDER_DISABLED + SDL_Window *window = (SDL_Window *)SDL_GetPointerProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, NULL); + SDL_Surface *surface = (SDL_Surface *)SDL_GetPointerProperty(props, SDL_PROP_RENDERER_CREATE_SURFACE_POINTER, NULL); + const char *driver_name = SDL_GetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, NULL); + const char *hint; + SDL_PropertiesID new_props; + +#ifdef SDL_PLATFORM_ANDROID + if (!Android_WaitActiveAndLockActivity()) { + return NULL; + } +#endif + + SDL_Renderer *renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(*renderer)); + if (!renderer) { + goto error; + } + + SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, true); + + if ((!window && !surface) || (window && surface)) { + SDL_InvalidParamError("window"); + goto error; + } + + if (window && SDL_WindowHasSurface(window)) { + SDL_SetError("Surface already associated with window"); + goto error; + } + + if (window && SDL_GetRenderer(window)) { + SDL_SetError("Renderer already associated with window"); + goto error; + } + + hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC); + if (hint && *hint) { + SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, true)); + } + + if (surface) { +#ifdef SDL_VIDEO_RENDER_SW + const bool rc = SW_CreateRendererForSurface(renderer, surface, props); +#else + const bool rc = SDL_SetError("SDL not built with software renderer"); +#endif + if (!rc) { + goto error; + } + } else { + bool rc = false; + if (!driver_name) { + driver_name = SDL_GetHint(SDL_HINT_RENDER_DRIVER); + } + + if (driver_name && *driver_name != 0) { + const char *driver_attempt = driver_name; + while (driver_attempt && *driver_attempt != 0 && !rc) { + const char *driver_attempt_end = SDL_strchr(driver_attempt, ','); + const size_t driver_attempt_len = (driver_attempt_end) ? (driver_attempt_end - driver_attempt) : SDL_strlen(driver_attempt); + + for (int i = 0; render_drivers[i]; i++) { + const SDL_RenderDriver *driver = render_drivers[i]; + if ((driver_attempt_len == SDL_strlen(driver->name)) && (SDL_strncasecmp(driver->name, driver_attempt, driver_attempt_len) == 0)) { + rc = driver->CreateRenderer(renderer, window, props); + if (rc) { + break; + } + } + } + + driver_attempt = (driver_attempt_end) ? (driver_attempt_end + 1) : NULL; + } + } else { + for (int i = 0; render_drivers[i]; i++) { + const SDL_RenderDriver *driver = render_drivers[i]; + rc = driver->CreateRenderer(renderer, window, props); + if (rc) { + break; + } + SDL_DestroyRendererWithoutFreeing(renderer); + SDL_zerop(renderer); // make sure we don't leave function pointers from a previous CreateRenderer() in this struct. + } + } + + if (!rc) { + if (driver_name) { + SDL_SetError("%s not available", driver_name); + } else { + SDL_SetError("Couldn't find matching render driver"); + } + goto error; + } + } + + VerifyDrawQueueFunctions(renderer); + + renderer->window = window; + renderer->target_mutex = SDL_CreateMutex(); + if (surface) { + renderer->main_view.pixel_w = surface->w; + renderer->main_view.pixel_h = surface->h; + } + renderer->main_view.viewport.w = -1; + renderer->main_view.viewport.h = -1; + renderer->main_view.scale.x = 1.0f; + renderer->main_view.scale.y = 1.0f; + renderer->main_view.logical_scale.x = 1.0f; + renderer->main_view.logical_scale.y = 1.0f; + renderer->main_view.current_scale.x = 1.0f; + renderer->main_view.current_scale.y = 1.0f; + renderer->view = &renderer->main_view; + renderer->dpi_scale.x = 1.0f; + renderer->dpi_scale.y = 1.0f; + UpdatePixelViewport(renderer, &renderer->main_view); + UpdatePixelClipRect(renderer, &renderer->main_view); + UpdateMainViewDimensions(renderer); + + // new textures start at zero, so we start at 1 so first render doesn't flush by accident. + renderer->render_command_generation = 1; + + if (renderer->software) { + // Software renderer always uses line method, for speed + renderer->line_method = SDL_RENDERLINEMETHOD_LINES; + } else { + renderer->line_method = SDL_GetRenderLineMethod(); + } + + renderer->SDR_white_point = 1.0f; + renderer->HDR_headroom = 1.0f; + renderer->desired_color_scale = 1.0f; + renderer->color_scale = 1.0f; + + if (window) { + if (SDL_GetWindowFlags(window) & SDL_WINDOW_TRANSPARENT) { + renderer->transparent_window = true; + } + + if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN | SDL_WINDOW_MINIMIZED)) { + renderer->hidden = true; + } + } + + new_props = SDL_GetRendererProperties(renderer); + SDL_SetStringProperty(new_props, SDL_PROP_RENDERER_NAME_STRING, renderer->name); + if (window) { + SDL_SetPointerProperty(new_props, SDL_PROP_RENDERER_WINDOW_POINTER, window); + } + if (surface) { + SDL_SetPointerProperty(new_props, SDL_PROP_RENDERER_SURFACE_POINTER, surface); + } + SDL_SetNumberProperty(new_props, SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER, renderer->output_colorspace); + UpdateHDRProperties(renderer); + + if (window) { + SDL_SetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_RENDERER_POINTER, renderer); + SDL_AddWindowRenderer(window, renderer); + } + + SDL_SetRenderViewport(renderer, NULL); + + if (window) { + SDL_AddWindowEventWatch(SDL_WINDOW_EVENT_WATCH_NORMAL, SDL_RendererEventWatch, renderer); + } + + int vsync = (int)SDL_GetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0); + if (!SDL_SetRenderVSync(renderer, vsync)) { + if (vsync == 0) { + // Some renderers require vsync enabled + SDL_SetRenderVSync(renderer, 1); + } + } + SDL_CalculateSimulatedVSyncInterval(renderer, window); + + SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, + "Created renderer: %s", renderer->name); + + renderer->next = SDL_renderers; + SDL_renderers = renderer; + +#ifdef SDL_PLATFORM_ANDROID + Android_UnlockActivityMutex(); +#endif + + SDL_ClearError(); + + return renderer; + +error: +#ifdef SDL_PLATFORM_ANDROID + Android_UnlockActivityMutex(); +#endif + + if (renderer) { + SDL_DestroyRenderer(renderer); + } + return NULL; + +#else + SDL_SetError("SDL not built with rendering support"); + return NULL; +#endif +} + +SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, const char *name) +{ + SDL_Renderer *renderer; + SDL_PropertiesID props = SDL_CreateProperties(); + SDL_SetPointerProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window); + SDL_SetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, name); + renderer = SDL_CreateRendererWithProperties(props); + SDL_DestroyProperties(props); + return renderer; +} + +SDL_Renderer *SDL_CreateSoftwareRenderer(SDL_Surface *surface) +{ +#ifdef SDL_VIDEO_RENDER_SW + SDL_Renderer *renderer; + + if (!surface) { + SDL_InvalidParamError("surface"); + return NULL; + } + + SDL_PropertiesID props = SDL_CreateProperties(); + SDL_SetPointerProperty(props, SDL_PROP_RENDERER_CREATE_SURFACE_POINTER, surface); + renderer = SDL_CreateRendererWithProperties(props); + SDL_DestroyProperties(props); + return renderer; +#else + SDL_SetError("SDL not built with rendering support"); + return NULL; +#endif // !SDL_RENDER_DISABLED +} + +SDL_Renderer *SDL_GetRenderer(SDL_Window *window) +{ + return (SDL_Renderer *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_RENDERER_POINTER, NULL); +} + +SDL_Window *SDL_GetRenderWindow(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + return renderer->window; +} + +const char *SDL_GetRendererName(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + + return SDL_GetPersistentString(renderer->name); +} + +SDL_PropertiesID SDL_GetRendererProperties(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, 0); + + if (renderer->props == 0) { + renderer->props = SDL_CreateProperties(); + } + return renderer->props; +} + +bool SDL_GetRenderOutputSize(SDL_Renderer *renderer, int *w, int *h) +{ + if (w) { + *w = 0; + } + if (h) { + *h = 0; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (renderer->GetOutputSize) { + return renderer->GetOutputSize(renderer, w, h); + } else if (renderer->window) { + return SDL_GetWindowSizeInPixels(renderer->window, w, h); + } else { + SDL_assert(!"This should never happen"); + return SDL_SetError("Renderer doesn't support querying output size"); + } +} + +bool SDL_GetCurrentRenderOutputSize(SDL_Renderer *renderer, int *w, int *h) +{ + if (w) { + *w = 0; + } + if (h) { + *h = 0; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + const SDL_RenderViewState *view = renderer->view; + if (w) { + *w = view->pixel_w; + } + if (h) { + *h = view->pixel_h; + } + return true; +} + +static bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode) +{ + switch (blendMode) { + // These are required to be supported by all renderers + case SDL_BLENDMODE_NONE: + case SDL_BLENDMODE_BLEND: + case SDL_BLENDMODE_BLEND_PREMULTIPLIED: + case SDL_BLENDMODE_ADD: + case SDL_BLENDMODE_ADD_PREMULTIPLIED: + case SDL_BLENDMODE_MOD: + case SDL_BLENDMODE_MUL: + return true; + + default: + return renderer->SupportsBlendMode && renderer->SupportsBlendMode(renderer, blendMode); + } +} + +static bool IsSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format) +{ + int i; + + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == format) { + return true; + } + } + return false; +} + +static SDL_PixelFormat GetClosestSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format) +{ + int i; + + if (format == SDL_PIXELFORMAT_MJPG) { + // We'll decode to SDL_PIXELFORMAT_NV12 or SDL_PIXELFORMAT_RGBA32 + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == SDL_PIXELFORMAT_NV12) { + return renderer->texture_formats[i]; + } + } + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == SDL_PIXELFORMAT_RGBA32) { + return renderer->texture_formats[i]; + } + } + } else if (SDL_ISPIXELFORMAT_FOURCC(format)) { + // Look for an exact match + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == format) { + return renderer->texture_formats[i]; + } + } + } else if (SDL_ISPIXELFORMAT_10BIT(format) || SDL_ISPIXELFORMAT_FLOAT(format)) { + if (SDL_ISPIXELFORMAT_10BIT(format)) { + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) { + return renderer->texture_formats[i]; + } + } + } + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) { + return renderer->texture_formats[i]; + } + } + } else { + bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format); + + // We just want to match the first format that has the same channels + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) && + SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == hasAlpha) { + return renderer->texture_formats[i]; + } + } + } + return renderer->texture_formats[0]; +} + +SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_PropertiesID props) +{ + SDL_Texture *texture; + SDL_PixelFormat format = (SDL_PixelFormat)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, SDL_PIXELFORMAT_UNKNOWN); + SDL_TextureAccess access = (SDL_TextureAccess)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, SDL_TEXTUREACCESS_STATIC); + int w = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, 0); + int h = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, 0); + SDL_Colorspace default_colorspace; + bool texture_is_fourcc_and_target; + + CHECK_RENDERER_MAGIC(renderer, NULL); + + if (!format) { + format = renderer->texture_formats[0]; + } + if (SDL_BYTESPERPIXEL(format) == 0) { + SDL_SetError("Invalid texture format"); + return NULL; + } + if (SDL_ISPIXELFORMAT_INDEXED(format)) { + if (!IsSupportedFormat(renderer, format)) { + SDL_SetError("Palettized textures are not supported"); + return NULL; + } + } + if (w <= 0 || h <= 0) { + SDL_SetError("Texture dimensions can't be 0"); + return NULL; + } + int max_texture_size = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 0); + if (max_texture_size && (w > max_texture_size || h > max_texture_size)) { + SDL_SetError("Texture dimensions are limited to %dx%d", max_texture_size, max_texture_size); + return NULL; + } + + default_colorspace = SDL_GetDefaultColorspaceForFormat(format); + + texture = (SDL_Texture *)SDL_calloc(1, sizeof(*texture)); + if (!texture) { + return NULL; + } + texture->refcount = 1; + SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, true); + texture->colorspace = (SDL_Colorspace)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, default_colorspace); + texture->format = format; + texture->access = access; + texture->w = w; + texture->h = h; + texture->color.r = 1.0f; + texture->color.g = 1.0f; + texture->color.b = 1.0f; + texture->color.a = 1.0f; + texture->blendMode = SDL_ISPIXELFORMAT_ALPHA(format) ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE; + texture->scaleMode = SDL_SCALEMODE_LINEAR; + texture->view.pixel_w = w; + texture->view.pixel_h = h; + texture->view.viewport.w = -1; + texture->view.viewport.h = -1; + texture->view.scale.x = 1.0f; + texture->view.scale.y = 1.0f; + texture->view.logical_scale.x = 1.0f; + texture->view.logical_scale.y = 1.0f; + texture->view.current_scale.x = 1.0f; + texture->view.current_scale.y = 1.0f; + texture->renderer = renderer; + texture->next = renderer->textures; + if (renderer->textures) { + renderer->textures->prev = texture; + } + renderer->textures = texture; + + UpdatePixelViewport(renderer, &texture->view); + UpdatePixelClipRect(renderer, &texture->view); + + texture->SDR_white_point = SDL_GetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT, SDL_GetDefaultSDRWhitePoint(texture->colorspace)); + texture->HDR_headroom = SDL_GetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT, SDL_GetDefaultHDRHeadroom(texture->colorspace)); + + // FOURCC format cannot be used directly by renderer back-ends for target texture + texture_is_fourcc_and_target = (access == SDL_TEXTUREACCESS_TARGET && SDL_ISPIXELFORMAT_FOURCC(format)); + + if (!texture_is_fourcc_and_target && IsSupportedFormat(renderer, format)) { + if (!renderer->CreateTexture(renderer, texture, props)) { + SDL_DestroyTexture(texture); + return NULL; + } + } else { + SDL_PixelFormat closest_format; + SDL_PropertiesID native_props = SDL_CreateProperties(); + + if (!texture_is_fourcc_and_target) { + closest_format = GetClosestSupportedFormat(renderer, format); + } else { + closest_format = renderer->texture_formats[0]; + } + + if (format == SDL_PIXELFORMAT_MJPG && closest_format == SDL_PIXELFORMAT_NV12) { + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, SDL_COLORSPACE_JPEG); + } else { + default_colorspace = SDL_GetDefaultColorspaceForFormat(closest_format); + if (SDL_COLORSPACETYPE(texture->colorspace) == SDL_COLORSPACETYPE(default_colorspace)) { + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, texture->colorspace); + } else { + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, default_colorspace); + } + } + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, closest_format); + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, texture->access); + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, texture->w); + SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, texture->h); + + texture->native = SDL_CreateTextureWithProperties(renderer, native_props); + SDL_DestroyProperties(native_props); + if (!texture->native) { + SDL_DestroyTexture(texture); + return NULL; + } + + SDL_SetPointerProperty(SDL_GetTextureProperties(texture->native), SDL_PROP_TEXTURE_PARENT_POINTER, texture); + + // Swap textures to have texture before texture->native in the list + texture->native->next = texture->next; + if (texture->native->next) { + texture->native->next->prev = texture->native; + } + texture->prev = texture->native->prev; + if (texture->prev) { + texture->prev->next = texture; + } + texture->native->prev = texture; + texture->next = texture->native; + renderer->textures = texture; + + if (texture->format == SDL_PIXELFORMAT_MJPG) { + // We have a custom decode + upload path for this + } else if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { +#ifdef SDL_HAVE_YUV + texture->yuv = SDL_SW_CreateYUVTexture(texture->format, texture->colorspace, w, h); +#else + SDL_SetError("SDL not built with YUV support"); +#endif + if (!texture->yuv) { + SDL_DestroyTexture(texture); + return NULL; + } + } else if (access == SDL_TEXTUREACCESS_STREAMING) { + // The pitch is 4 byte aligned + texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3); + texture->pixels = SDL_calloc(1, (size_t)texture->pitch * h); + if (!texture->pixels) { + SDL_DestroyTexture(texture); + return NULL; + } + } + } + + // Now set the properties for the new texture + props = SDL_GetTextureProperties(texture); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_COLORSPACE_NUMBER, texture->colorspace); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_FORMAT_NUMBER, texture->format); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, texture->access); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_WIDTH_NUMBER, texture->w); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_HEIGHT_NUMBER, texture->h); + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_SDR_WHITE_POINT_FLOAT, texture->SDR_white_point); + if (texture->HDR_headroom > 0.0f) { + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_HDR_HEADROOM_FLOAT, texture->HDR_headroom); + } + return texture; +} + +SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, SDL_PixelFormat format, SDL_TextureAccess access, int w, int h) +{ + SDL_Texture *texture; + SDL_PropertiesID props = SDL_CreateProperties(); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, format); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, access); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, w); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, h); + texture = SDL_CreateTextureWithProperties(renderer, props); + SDL_DestroyProperties(props); + return texture; +} + +static bool SDL_UpdateTextureFromSurface(SDL_Texture *texture, SDL_Rect *rect, SDL_Surface *surface) +{ + SDL_TextureAccess access; + bool direct_update; + SDL_PixelFormat tex_format; + SDL_PropertiesID surface_props; + SDL_PropertiesID tex_props; + SDL_Colorspace surface_colorspace = SDL_COLORSPACE_UNKNOWN; + SDL_Colorspace texture_colorspace = SDL_COLORSPACE_UNKNOWN; + + if (texture == NULL || surface == NULL) { + return false; + } + + tex_props = SDL_GetTextureProperties(texture); + if (!tex_props) { + return false; + } + + surface_props = SDL_GetSurfaceProperties(surface); + if (!surface_props) { + return false; + } + + tex_format = (SDL_PixelFormat)SDL_GetNumberProperty(tex_props, SDL_PROP_TEXTURE_FORMAT_NUMBER, 0); + access = (SDL_TextureAccess)SDL_GetNumberProperty(tex_props, SDL_PROP_TEXTURE_ACCESS_NUMBER, 0); + + if (access != SDL_TEXTUREACCESS_STATIC && access != SDL_TEXTUREACCESS_STREAMING) { + return false; + } + + surface_colorspace = SDL_GetSurfaceColorspace(surface); + texture_colorspace = surface_colorspace; + + if (surface_colorspace == SDL_COLORSPACE_SRGB_LINEAR || + SDL_COLORSPACETRANSFER(surface_colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) { + if (SDL_ISPIXELFORMAT_FLOAT(tex_format)) { + texture_colorspace = SDL_COLORSPACE_SRGB_LINEAR; + } else if (SDL_ISPIXELFORMAT_10BIT(tex_format)) { + texture_colorspace = SDL_COLORSPACE_HDR10; + } else { + texture_colorspace = SDL_COLORSPACE_SRGB; + } + } + + if (tex_format == surface->format && texture_colorspace == surface_colorspace) { + if (SDL_ISPIXELFORMAT_ALPHA(surface->format) && SDL_SurfaceHasColorKey(surface)) { + /* Surface and Renderer formats are identical. + * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */ + direct_update = false; + } else { + // Update Texture directly + direct_update = true; + } + } else { + // Surface and Renderer formats are different, it needs an intermediate conversion. + direct_update = false; + } + + if (direct_update) { + if (SDL_MUSTLOCK(surface)) { + SDL_LockSurface(surface); + SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch); + SDL_UnlockSurface(surface); + } else { + SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch); + } + } else { + SDL_Surface *temp = NULL; + + // Set up a destination surface for the texture update + temp = SDL_ConvertSurfaceAndColorspace(surface, tex_format, NULL, texture_colorspace, surface_props); + if (temp) { + SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch); + SDL_DestroySurface(temp); + } else { + return false; + } + } + + { + Uint8 r, g, b, a; + SDL_BlendMode blendMode; + + SDL_GetSurfaceColorMod(surface, &r, &g, &b); + SDL_SetTextureColorMod(texture, r, g, b); + + SDL_GetSurfaceAlphaMod(surface, &a); + SDL_SetTextureAlphaMod(texture, a); + + if (SDL_SurfaceHasColorKey(surface)) { + // We converted to a texture with alpha format + SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); + } else { + SDL_GetSurfaceBlendMode(surface, &blendMode); + SDL_SetTextureBlendMode(texture, blendMode); + } + } + + return true; +} + +SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface) +{ + bool needAlpha; + int i; + SDL_PixelFormat format = SDL_PIXELFORMAT_UNKNOWN; + SDL_Palette *palette; + SDL_Texture *texture; + SDL_PropertiesID props; + SDL_Colorspace surface_colorspace = SDL_COLORSPACE_UNKNOWN; + SDL_Colorspace texture_colorspace = SDL_COLORSPACE_UNKNOWN; + + CHECK_RENDERER_MAGIC(renderer, NULL); + + if (!SDL_SurfaceValid(surface)) { + SDL_InvalidParamError("SDL_CreateTextureFromSurface(): surface"); + return NULL; + } + + // See what the best texture format is + if (SDL_ISPIXELFORMAT_ALPHA(surface->format) || SDL_SurfaceHasColorKey(surface)) { + needAlpha = true; + } else { + needAlpha = false; + } + + // If Palette contains alpha values, promotes to alpha format + palette = SDL_GetSurfacePalette(surface); + if (palette) { + bool is_opaque, has_alpha_channel; + SDL_DetectPalette(palette, &is_opaque, &has_alpha_channel); + if (!is_opaque) { + needAlpha = true; + } + } + + surface_colorspace = SDL_GetSurfaceColorspace(surface); + + // Try to have the best pixel format for the texture + // No alpha, but a colorkey => promote to alpha + if (!SDL_ISPIXELFORMAT_ALPHA(surface->format) && SDL_SurfaceHasColorKey(surface)) { + if (surface->format == SDL_PIXELFORMAT_XRGB8888) { + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) { + format = SDL_PIXELFORMAT_ARGB8888; + break; + } + } + } else if (surface->format == SDL_PIXELFORMAT_XBGR8888) { + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ABGR8888) { + format = SDL_PIXELFORMAT_ABGR8888; + break; + } + } + } + } else { + // Exact match would be fine + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (renderer->texture_formats[i] == surface->format) { + format = surface->format; + break; + } + } + } + + // Look for 10-bit pixel formats if needed + if (format == SDL_PIXELFORMAT_UNKNOWN && SDL_ISPIXELFORMAT_10BIT(surface->format)) { + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) { + format = renderer->texture_formats[i]; + break; + } + } + } + + // Look for floating point pixel formats if needed + if (format == SDL_PIXELFORMAT_UNKNOWN && + (SDL_ISPIXELFORMAT_10BIT(surface->format) || SDL_ISPIXELFORMAT_FLOAT(surface->format))) { + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) { + format = renderer->texture_formats[i]; + break; + } + } + } + + // Fallback, choose a valid pixel format + if (format == SDL_PIXELFORMAT_UNKNOWN) { + format = renderer->texture_formats[0]; + for (i = 0; i < renderer->num_texture_formats; ++i) { + if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) && + SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == needAlpha) { + format = renderer->texture_formats[i]; + break; + } + } + } + + if (surface_colorspace == SDL_COLORSPACE_SRGB_LINEAR || + SDL_COLORSPACETRANSFER(surface_colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) { + if (SDL_ISPIXELFORMAT_FLOAT(format)) { + texture_colorspace = SDL_COLORSPACE_SRGB_LINEAR; + } else if (SDL_ISPIXELFORMAT_10BIT(format)) { + texture_colorspace = SDL_COLORSPACE_HDR10; + } else { + texture_colorspace = SDL_COLORSPACE_SRGB; + } + } + + props = SDL_CreateProperties(); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, texture_colorspace); + if (surface_colorspace == texture_colorspace) { + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT, + SDL_GetSurfaceSDRWhitePoint(surface, surface_colorspace)); + } + SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT, + SDL_GetSurfaceHDRHeadroom(surface, surface_colorspace)); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, format); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, SDL_TEXTUREACCESS_STATIC); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, surface->w); + SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, surface->h); + texture = SDL_CreateTextureWithProperties(renderer, props); + SDL_DestroyProperties(props); + if (!texture) { + return NULL; + } + + if (!SDL_UpdateTextureFromSurface(texture, NULL, surface)) { + SDL_DestroyTexture(texture); + return NULL; + } + + return texture; +} + +SDL_Renderer *SDL_GetRendererFromTexture(SDL_Texture *texture) +{ + CHECK_TEXTURE_MAGIC(texture, NULL); + + return texture->renderer; +} + +SDL_PropertiesID SDL_GetTextureProperties(SDL_Texture *texture) +{ + CHECK_TEXTURE_MAGIC(texture, 0); + + if (texture->props == 0) { + texture->props = SDL_CreateProperties(); + } + return texture->props; +} + +bool SDL_GetTextureSize(SDL_Texture *texture, float *w, float *h) +{ + if (w) { + *w = 0; + } + if (h) { + *h = 0; + } + + CHECK_TEXTURE_MAGIC(texture, false); + + if (w) { + *w = (float)texture->w; + } + if (h) { + *h = (float)texture->h; + } + return true; +} + +bool SDL_SetTextureColorMod(SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b) +{ + const float fR = (float)r / 255.0f; + const float fG = (float)g / 255.0f; + const float fB = (float)b / 255.0f; + + return SDL_SetTextureColorModFloat(texture, fR, fG, fB); +} + +bool SDL_SetTextureColorModFloat(SDL_Texture *texture, float r, float g, float b) +{ + CHECK_TEXTURE_MAGIC(texture, false); + + texture->color.r = r; + texture->color.g = g; + texture->color.b = b; + if (texture->native) { + return SDL_SetTextureColorModFloat(texture->native, r, g, b); + } + return true; +} + +bool SDL_GetTextureColorMod(SDL_Texture *texture, Uint8 *r, Uint8 *g, Uint8 *b) +{ + float fR = 1.0f, fG = 1.0f, fB = 1.0f; + + if (!SDL_GetTextureColorModFloat(texture, &fR, &fG, &fB)) { + if (r) { + *r = 255; + } + if (g) { + *g = 255; + } + if (b) { + *b = 255; + } + return false; + } + + if (r) { + *r = (Uint8)SDL_roundf(SDL_clamp(fR, 0.0f, 1.0f) * 255.0f); + } + if (g) { + *g = (Uint8)SDL_roundf(SDL_clamp(fG, 0.0f, 1.0f) * 255.0f); + } + if (b) { + *b = (Uint8)SDL_roundf(SDL_clamp(fB, 0.0f, 1.0f) * 255.0f); + } + return true; +} + +bool SDL_GetTextureColorModFloat(SDL_Texture *texture, float *r, float *g, float *b) +{ + SDL_FColor color; + + if (r) { + *r = 1.0f; + } + if (g) { + *g = 1.0f; + } + if (b) { + *b = 1.0f; + } + + CHECK_TEXTURE_MAGIC(texture, false); + + color = texture->color; + + if (r) { + *r = color.r; + } + if (g) { + *g = color.g; + } + if (b) { + *b = color.b; + } + return true; +} + +bool SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha) +{ + const float fA = (float)alpha / 255.0f; + + return SDL_SetTextureAlphaModFloat(texture, fA); +} + +bool SDL_SetTextureAlphaModFloat(SDL_Texture *texture, float alpha) +{ + CHECK_TEXTURE_MAGIC(texture, false); + + texture->color.a = alpha; + if (texture->native) { + return SDL_SetTextureAlphaModFloat(texture->native, alpha); + } + return true; +} + +bool SDL_GetTextureAlphaMod(SDL_Texture *texture, Uint8 *alpha) +{ + float fA = 1.0f; + + if (!SDL_GetTextureAlphaModFloat(texture, &fA)) { + if (alpha) { + *alpha = 255; + } + return false; + } + + if (alpha) { + *alpha = (Uint8)SDL_roundf(SDL_clamp(fA, 0.0f, 1.0f) * 255.0f); + } + return true; +} + +bool SDL_GetTextureAlphaModFloat(SDL_Texture *texture, float *alpha) +{ + if (alpha) { + *alpha = 1.0f; + } + + CHECK_TEXTURE_MAGIC(texture, false); + + if (alpha) { + *alpha = texture->color.a; + } + return true; +} + +bool SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode) +{ + SDL_Renderer *renderer; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (blendMode == SDL_BLENDMODE_INVALID) { + return SDL_InvalidParamError("blendMode"); + } + + renderer = texture->renderer; + if (!IsSupportedBlendMode(renderer, blendMode)) { + return SDL_Unsupported(); + } + texture->blendMode = blendMode; + if (texture->native) { + return SDL_SetTextureBlendMode(texture->native, blendMode); + } + return true; +} + +bool SDL_GetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode *blendMode) +{ + if (blendMode) { + *blendMode = SDL_BLENDMODE_INVALID; + } + + CHECK_TEXTURE_MAGIC(texture, false); + + if (blendMode) { + *blendMode = texture->blendMode; + } + return true; +} + +bool SDL_SetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode scaleMode) +{ + SDL_Renderer *renderer; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (scaleMode != SDL_SCALEMODE_NEAREST && + scaleMode != SDL_SCALEMODE_LINEAR) { + return SDL_InvalidParamError("scaleMode"); + } + + renderer = texture->renderer; + texture->scaleMode = scaleMode; + if (texture->native) { + return SDL_SetTextureScaleMode(texture->native, scaleMode); + } else { + renderer->SetTextureScaleMode(renderer, texture, scaleMode); + } + return true; +} + +bool SDL_GetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode *scaleMode) +{ + if (scaleMode) { + *scaleMode = SDL_SCALEMODE_LINEAR; + } + + CHECK_TEXTURE_MAGIC(texture, false); + + if (scaleMode) { + *scaleMode = texture->scaleMode; + } + return true; +} + +#ifdef SDL_HAVE_YUV +static bool SDL_UpdateTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, + const void *pixels, int pitch) +{ + SDL_Texture *native = texture->native; + SDL_Rect full_rect; + + if (!SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch)) { + return false; + } + + full_rect.x = 0; + full_rect.y = 0; + full_rect.w = texture->w; + full_rect.h = texture->h; + rect = &full_rect; + + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + // We can lock the texture and copy to it + void *native_pixels = NULL; + int native_pitch = 0; + + if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, native_pixels, native_pitch); + SDL_UnlockTexture(native); + } else { + // Use a temporary buffer for updating + const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3); + const size_t alloclen = (size_t)rect->h * temp_pitch; + if (alloclen > 0) { + void *temp_pixels = SDL_malloc(alloclen); + if (!temp_pixels) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, temp_pixels, temp_pitch); + SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch); + SDL_free(temp_pixels); + } + } + return true; +} +#endif // SDL_HAVE_YUV + +static bool SDL_UpdateTextureNative(SDL_Texture *texture, const SDL_Rect *rect, + const void *pixels, int pitch) +{ + SDL_Texture *native = texture->native; + + if (!rect->w || !rect->h) { + return true; // nothing to do. + } + + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + // We can lock the texture and copy to it + void *native_pixels = NULL; + int native_pitch = 0; + + if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) { + return false; + } + SDL_ConvertPixelsAndColorspace(rect->w, rect->h, + texture->format, texture->colorspace, 0, pixels, pitch, + native->format, native->colorspace, 0, native_pixels, native_pitch); + SDL_UnlockTexture(native); + } else { + // Use a temporary buffer for updating + const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3); + const size_t alloclen = (size_t)rect->h * temp_pitch; + if (alloclen > 0) { + void *temp_pixels = SDL_malloc(alloclen); + if (!temp_pixels) { + return false; + } + SDL_ConvertPixelsAndColorspace(rect->w, rect->h, + texture->format, texture->colorspace, 0, pixels, pitch, + native->format, native->colorspace, 0, temp_pixels, temp_pitch); + SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch); + SDL_free(temp_pixels); + } + } + return true; +} + +bool SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch) +{ + SDL_Rect real_rect; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (!pixels) { + return SDL_InvalidParamError("pixels"); + } + if (!pitch) { + return SDL_InvalidParamError("pitch"); + } + + real_rect.x = 0; + real_rect.y = 0; + real_rect.w = texture->w; + real_rect.h = texture->h; + if (rect) { + if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) { + return true; + } + } + + if (real_rect.w == 0 || real_rect.h == 0) { + return true; // nothing to do. +#ifdef SDL_HAVE_YUV + } else if (texture->yuv) { + return SDL_UpdateTextureYUV(texture, &real_rect, pixels, pitch); +#endif + } else if (texture->native) { + return SDL_UpdateTextureNative(texture, &real_rect, pixels, pitch); + } else { + SDL_Renderer *renderer = texture->renderer; + if (!FlushRenderCommandsIfTextureNeeded(texture)) { + return false; + } + return renderer->UpdateTexture(renderer, texture, &real_rect, pixels, pitch); + } +} + +#ifdef SDL_HAVE_YUV +static bool SDL_UpdateTextureYUVPlanar(SDL_Texture *texture, const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *Uplane, int Upitch, + const Uint8 *Vplane, int Vpitch) +{ + SDL_Texture *native = texture->native; + SDL_Rect full_rect; + + if (!SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch)) { + return false; + } + + full_rect.x = 0; + full_rect.y = 0; + full_rect.w = texture->w; + full_rect.h = texture->h; + rect = &full_rect; + + if (!rect->w || !rect->h) { + return true; // nothing to do. + } + + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + // We can lock the texture and copy to it + void *native_pixels = NULL; + int native_pitch = 0; + + if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, native_pixels, native_pitch); + SDL_UnlockTexture(native); + } else { + // Use a temporary buffer for updating + const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3); + const size_t alloclen = (size_t)rect->h * temp_pitch; + if (alloclen > 0) { + void *temp_pixels = SDL_malloc(alloclen); + if (!temp_pixels) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, temp_pixels, temp_pitch); + SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch); + SDL_free(temp_pixels); + } + } + return true; +} + +static bool SDL_UpdateTextureNVPlanar(SDL_Texture *texture, const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *UVplane, int UVpitch) +{ + SDL_Texture *native = texture->native; + SDL_Rect full_rect; + + if (!SDL_SW_UpdateNVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, UVplane, UVpitch)) { + return false; + } + + full_rect.x = 0; + full_rect.y = 0; + full_rect.w = texture->w; + full_rect.h = texture->h; + rect = &full_rect; + + if (!rect->w || !rect->h) { + return true; // nothing to do. + } + + if (texture->access == SDL_TEXTUREACCESS_STREAMING) { + // We can lock the texture and copy to it + void *native_pixels = NULL; + int native_pitch = 0; + + if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, native_pixels, native_pitch); + SDL_UnlockTexture(native); + } else { + // Use a temporary buffer for updating + const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3); + const size_t alloclen = (size_t)rect->h * temp_pitch; + if (alloclen > 0) { + void *temp_pixels = SDL_malloc(alloclen); + if (!temp_pixels) { + return false; + } + SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format, + rect->w, rect->h, temp_pixels, temp_pitch); + SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch); + SDL_free(temp_pixels); + } + } + return true; +} + +#endif // SDL_HAVE_YUV + +bool SDL_UpdateYUVTexture(SDL_Texture *texture, const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *Uplane, int Upitch, + const Uint8 *Vplane, int Vpitch) +{ +#ifdef SDL_HAVE_YUV + SDL_Renderer *renderer; + SDL_Rect real_rect; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (!Yplane) { + return SDL_InvalidParamError("Yplane"); + } + if (!Ypitch) { + return SDL_InvalidParamError("Ypitch"); + } + if (!Uplane) { + return SDL_InvalidParamError("Uplane"); + } + if (!Upitch) { + return SDL_InvalidParamError("Upitch"); + } + if (!Vplane) { + return SDL_InvalidParamError("Vplane"); + } + if (!Vpitch) { + return SDL_InvalidParamError("Vpitch"); + } + + if (texture->format != SDL_PIXELFORMAT_YV12 && + texture->format != SDL_PIXELFORMAT_IYUV) { + return SDL_SetError("Texture format must by YV12 or IYUV"); + } + + real_rect.x = 0; + real_rect.y = 0; + real_rect.w = texture->w; + real_rect.h = texture->h; + if (rect) { + SDL_GetRectIntersection(rect, &real_rect, &real_rect); + } + + if (real_rect.w == 0 || real_rect.h == 0) { + return true; // nothing to do. + } + + if (texture->yuv) { + return SDL_UpdateTextureYUVPlanar(texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + } else { + SDL_assert(!texture->native); + renderer = texture->renderer; + SDL_assert(renderer->UpdateTextureYUV); + if (renderer->UpdateTextureYUV) { + if (!FlushRenderCommandsIfTextureNeeded(texture)) { + return false; + } + return renderer->UpdateTextureYUV(renderer, texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + } else { + return SDL_Unsupported(); + } + } +#else + return false; +#endif +} + +bool SDL_UpdateNVTexture(SDL_Texture *texture, const SDL_Rect *rect, + const Uint8 *Yplane, int Ypitch, + const Uint8 *UVplane, int UVpitch) +{ +#ifdef SDL_HAVE_YUV + SDL_Renderer *renderer; + SDL_Rect real_rect; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (!Yplane) { + return SDL_InvalidParamError("Yplane"); + } + if (!Ypitch) { + return SDL_InvalidParamError("Ypitch"); + } + if (!UVplane) { + return SDL_InvalidParamError("UVplane"); + } + if (!UVpitch) { + return SDL_InvalidParamError("UVpitch"); + } + + if (texture->format != SDL_PIXELFORMAT_NV12 && + texture->format != SDL_PIXELFORMAT_NV21) { + return SDL_SetError("Texture format must by NV12 or NV21"); + } + + real_rect.x = 0; + real_rect.y = 0; + real_rect.w = texture->w; + real_rect.h = texture->h; + if (rect) { + SDL_GetRectIntersection(rect, &real_rect, &real_rect); + } + + if (real_rect.w == 0 || real_rect.h == 0) { + return true; // nothing to do. + } + + if (texture->yuv) { + return SDL_UpdateTextureNVPlanar(texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch); + } else { + SDL_assert(!texture->native); + renderer = texture->renderer; + SDL_assert(renderer->UpdateTextureNV); + if (renderer->UpdateTextureNV) { + if (!FlushRenderCommandsIfTextureNeeded(texture)) { + return false; + } + return renderer->UpdateTextureNV(renderer, texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch); + } else { + return SDL_Unsupported(); + } + } +#else + return false; +#endif +} + +#ifdef SDL_HAVE_YUV +static bool SDL_LockTextureYUV(SDL_Texture *texture, const SDL_Rect *rect, + void **pixels, int *pitch) +{ + return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch); +} +#endif // SDL_HAVE_YUV + +static bool SDL_LockTextureNative(SDL_Texture *texture, const SDL_Rect *rect, + void **pixels, int *pitch) +{ + texture->locked_rect = *rect; + *pixels = (void *)((Uint8 *)texture->pixels + + rect->y * texture->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format)); + *pitch = texture->pitch; + return true; +} + +bool SDL_LockTexture(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch) +{ + SDL_Rect full_rect; + + CHECK_TEXTURE_MAGIC(texture, false); + + if (texture->access != SDL_TEXTUREACCESS_STREAMING) { + return SDL_SetError("SDL_LockTexture(): texture must be streaming"); + } + + if (!rect) { + full_rect.x = 0; + full_rect.y = 0; + full_rect.w = texture->w; + full_rect.h = texture->h; + rect = &full_rect; + } + +#ifdef SDL_HAVE_YUV + if (texture->yuv) { + if (!FlushRenderCommandsIfTextureNeeded(texture)) { + return false; + } + return SDL_LockTextureYUV(texture, rect, pixels, pitch); + } else +#endif + if (texture->native) { + // Calls a real SDL_LockTexture/SDL_UnlockTexture on unlock, flushing then. + return SDL_LockTextureNative(texture, rect, pixels, pitch); + } else { + SDL_Renderer *renderer = texture->renderer; + if (!FlushRenderCommandsIfTextureNeeded(texture)) { + return false; + } + return renderer->LockTexture(renderer, texture, rect, pixels, pitch); + } +} + +bool SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect, SDL_Surface **surface) +{ + SDL_Rect real_rect; + void *pixels = NULL; + int pitch = 0; // fix static analysis + + if (!texture || !surface) { + return false; + } + + real_rect.x = 0; + real_rect.y = 0; + real_rect.w = texture->w; + real_rect.h = texture->h; + if (rect) { + SDL_GetRectIntersection(rect, &real_rect, &real_rect); + } + + if (!SDL_LockTexture(texture, &real_rect, &pixels, &pitch)) { + return false; + } + + texture->locked_surface = SDL_CreateSurfaceFrom(real_rect.w, real_rect.h, texture->format, pixels, pitch); + if (!texture->locked_surface) { + SDL_UnlockTexture(texture); + return false; + } + + *surface = texture->locked_surface; + return true; +} + +#ifdef SDL_HAVE_YUV +static void SDL_UnlockTextureYUV(SDL_Texture *texture) +{ + SDL_Texture *native = texture->native; + void *native_pixels = NULL; + int native_pitch = 0; + SDL_Rect rect; + + rect.x = 0; + rect.y = 0; + rect.w = texture->w; + rect.h = texture->h; + + if (!SDL_LockTexture(native, &rect, &native_pixels, &native_pitch)) { + return; + } + SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format, + rect.w, rect.h, native_pixels, native_pitch); + SDL_UnlockTexture(native); +} +#endif // SDL_HAVE_YUV + +static void SDL_UnlockTextureNative(SDL_Texture *texture) +{ + SDL_Texture *native = texture->native; + void *native_pixels = NULL; + int native_pitch = 0; + const SDL_Rect *rect = &texture->locked_rect; + const void *pixels = (void *)((Uint8 *)texture->pixels + + rect->y * texture->pitch + + rect->x * SDL_BYTESPERPIXEL(texture->format)); + int pitch = texture->pitch; + + if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) { + return; + } + SDL_ConvertPixels(rect->w, rect->h, + texture->format, pixels, pitch, + native->format, native_pixels, native_pitch); + SDL_UnlockTexture(native); +} + +void SDL_UnlockTexture(SDL_Texture *texture) +{ + CHECK_TEXTURE_MAGIC(texture,); + + if (texture->access != SDL_TEXTUREACCESS_STREAMING) { + return; + } +#ifdef SDL_HAVE_YUV + if (texture->yuv) { + SDL_UnlockTextureYUV(texture); + } else +#endif + if (texture->native) { + SDL_UnlockTextureNative(texture); + } else { + SDL_Renderer *renderer = texture->renderer; + renderer->UnlockTexture(renderer, texture); + } + + SDL_DestroySurface(texture->locked_surface); + texture->locked_surface = NULL; +} + +bool SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture) +{ + // texture == NULL is valid and means reset the target to the window + if (texture) { + CHECK_TEXTURE_MAGIC(texture, false); + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + if (texture->access != SDL_TEXTUREACCESS_TARGET) { + return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET"); + } + if (texture->native) { + // Always render to the native texture + texture = texture->native; + } + } + + if (texture == renderer->target) { + // Nothing to do! + return true; + } + + FlushRenderCommands(renderer); // time to send everything to the GPU! + + SDL_LockMutex(renderer->target_mutex); + + renderer->target = texture; + if (texture) { + renderer->view = &texture->view; + } else { + renderer->view = &renderer->main_view; + } + UpdateColorScale(renderer); + + if (!renderer->SetRenderTarget(renderer, texture)) { + SDL_UnlockMutex(renderer->target_mutex); + return false; + } + + SDL_UnlockMutex(renderer->target_mutex); + + if (!QueueCmdSetViewport(renderer)) { + return false; + } + if (!QueueCmdSetClipRect(renderer)) { + return false; + } + + // All set! + return true; +} + +SDL_Texture *SDL_GetRenderTarget(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + if (!renderer->target) { + return NULL; + } + return (SDL_Texture *) SDL_GetPointerProperty(SDL_GetTextureProperties(renderer->target), SDL_PROP_TEXTURE_PARENT_POINTER, renderer->target); +} + +static void UpdateLogicalPresentation(SDL_Renderer *renderer) +{ + SDL_RenderViewState *view = renderer->view; + const bool is_main_view = (view == &renderer->main_view); + const float logical_w = view->logical_w; + const float logical_h = view->logical_h; + int iwidth, iheight; + + if (renderer->target) { + iwidth = (int)renderer->target->w; + iheight = (int)renderer->target->h; + } else { + SDL_GetRenderOutputSize(renderer, &iwidth, &iheight); + } + + view->logical_src_rect.x = 0.0f; + view->logical_src_rect.y = 0.0f; + view->logical_src_rect.w = logical_w; + view->logical_src_rect.h = logical_h; + + if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_DISABLED) { + view->logical_dst_rect.x = 0.0f; + view->logical_dst_rect.y = 0.0f; + view->logical_dst_rect.w = iwidth; + view->logical_dst_rect.h = iheight; + view->logical_offset.x = view->logical_offset.y = 0.0f; + view->logical_scale.x = view->logical_scale.y = 1.0f; + view->current_scale.x = view->scale.x; // skip the multiplications against 1.0f. + view->current_scale.y = view->scale.y; + } else { + const float output_w = (float)iwidth; + const float output_h = (float)iheight; + const float want_aspect = logical_w / logical_h; + const float real_aspect = output_w / output_h; + + if ((logical_w <= 0.0f) || (logical_h <= 0.0f)) { + view->logical_dst_rect.x = 0.0f; + view->logical_dst_rect.y = 0.0f; + view->logical_dst_rect.w = output_w; + view->logical_dst_rect.h = output_h; + } else if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) { + float scale; + if (want_aspect > real_aspect) { + scale = (float)((int)output_w / (int)logical_w); // This an integer division! + } else { + scale = (float)((int)output_h / (int)logical_h); // This an integer division! + } + + if (scale < 1.0f) { + scale = 1.0f; + } + + view->logical_dst_rect.w = SDL_floorf(logical_w * scale); + view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f; + view->logical_dst_rect.h = SDL_floorf(logical_h * scale); + view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f; + + } else if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_STRETCH || SDL_fabsf(want_aspect - real_aspect) < 0.0001f) { + view->logical_dst_rect.x = 0.0f; + view->logical_dst_rect.y = 0.0f; + view->logical_dst_rect.w = output_w; + view->logical_dst_rect.h = output_h; + + } else if (want_aspect > real_aspect) { + if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) { + // We want a wider aspect ratio than is available - letterbox it + const float scale = output_w / logical_w; + view->logical_dst_rect.x = 0.0f; + view->logical_dst_rect.w = output_w; + view->logical_dst_rect.h = SDL_floorf(logical_h * scale); + view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f; + } else { // view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_OVERSCAN + /* We want a wider aspect ratio than is available - + zoom so logical height matches the real height + and the width will grow off the screen + */ + const float scale = output_h / logical_h; + view->logical_dst_rect.y = 0.0f; + view->logical_dst_rect.h = output_h; + view->logical_dst_rect.w = SDL_floorf(logical_w * scale); + view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f; + } + } else { + if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) { + // We want a narrower aspect ratio than is available - use side-bars + const float scale = output_h / logical_h; + view->logical_dst_rect.y = 0.0f; + view->logical_dst_rect.h = output_h; + view->logical_dst_rect.w = SDL_floorf(logical_w * scale); + view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f; + } else { // view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_OVERSCAN + /* We want a narrower aspect ratio than is available - + zoom so logical width matches the real width + and the height will grow off the screen + */ + const float scale = output_w / logical_w; + view->logical_dst_rect.x = 0.0f; + view->logical_dst_rect.w = output_w; + view->logical_dst_rect.h = SDL_floorf(logical_h * scale); + view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f; + } + } + + view->logical_scale.x = (logical_w > 0.0f) ? view->logical_dst_rect.w / logical_w : 0.0f; + view->logical_scale.y = (logical_h > 0.0f) ? view->logical_dst_rect.h / logical_h : 0.0f; + view->current_scale.x = view->scale.x * view->logical_scale.x; + view->current_scale.y = view->scale.y * view->logical_scale.y; + view->logical_offset.x = view->logical_dst_rect.x; + view->logical_offset.y = view->logical_dst_rect.y; + } + + if (is_main_view) { + // This makes sure the dpi_scale is right. It also sets pixel_w and pixel_h, but we're going to change them directly below here. + UpdateMainViewDimensions(renderer); + } + + view->pixel_w = (int) view->logical_dst_rect.w; + view->pixel_h = (int) view->logical_dst_rect.h; + UpdatePixelViewport(renderer, view); + UpdatePixelClipRect(renderer, view); +} + +bool SDL_SetRenderLogicalPresentation(SDL_Renderer *renderer, int w, int h, SDL_RendererLogicalPresentation mode) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + SDL_RenderViewState *view = renderer->view; + view->logical_presentation_mode = mode; + view->logical_w = w; + view->logical_h = h; + + UpdateLogicalPresentation(renderer); + + return true; +} + +bool SDL_GetRenderLogicalPresentation(SDL_Renderer *renderer, int *w, int *h, SDL_RendererLogicalPresentation *mode) +{ + #define SETVAL(ptr, val) if (ptr) { *ptr = val; } + + SETVAL(w, 0); + SETVAL(h, 0); + SETVAL(mode, SDL_LOGICAL_PRESENTATION_DISABLED); + + CHECK_RENDERER_MAGIC(renderer, false); + + const SDL_RenderViewState *view = renderer->view; + SETVAL(w, view->logical_w); + SETVAL(h, view->logical_h); + SETVAL(mode, view->logical_presentation_mode); + + #undef SETVAL + + return true; +} + +bool SDL_GetRenderLogicalPresentationRect(SDL_Renderer *renderer, SDL_FRect *rect) +{ + if (rect) { + SDL_zerop(rect); + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (rect) { + SDL_copyp(rect, &renderer->view->logical_dst_rect); + } + return true; +} + +static void SDL_RenderLogicalBorders(SDL_Renderer *renderer, const SDL_FRect *dst) +{ + const SDL_RenderViewState *view = renderer->view; + + if (dst->x > 0.0f || dst->y > 0.0f) { + SDL_BlendMode saved_blend_mode = renderer->blendMode; + SDL_FColor saved_color = renderer->color; + + SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE); + SDL_SetRenderDrawColorFloat(renderer, 0.0f, 0.0f, 0.0f, 1.0f); + + if (dst->x > 0.0f) { + SDL_FRect rect; + + rect.x = 0.0f; + rect.y = 0.0f; + rect.w = dst->x; + rect.h = (float)view->pixel_h; + SDL_RenderFillRect(renderer, &rect); + + rect.x = dst->x + dst->w; + rect.w = (float)view->pixel_w - rect.x; + SDL_RenderFillRect(renderer, &rect); + } + + if (dst->y > 0.0f) { + SDL_FRect rect; + + rect.x = 0.0f; + rect.y = 0.0f; + rect.w = (float)view->pixel_w; + rect.h = dst->y; + SDL_RenderFillRect(renderer, &rect); + + rect.y = dst->y + dst->h; + rect.h = (float)view->pixel_h - rect.y; + SDL_RenderFillRect(renderer, &rect); + } + + SDL_SetRenderDrawBlendMode(renderer, saved_blend_mode); + SDL_SetRenderDrawColorFloat(renderer, saved_color.r, saved_color.g, saved_color.b, saved_color.a); + } +} + +static void SDL_RenderLogicalPresentation(SDL_Renderer *renderer) +{ + SDL_assert(renderer->view == &renderer->main_view); + + SDL_RenderViewState *view = &renderer->main_view; + const SDL_RendererLogicalPresentation mode = view->logical_presentation_mode; + if (mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) { + // save off some state we're going to trample. + const int logical_w = view->logical_w; + const int logical_h = view->logical_h; + const float scale_x = view->scale.x; + const float scale_y = view->scale.y; + const bool clipping_enabled = view->clipping_enabled; + SDL_Rect orig_viewport, orig_cliprect; + const SDL_FRect logical_dst_rect = view->logical_dst_rect; + + SDL_copyp(&orig_viewport, &view->viewport); + if (clipping_enabled) { + SDL_copyp(&orig_cliprect, &view->clip_rect); + } + + // trample some state. + SDL_SetRenderLogicalPresentation(renderer, logical_w, logical_h, SDL_LOGICAL_PRESENTATION_DISABLED); + SDL_SetRenderViewport(renderer, NULL); + if (clipping_enabled) { + SDL_SetRenderClipRect(renderer, NULL); + } + SDL_SetRenderScale(renderer, 1.0f, 1.0f); + + // draw the borders. + SDL_RenderLogicalBorders(renderer, &logical_dst_rect); + + // now set everything back. + view->logical_presentation_mode = mode; + SDL_SetRenderViewport(renderer, &orig_viewport); + if (clipping_enabled) { + SDL_SetRenderClipRect(renderer, &orig_cliprect); + } + SDL_SetRenderScale(renderer, scale_x, scale_y); + + SDL_SetRenderLogicalPresentation(renderer, logical_w, logical_h, mode); + } +} + +static bool SDL_RenderVectorFromWindow(SDL_Renderer *renderer, float window_dx, float window_dy, float *dx, float *dy) +{ + // Convert from window coordinates to pixels within the window + window_dx *= renderer->dpi_scale.x; + window_dy *= renderer->dpi_scale.y; + + // Convert from pixels within the window to pixels within the view + const SDL_RenderViewState *view = &renderer->main_view; + if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) { + const SDL_FRect *src = &view->logical_src_rect; + const SDL_FRect *dst = &view->logical_dst_rect; + window_dx = (window_dx * src->w) / dst->w; + window_dy = (window_dy * src->h) / dst->h; + } + + window_dx /= view->scale.x; + window_dy /= view->scale.y; + + *dx = window_dx; + *dy = window_dy; + return true; +} + +bool SDL_RenderCoordinatesFromWindow(SDL_Renderer *renderer, float window_x, float window_y, float *x, float *y) +{ + float render_x, render_y; + + CHECK_RENDERER_MAGIC(renderer, false); + + // Convert from window coordinates to pixels within the window + render_x = window_x * renderer->dpi_scale.x; + render_y = window_y * renderer->dpi_scale.y; + + // Convert from pixels within the window to pixels within the view + const SDL_RenderViewState *view = &renderer->main_view; + if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) { + const SDL_FRect *src = &view->logical_src_rect; + const SDL_FRect *dst = &view->logical_dst_rect; + render_x = ((render_x - dst->x) * src->w) / dst->w; + render_y = ((render_y - dst->y) * src->h) / dst->h; + } + + render_x = (render_x / view->scale.x) - view->viewport.x; + render_y = (render_y / view->scale.y) - view->viewport.y; + + if (x) { + *x = render_x; + } + if (y) { + *y = render_y; + } + return true; +} + +bool SDL_RenderCoordinatesToWindow(SDL_Renderer *renderer, float x, float y, float *window_x, float *window_y) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + const SDL_RenderViewState *view = &renderer->main_view; + x = (view->viewport.x + x) * view->scale.x; + y = (view->viewport.y + y) * view->scale.y; + + // Convert from render coordinates to pixels within the window + if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) { + const SDL_FRect *src = &view->logical_src_rect; + const SDL_FRect *dst = &view->logical_dst_rect; + x = dst->x + ((x * dst->w) / src->w); + y = dst->y + ((y * dst->h) / src->h); + } + + // Convert from pixels within the window to window coordinates + x /= renderer->dpi_scale.x; + y /= renderer->dpi_scale.y; + + if (window_x) { + *window_x = x; + } + if (window_y) { + *window_y = y; + } + return true; +} + +bool SDL_ConvertEventToRenderCoordinates(SDL_Renderer *renderer, SDL_Event *event) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + if (event->type == SDL_EVENT_MOUSE_MOTION) { + SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->motion.x, event->motion.y, &event->motion.x, &event->motion.y); + SDL_RenderVectorFromWindow(renderer, event->motion.xrel, event->motion.yrel, &event->motion.xrel, &event->motion.yrel); + } + } else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN || + event->type == SDL_EVENT_MOUSE_BUTTON_UP) { + SDL_Window *window = SDL_GetWindowFromID(event->button.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->button.x, event->button.y, &event->button.x, &event->button.y); + } + } else if (event->type == SDL_EVENT_MOUSE_WHEEL) { + SDL_Window *window = SDL_GetWindowFromID(event->wheel.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->wheel.mouse_x, + event->wheel.mouse_y, + &event->wheel.mouse_x, + &event->wheel.mouse_y); + } + } else if (event->type == SDL_EVENT_FINGER_DOWN || + event->type == SDL_EVENT_FINGER_UP || + event->type == SDL_EVENT_FINGER_CANCELED || + event->type == SDL_EVENT_FINGER_MOTION) { + // FIXME: Are these events guaranteed to be window relative? + if (renderer->window) { + int w, h; + if (!SDL_GetWindowSize(renderer->window, &w, &h)) { + return false; + } + SDL_RenderCoordinatesFromWindow(renderer, event->tfinger.x * w, event->tfinger.y * h, &event->tfinger.x, &event->tfinger.y); + SDL_RenderVectorFromWindow(renderer, event->tfinger.dx * w, event->tfinger.dy * h, &event->tfinger.dx, &event->tfinger.dy); + } + } else if (event->type == SDL_EVENT_PEN_MOTION) { + SDL_Window *window = SDL_GetWindowFromID(event->pmotion.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->pmotion.x, event->pmotion.y, &event->pmotion.x, &event->pmotion.y); + } + } else if ((event->type == SDL_EVENT_PEN_DOWN) || (event->type == SDL_EVENT_PEN_UP)) { + SDL_Window *window = SDL_GetWindowFromID(event->ptouch.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->ptouch.x, event->ptouch.y, &event->ptouch.x, &event->ptouch.y); + } + } else if ((event->type == SDL_EVENT_PEN_BUTTON_DOWN) || (event->type == SDL_EVENT_PEN_BUTTON_UP)) { + SDL_Window *window = SDL_GetWindowFromID(event->pbutton.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->pbutton.x, event->pbutton.y, &event->pbutton.x, &event->pbutton.y); + } + } else if (event->type == SDL_EVENT_PEN_AXIS) { + SDL_Window *window = SDL_GetWindowFromID(event->paxis.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->paxis.x, event->paxis.y, &event->paxis.x, &event->paxis.y); + } + } else if (event->type == SDL_EVENT_DROP_POSITION || + event->type == SDL_EVENT_DROP_FILE || + event->type == SDL_EVENT_DROP_TEXT || + event->type == SDL_EVENT_DROP_COMPLETE) { + SDL_Window *window = SDL_GetWindowFromID(event->drop.windowID); + if (window == renderer->window) { + SDL_RenderCoordinatesFromWindow(renderer, event->drop.x, event->drop.y, &event->drop.x, &event->drop.y); + } + } + return true; +} + +bool SDL_SetRenderViewport(SDL_Renderer *renderer, const SDL_Rect *rect) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + SDL_RenderViewState *view = renderer->view; + if (rect) { + if ((rect->w < 0) || (rect->h < 0)) { + return SDL_SetError("rect has a negative size"); + } + SDL_copyp(&view->viewport, rect); + } else { + view->viewport.x = view->viewport.y = 0; + view->viewport.w = view->viewport.h = -1; + } + UpdatePixelViewport(renderer, view); + + return QueueCmdSetViewport(renderer); +} + +bool SDL_GetRenderViewport(SDL_Renderer *renderer, SDL_Rect *rect) +{ + if (rect) { + SDL_zerop(rect); + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (rect) { + const SDL_RenderViewState *view = renderer->view; + rect->x = view->viewport.x; + rect->y = view->viewport.y; + if (view->viewport.w >= 0) { + rect->w = view->viewport.w; + } else { + rect->w = (int)SDL_ceilf(view->pixel_w / view->current_scale.x); + } + if (view->viewport.h >= 0) { + rect->h = view->viewport.h; + } else { + rect->h = (int)SDL_ceilf(view->pixel_h / view->current_scale.y); + } + } + return true; +} + +bool SDL_RenderViewportSet(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + const SDL_RenderViewState *view = renderer->view; + return (view->viewport.w >= 0 && view->viewport.h >= 0); +} + +static void GetRenderViewportSize(SDL_Renderer *renderer, SDL_FRect *rect) +{ + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + + rect->x = 0.0f; + rect->y = 0.0f; + + if (view->viewport.w >= 0) { + rect->w = (float)view->viewport.w; + } else { + rect->w = view->pixel_w / scale_x; + } + + if (view->viewport.h >= 0) { + rect->h = (float)view->viewport.h; + } else { + rect->h = view->pixel_h / scale_y; + } +} + +bool SDL_GetRenderSafeArea(SDL_Renderer *renderer, SDL_Rect *rect) +{ + if (rect) { + SDL_zerop(rect); + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (renderer->target || !renderer->window) { + // The entire viewport is safe for rendering + return SDL_GetRenderViewport(renderer, rect); + } + + if (rect) { + // Get the window safe rect + SDL_Rect safe; + if (!SDL_GetWindowSafeArea(renderer->window, &safe)) { + return false; + } + + // Convert the coordinates into the render space + float minx = (float)safe.x; + float miny = (float)safe.y; + float maxx = (float)safe.x + safe.w; + float maxy = (float)safe.y + safe.h; + if (!SDL_RenderCoordinatesFromWindow(renderer, minx, miny, &minx, &miny) || + !SDL_RenderCoordinatesFromWindow(renderer, maxx, maxy, &maxx, &maxy)) { + return false; + } + + rect->x = (int)SDL_ceilf(minx); + rect->y = (int)SDL_ceilf(miny); + rect->w = (int)SDL_ceilf(maxx - minx); + rect->h = (int)SDL_ceilf(maxy - miny); + + // Clip with the viewport + SDL_Rect viewport; + if (!SDL_GetRenderViewport(renderer, &viewport)) { + return false; + } + if (!SDL_GetRectIntersection(rect, &viewport, rect)) { + return SDL_SetError("No safe area within viewport"); + } + } + return true; +} + +bool SDL_SetRenderClipRect(SDL_Renderer *renderer, const SDL_Rect *rect) +{ + CHECK_RENDERER_MAGIC(renderer, false) + + SDL_RenderViewState *view = renderer->view; + if (rect && rect->w >= 0 && rect->h >= 0) { + view->clipping_enabled = true; + SDL_copyp(&view->clip_rect, rect); + } else { + view->clipping_enabled = false; + SDL_zero(view->clip_rect); + } + UpdatePixelClipRect(renderer, view); + + return QueueCmdSetClipRect(renderer); +} + +bool SDL_GetRenderClipRect(SDL_Renderer *renderer, SDL_Rect *rect) +{ + if (rect) { + SDL_zerop(rect); + } + + CHECK_RENDERER_MAGIC(renderer, false) + + if (rect) { + SDL_copyp(rect, &renderer->view->clip_rect); + } + return true; +} + +bool SDL_RenderClipEnabled(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, false) + return renderer->view->clipping_enabled; +} + +bool SDL_SetRenderScale(SDL_Renderer *renderer, float scaleX, float scaleY) +{ + bool result = true; + + CHECK_RENDERER_MAGIC(renderer, false); + + SDL_RenderViewState *view = renderer->view; + + if ((view->scale.x == scaleX) && (view->scale.y == scaleY)) { + return true; + } + + view->scale.x = scaleX; + view->scale.y = scaleY; + view->current_scale.x = scaleX * view->logical_scale.x; + view->current_scale.y = scaleY * view->logical_scale.y; + UpdatePixelViewport(renderer, view); + UpdatePixelClipRect(renderer, view); + + // The scale affects the existing viewport and clip rectangle + result &= QueueCmdSetViewport(renderer); + result &= QueueCmdSetClipRect(renderer); + return result; +} + +bool SDL_GetRenderScale(SDL_Renderer *renderer, float *scaleX, float *scaleY) +{ + if (scaleX) { + *scaleX = 1.0f; + } + if (scaleY) { + *scaleY = 1.0f; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + const SDL_RenderViewState *view = renderer->view; + + if (scaleX) { + *scaleX = view->scale.x; + } + if (scaleY) { + *scaleY = view->scale.y; + } + return true; +} + +bool SDL_SetRenderDrawColor(SDL_Renderer *renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a) +{ + const float fR = (float)r / 255.0f; + const float fG = (float)g / 255.0f; + const float fB = (float)b / 255.0f; + const float fA = (float)a / 255.0f; + + return SDL_SetRenderDrawColorFloat(renderer, fR, fG, fB, fA); +} + +bool SDL_SetRenderDrawColorFloat(SDL_Renderer *renderer, float r, float g, float b, float a) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + renderer->color.r = r; + renderer->color.g = g; + renderer->color.b = b; + renderer->color.a = a; + return true; +} + +bool SDL_GetRenderDrawColor(SDL_Renderer *renderer, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a) +{ + float fR, fG, fB, fA; + + if (!SDL_GetRenderDrawColorFloat(renderer, &fR, &fG, &fB, &fA)) { + if (r) { + *r = 0; + } + if (g) { + *g = 0; + } + if (b) { + *b = 0; + } + if (a) { + *a = 0; + } + return false; + } + + if (r) { + *r = (Uint8)(fR * 255.0f); + } + if (g) { + *g = (Uint8)(fG * 255.0f); + } + if (b) { + *b = (Uint8)(fB * 255.0f); + } + if (a) { + *a = (Uint8)(fA * 255.0f); + } + return true; +} + +bool SDL_GetRenderDrawColorFloat(SDL_Renderer *renderer, float *r, float *g, float *b, float *a) +{ + SDL_FColor color; + + if (r) { + *r = 0.0f; + } + if (g) { + *g = 0.0f; + } + if (b) { + *b = 0.0f; + } + if (a) { + *a = 0.0f; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + color = renderer->color; + + if (r) { + *r = color.r; + } + if (g) { + *g = color.g; + } + if (b) { + *b = color.b; + } + if (a) { + *a = color.a; + } + return true; +} + +bool SDL_SetRenderColorScale(SDL_Renderer *renderer, float scale) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + renderer->desired_color_scale = scale; + UpdateColorScale(renderer); + return true; +} + +bool SDL_GetRenderColorScale(SDL_Renderer *renderer, float *scale) +{ + if (scale) { + *scale = 1.0f; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (scale) { + *scale = renderer->desired_color_scale; + } + return true; +} + +bool SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + if (blendMode == SDL_BLENDMODE_INVALID) { + return SDL_InvalidParamError("blendMode"); + } + + if (blendMode == SDL_BLENDMODE_INVALID) { + return SDL_InvalidParamError("blendMode"); + } + + if (!IsSupportedBlendMode(renderer, blendMode)) { + return SDL_Unsupported(); + } + + renderer->blendMode = blendMode; + return true; +} + +bool SDL_GetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode *blendMode) +{ + if (blendMode) { + *blendMode = SDL_BLENDMODE_INVALID; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (blendMode) { + *blendMode = renderer->blendMode; + } + return true; +} + +bool SDL_RenderClear(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + return QueueCmdClear(renderer); +} + +bool SDL_RenderPoint(SDL_Renderer *renderer, float x, float y) +{ + SDL_FPoint fpoint; + fpoint.x = x; + fpoint.y = y; + return SDL_RenderPoints(renderer, &fpoint, 1); +} + +static bool RenderPointsWithRects(SDL_Renderer *renderer, const SDL_FPoint *fpoints, const int count) +{ + bool result; + bool isstack; + SDL_FRect *frects; + int i; + + if (count < 1) { + return true; + } + + frects = SDL_small_alloc(SDL_FRect, count, &isstack); + if (!frects) { + return false; + } + + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + for (i = 0; i < count; ++i) { + frects[i].x = fpoints[i].x * scale_x; + frects[i].y = fpoints[i].y * scale_y; + frects[i].w = scale_x; + frects[i].h = scale_y; + } + + result = QueueCmdFillRects(renderer, frects, count); + + SDL_small_free(frects, isstack); + + return result; +} + +bool SDL_RenderPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count) +{ + bool result; + + CHECK_RENDERER_MAGIC(renderer, false); + + if (!points) { + return SDL_InvalidParamError("SDL_RenderPoints(): points"); + } + if (count < 1) { + return true; + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + const SDL_RenderViewState *view = renderer->view; + if ((view->current_scale.x != 1.0f) || (view->current_scale.y != 1.0f)) { + result = RenderPointsWithRects(renderer, points, count); + } else { + result = QueueCmdDrawPoints(renderer, points, count); + } + return result; +} + +bool SDL_RenderLine(SDL_Renderer *renderer, float x1, float y1, float x2, float y2) +{ + SDL_FPoint points[2]; + points[0].x = x1; + points[0].y = y1; + points[1].x = x2; + points[1].y = y2; + return SDL_RenderLines(renderer, points, 2); +} + +static bool RenderLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, int y2, bool draw_last) +{ + const SDL_RenderViewState *view = renderer->view; + const int MAX_PIXELS = SDL_max(view->pixel_w, view->pixel_h) * 4; + int i, deltax, deltay, numpixels; + int d, dinc1, dinc2; + int x, xinc1, xinc2; + int y, yinc1, yinc2; + bool result; + bool isstack; + SDL_FPoint *points; + SDL_Rect viewport; + + /* the backend might clip this further to the clipping rect, but we + just want a basic safety against generating millions of points for + massive lines. */ + viewport = view->pixel_viewport; + viewport.x = 0; + viewport.y = 0; + if (!SDL_GetRectAndLineIntersection(&viewport, &x1, &y1, &x2, &y2)) { + return true; + } + + deltax = SDL_abs(x2 - x1); + deltay = SDL_abs(y2 - y1); + + if (deltax >= deltay) { + numpixels = deltax + 1; + d = (2 * deltay) - deltax; + dinc1 = deltay * 2; + dinc2 = (deltay - deltax) * 2; + xinc1 = 1; + xinc2 = 1; + yinc1 = 0; + yinc2 = 1; + } else { + numpixels = deltay + 1; + d = (2 * deltax) - deltay; + dinc1 = deltax * 2; + dinc2 = (deltax - deltay) * 2; + xinc1 = 0; + xinc2 = 1; + yinc1 = 1; + yinc2 = 1; + } + + if (x1 > x2) { + xinc1 = -xinc1; + xinc2 = -xinc2; + } + if (y1 > y2) { + yinc1 = -yinc1; + yinc2 = -yinc2; + } + + x = x1; + y = y1; + + if (!draw_last) { + --numpixels; + } + + if (numpixels > MAX_PIXELS) { + return SDL_SetError("Line too long (tried to draw %d pixels, max %d)", numpixels, MAX_PIXELS); + } + + points = SDL_small_alloc(SDL_FPoint, numpixels, &isstack); + if (!points) { + return false; + } + for (i = 0; i < numpixels; ++i) { + points[i].x = (float)x; + points[i].y = (float)y; + + if (d < 0) { + d += dinc1; + x += xinc1; + y += yinc1; + } else { + d += dinc2; + x += xinc2; + y += yinc2; + } + } + + if ((view->current_scale.x != 1.0f) || (view->current_scale.y != 1.0f)) { + result = RenderPointsWithRects(renderer, points, numpixels); + } else { + result = QueueCmdDrawPoints(renderer, points, numpixels); + } + + SDL_small_free(points, isstack); + + return result; +} + +static bool RenderLinesWithRectsF(SDL_Renderer *renderer, const SDL_FPoint *points, const int count) +{ + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + SDL_FRect *frect; + SDL_FRect *frects; + int i, nrects = 0; + bool result = true; + bool isstack; + bool drew_line = false; + bool draw_last = false; + + frects = SDL_small_alloc(SDL_FRect, count - 1, &isstack); + if (!frects) { + return false; + } + + for (i = 0; i < count - 1; ++i) { + bool same_x = (points[i].x == points[i + 1].x); + bool same_y = (points[i].y == points[i + 1].y); + + if (i == (count - 2)) { + if (!drew_line || points[i + 1].x != points[0].x || points[i + 1].y != points[0].y) { + draw_last = true; + } + } else { + if (same_x && same_y) { + continue; + } + } + if (same_x) { + const float minY = SDL_min(points[i].y, points[i + 1].y); + const float maxY = SDL_max(points[i].y, points[i + 1].y); + + frect = &frects[nrects++]; + frect->x = points[i].x * scale_x; + frect->y = minY * scale_y; + frect->w = scale_x; + frect->h = (maxY - minY + draw_last) * scale_y; + if (!draw_last && points[i + 1].y < points[i].y) { + frect->y += scale_y; + } + } else if (same_y) { + const float minX = SDL_min(points[i].x, points[i + 1].x); + const float maxX = SDL_max(points[i].x, points[i + 1].x); + + frect = &frects[nrects++]; + frect->x = minX * scale_x; + frect->y = points[i].y * scale_y; + frect->w = (maxX - minX + draw_last) * scale_x; + frect->h = scale_y; + if (!draw_last && points[i + 1].x < points[i].x) { + frect->x += scale_x; + } + } else { + result &= RenderLineBresenham(renderer, (int)SDL_roundf(points[i].x), (int)SDL_roundf(points[i].y), + (int)SDL_roundf(points[i + 1].x), (int)SDL_roundf(points[i + 1].y), draw_last); + } + drew_line = true; + } + + if (nrects) { + result &= QueueCmdFillRects(renderer, frects, nrects); + } + + SDL_small_free(frects, isstack); + + return result; +} + +bool SDL_RenderLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count) +{ + bool result = true; + + CHECK_RENDERER_MAGIC(renderer, false); + + if (!points) { + return SDL_InvalidParamError("SDL_RenderLines(): points"); + } + if (count < 2) { + return true; + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + SDL_RenderViewState *view = renderer->view; + const bool islogical = ((view == &renderer->main_view) && (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED)); + + if (islogical || (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY)) { + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + bool isstack1; + bool isstack2; + float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1); + int *indices = SDL_small_alloc(int, (4) * 3 * (count - 1) + (2) * 3 * (count), &isstack2); + + if (xy && indices) { + int i; + float *ptr_xy = xy; + int *ptr_indices = indices; + const int xy_stride = 2 * sizeof(float); + int num_vertices = 4 * count; + int num_indices = 0; + const int size_indices = 4; + int cur_index = -4; + const int is_looping = (points[0].x == points[count - 1].x && points[0].y == points[count - 1].y); + SDL_FPoint p; // previous point + p.x = p.y = 0.0f; + /* p q + + 0----1------ 4----5 + | \ |``\ | \ | + | \ | ` `\| \ | + 3----2-------7----6 + */ + for (i = 0; i < count; ++i) { + SDL_FPoint q = points[i]; // current point + + q.x *= scale_x; + q.y *= scale_y; + + *ptr_xy++ = q.x; + *ptr_xy++ = q.y; + *ptr_xy++ = q.x + scale_x; + *ptr_xy++ = q.y; + *ptr_xy++ = q.x + scale_x; + *ptr_xy++ = q.y + scale_y; + *ptr_xy++ = q.x; + *ptr_xy++ = q.y + scale_y; + +#define ADD_TRIANGLE(i1, i2, i3) \ + *ptr_indices++ = cur_index + (i1); \ + *ptr_indices++ = cur_index + (i2); \ + *ptr_indices++ = cur_index + (i3); \ + num_indices += 3; + + // closed polyline, don´t draw twice the point + if (i || is_looping == 0) { + ADD_TRIANGLE(4, 5, 6) + ADD_TRIANGLE(4, 6, 7) + } + + // first point only, no segment + if (i == 0) { + p = q; + cur_index += 4; + continue; + } + + // draw segment + if (p.y == q.y) { + if (p.x < q.x) { + ADD_TRIANGLE(1, 4, 7) + ADD_TRIANGLE(1, 7, 2) + } else { + ADD_TRIANGLE(5, 0, 3) + ADD_TRIANGLE(5, 3, 6) + } + } else if (p.x == q.x) { + if (p.y < q.y) { + ADD_TRIANGLE(2, 5, 4) + ADD_TRIANGLE(2, 4, 3) + } else { + ADD_TRIANGLE(6, 1, 0) + ADD_TRIANGLE(6, 0, 7) + } + } else { + if (p.y < q.y) { + if (p.x < q.x) { + ADD_TRIANGLE(1, 5, 4) + ADD_TRIANGLE(1, 4, 2) + ADD_TRIANGLE(2, 4, 7) + ADD_TRIANGLE(2, 7, 3) + } else { + ADD_TRIANGLE(4, 0, 5) + ADD_TRIANGLE(5, 0, 3) + ADD_TRIANGLE(5, 3, 6) + ADD_TRIANGLE(6, 3, 2) + } + } else { + if (p.x < q.x) { + ADD_TRIANGLE(0, 4, 7) + ADD_TRIANGLE(0, 7, 1) + ADD_TRIANGLE(1, 7, 6) + ADD_TRIANGLE(1, 6, 2) + } else { + ADD_TRIANGLE(6, 5, 1) + ADD_TRIANGLE(6, 1, 0) + ADD_TRIANGLE(7, 6, 0) + ADD_TRIANGLE(7, 0, 3) + } + } + } + + p = q; + cur_index += 4; + } + + result = QueueCmdGeometry(renderer, NULL, + xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0, + num_vertices, indices, num_indices, size_indices, + 1.0f, 1.0f, SDL_TEXTURE_ADDRESS_CLAMP); + } + + SDL_small_free(xy, isstack1); + SDL_small_free(indices, isstack2); + + } else if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) { + result = RenderLinesWithRectsF(renderer, points, count); + } else if (view->scale.x != 1.0f || view->scale.y != 1.0f) { /* we checked for logical scale elsewhere. */ + result = RenderLinesWithRectsF(renderer, points, count); + } else { + result = QueueCmdDrawLines(renderer, points, count); + } + + return result; +} + +bool SDL_RenderRect(SDL_Renderer *renderer, const SDL_FRect *rect) +{ + SDL_FRect frect; + SDL_FPoint points[5]; + + CHECK_RENDERER_MAGIC(renderer, false); + + // If 'rect' == NULL, then outline the whole surface + if (!rect) { + GetRenderViewportSize(renderer, &frect); + rect = &frect; + } + + points[0].x = rect->x; + points[0].y = rect->y; + points[1].x = rect->x + rect->w - 1; + points[1].y = rect->y; + points[2].x = rect->x + rect->w - 1; + points[2].y = rect->y + rect->h - 1; + points[3].x = rect->x; + points[3].y = rect->y + rect->h - 1; + points[4].x = rect->x; + points[4].y = rect->y; + return SDL_RenderLines(renderer, points, 5); +} + +bool SDL_RenderRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count) +{ + int i; + + CHECK_RENDERER_MAGIC(renderer, false); + + if (!rects) { + return SDL_InvalidParamError("SDL_RenderRects(): rects"); + } + if (count < 1) { + return true; + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + for (i = 0; i < count; ++i) { + if (!SDL_RenderRect(renderer, &rects[i])) { + return false; + } + } + return true; +} + +bool SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_FRect *rect) +{ + SDL_FRect frect; + + CHECK_RENDERER_MAGIC(renderer, false); + + // If 'rect' == NULL, then fill the whole surface + if (!rect) { + GetRenderViewportSize(renderer, &frect); + rect = &frect; + } + return SDL_RenderFillRects(renderer, rect, 1); +} + +bool SDL_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count) +{ + SDL_FRect *frects; + int i; + bool result; + bool isstack; + + CHECK_RENDERER_MAGIC(renderer, false); + + if (!rects) { + return SDL_InvalidParamError("SDL_RenderFillRects(): rects"); + } + if (count < 1) { + return true; + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + frects = SDL_small_alloc(SDL_FRect, count, &isstack); + if (!frects) { + return false; + } + + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + for (i = 0; i < count; ++i) { + frects[i].x = rects[i].x * scale_x; + frects[i].y = rects[i].y * scale_y; + frects[i].w = rects[i].w * scale_x; + frects[i].h = rects[i].h * scale_y; + } + + result = QueueCmdFillRects(renderer, frects, count); + + SDL_small_free(frects, isstack); + + return result; +} + +static bool SDL_RenderTextureInternal(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect) +{ + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + const bool use_rendergeometry = (!renderer->QueueCopy); + bool result; + + if (use_rendergeometry) { + float xy[8]; + const int xy_stride = 2 * sizeof(float); + float uv[8]; + const int uv_stride = 2 * sizeof(float); + const int num_vertices = 4; + const int *indices = rect_index_order; + const int num_indices = 6; + const int size_indices = 4; + float minu, minv, maxu, maxv; + float minx, miny, maxx, maxy; + + minu = srcrect->x / texture->w; + minv = srcrect->y / texture->h; + maxu = (srcrect->x + srcrect->w) / texture->w; + maxv = (srcrect->y + srcrect->h) / texture->h; + + minx = dstrect->x; + miny = dstrect->y; + maxx = dstrect->x + dstrect->w; + maxy = dstrect->y + dstrect->h; + + uv[0] = minu; + uv[1] = minv; + uv[2] = maxu; + uv[3] = minv; + uv[4] = maxu; + uv[5] = maxv; + uv[6] = minu; + uv[7] = maxv; + + xy[0] = minx; + xy[1] = miny; + xy[2] = maxx; + xy[3] = miny; + xy[4] = maxx; + xy[5] = maxy; + xy[6] = minx; + xy[7] = maxy; + + result = QueueCmdGeometry(renderer, texture, + xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP); + } else { + const SDL_FRect rect = { dstrect->x * scale_x, dstrect->y * scale_y, dstrect->w * scale_x, dstrect->h * scale_y }; + result = QueueCmdCopy(renderer, texture, srcrect, &rect); + } + return result; +} + +bool SDL_RenderTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect) +{ + CHECK_RENDERER_MAGIC(renderer, false); + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + SDL_FRect real_srcrect; + real_srcrect.x = 0.0f; + real_srcrect.y = 0.0f; + real_srcrect.w = (float)texture->w; + real_srcrect.h = (float)texture->h; + if (srcrect) { + if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect) || + real_srcrect.w == 0.0f || real_srcrect.h == 0.0f) { + return true; + } + } + + SDL_FRect full_dstrect; + if (!dstrect) { + GetRenderViewportSize(renderer, &full_dstrect); + dstrect = &full_dstrect; + } + + if (texture->native) { + texture = texture->native; + } + + texture->last_command_generation = renderer->render_command_generation; + + return SDL_RenderTextureInternal(renderer, texture, &real_srcrect, dstrect); +} + +bool SDL_RenderTextureAffine(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_FRect *srcrect, const SDL_FPoint *origin, const SDL_FPoint *right, const SDL_FPoint *down) +{ + SDL_FRect real_srcrect; + SDL_FRect real_dstrect; + bool result; + + CHECK_RENDERER_MAGIC(renderer, false); + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + if (!renderer->QueueCopyEx && !renderer->QueueGeometry) { + return SDL_SetError("Renderer does not support RenderCopyEx"); + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + real_srcrect.x = 0.0f; + real_srcrect.y = 0.0f; + real_srcrect.w = (float)texture->w; + real_srcrect.h = (float)texture->h; + if (srcrect) { + if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) { + return true; + } + } + + GetRenderViewportSize(renderer, &real_dstrect); + + if (texture->native) { + texture = texture->native; + } + + texture->last_command_generation = renderer->render_command_generation; + + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + + { + float xy[8]; + const int xy_stride = 2 * sizeof(float); + float uv[8]; + const int uv_stride = 2 * sizeof(float); + const int num_vertices = 4; + const int *indices = rect_index_order; + const int num_indices = 6; + const int size_indices = 4; + + float minu = real_srcrect.x / texture->w; + float minv = real_srcrect.y / texture->h; + float maxu = (real_srcrect.x + real_srcrect.w) / texture->w; + float maxv = (real_srcrect.y + real_srcrect.h) / texture->h; + + uv[0] = minu; + uv[1] = minv; + uv[2] = maxu; + uv[3] = minv; + uv[4] = maxu; + uv[5] = maxv; + uv[6] = minu; + uv[7] = maxv; + + // (minx, miny) + if (origin) { + xy[0] = origin->x; + xy[1] = origin->y; + } else { + xy[0] = real_dstrect.x; + xy[1] = real_dstrect.y; + } + + // (maxx, miny) + if (right) { + xy[2] = right->x; + xy[3] = right->y; + } else { + xy[2] = real_dstrect.x + real_dstrect.w; + xy[3] = real_dstrect.y; + } + + // (minx, maxy) + if (down) { + xy[6] = down->x; + xy[7] = down->y; + } else { + xy[6] = real_dstrect.x; + xy[7] = real_dstrect.y + real_dstrect.h; + } + + // (maxx, maxy) + if (origin || right || down) { + xy[4] = xy[2] + xy[6] - xy[0]; + xy[5] = xy[3] + xy[7] - xy[1]; + } else { + xy[4] = real_dstrect.x + real_dstrect.w; + xy[5] = real_dstrect.y + real_dstrect.h; + } + + result = QueueCmdGeometry( + renderer, texture, + xy, xy_stride, + &texture->color, 0 /* color_stride */, + uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP + ); + } + return result; +} + +bool SDL_RenderTextureRotated(SDL_Renderer *renderer, SDL_Texture *texture, + const SDL_FRect *srcrect, const SDL_FRect *dstrect, + const double angle, const SDL_FPoint *center, const SDL_FlipMode flip) +{ + SDL_FRect real_srcrect; + SDL_FPoint real_center; + bool result; + + if (flip == SDL_FLIP_NONE && (int)(angle / 360) == angle / 360) { // fast path when we don't need rotation or flipping + return SDL_RenderTexture(renderer, texture, srcrect, dstrect); + } + + CHECK_RENDERER_MAGIC(renderer, false); + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + if (!renderer->QueueCopyEx && !renderer->QueueGeometry) { + return SDL_SetError("Renderer does not support RenderCopyEx"); + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + real_srcrect.x = 0.0f; + real_srcrect.y = 0.0f; + real_srcrect.w = (float)texture->w; + real_srcrect.h = (float)texture->h; + if (srcrect) { + if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) { + return true; + } + } + + // We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? + SDL_FRect full_dstrect; + if (!dstrect) { + GetRenderViewportSize(renderer, &full_dstrect); + dstrect = &full_dstrect; + } + + if (texture->native) { + texture = texture->native; + } + + if (center) { + real_center = *center; + } else { + real_center.x = dstrect->w / 2.0f; + real_center.y = dstrect->h / 2.0f; + } + + texture->last_command_generation = renderer->render_command_generation; + + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + + const bool use_rendergeometry = (!renderer->QueueCopyEx); + if (use_rendergeometry) { + float xy[8]; + const int xy_stride = 2 * sizeof(float); + float uv[8]; + const int uv_stride = 2 * sizeof(float); + const int num_vertices = 4; + const int *indices = rect_index_order; + const int num_indices = 6; + const int size_indices = 4; + float minu, minv, maxu, maxv; + float minx, miny, maxx, maxy; + float centerx, centery; + + float s_minx, s_miny, s_maxx, s_maxy; + float c_minx, c_miny, c_maxx, c_maxy; + + const float radian_angle = (float)((SDL_PI_D * angle) / 180.0); + const float s = SDL_sinf(radian_angle); + const float c = SDL_cosf(radian_angle); + + minu = real_srcrect.x / texture->w; + minv = real_srcrect.y / texture->h; + maxu = (real_srcrect.x + real_srcrect.w) / texture->w; + maxv = (real_srcrect.y + real_srcrect.h) / texture->h; + + centerx = real_center.x + dstrect->x; + centery = real_center.y + dstrect->y; + + if (flip & SDL_FLIP_HORIZONTAL) { + minx = dstrect->x + dstrect->w; + maxx = dstrect->x; + } else { + minx = dstrect->x; + maxx = dstrect->x + dstrect->w; + } + + if (flip & SDL_FLIP_VERTICAL) { + miny = dstrect->y + dstrect->h; + maxy = dstrect->y; + } else { + miny = dstrect->y; + maxy = dstrect->y + dstrect->h; + } + + uv[0] = minu; + uv[1] = minv; + uv[2] = maxu; + uv[3] = minv; + uv[4] = maxu; + uv[5] = maxv; + uv[6] = minu; + uv[7] = maxv; + + /* apply rotation with 2x2 matrix ( c -s ) + * ( s c ) */ + s_minx = s * (minx - centerx); + s_miny = s * (miny - centery); + s_maxx = s * (maxx - centerx); + s_maxy = s * (maxy - centery); + c_minx = c * (minx - centerx); + c_miny = c * (miny - centery); + c_maxx = c * (maxx - centerx); + c_maxy = c * (maxy - centery); + + // (minx, miny) + xy[0] = (c_minx - s_miny) + centerx; + xy[1] = (s_minx + c_miny) + centery; + // (maxx, miny) + xy[2] = (c_maxx - s_miny) + centerx; + xy[3] = (s_maxx + c_miny) + centery; + // (maxx, maxy) + xy[4] = (c_maxx - s_maxy) + centerx; + xy[5] = (s_maxx + c_maxy) + centery; + // (minx, maxy) + xy[6] = (c_minx - s_maxy) + centerx; + xy[7] = (s_minx + c_maxy) + centery; + + result = QueueCmdGeometry(renderer, texture, + xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP); + } else { + result = QueueCmdCopyEx(renderer, texture, &real_srcrect, dstrect, angle, &real_center, flip, scale_x, scale_y); + } + return result; +} + +static bool SDL_RenderTextureTiled_Wrap(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect) +{ + float xy[8]; + const int xy_stride = 2 * sizeof(float); + float uv[8]; + const int uv_stride = 2 * sizeof(float); + const int num_vertices = 4; + const int *indices = rect_index_order; + const int num_indices = 6; + const int size_indices = 4; + float minu, minv, maxu, maxv; + float minx, miny, maxx, maxy; + + minu = 0.0f; + minv = 0.0f; + maxu = dstrect->w / (srcrect->w * scale); + maxv = dstrect->h / (srcrect->h * scale); + + minx = dstrect->x; + miny = dstrect->y; + maxx = dstrect->x + dstrect->w; + maxy = dstrect->y + dstrect->h; + + uv[0] = minu; + uv[1] = minv; + uv[2] = maxu; + uv[3] = minv; + uv[4] = maxu; + uv[5] = maxv; + uv[6] = minu; + uv[7] = maxv; + + xy[0] = minx; + xy[1] = miny; + xy[2] = maxx; + xy[3] = miny; + xy[4] = maxx; + xy[5] = maxy; + xy[6] = minx; + xy[7] = maxy; + + const SDL_RenderViewState *view = renderer->view; + return QueueCmdGeometry(renderer, texture, + xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + view->current_scale.x, view->current_scale.y, SDL_TEXTURE_ADDRESS_WRAP); +} + +static bool SDL_RenderTextureTiled_Iterate(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect) +{ + float tile_width = srcrect->w * scale; + float tile_height = srcrect->h * scale; + float float_rows, float_cols; + float remaining_w = SDL_modff(dstrect->w / tile_width, &float_cols); + float remaining_h = SDL_modff(dstrect->h / tile_height, &float_rows); + float remaining_src_w = remaining_w * srcrect->w; + float remaining_src_h = remaining_h * srcrect->h; + float remaining_dst_w = remaining_w * tile_width; + float remaining_dst_h = remaining_h * tile_height; + int rows = (int)float_rows; + int cols = (int)float_cols; + SDL_FRect curr_src, curr_dst; + + SDL_copyp(&curr_src, srcrect); + curr_dst.y = dstrect->y; + curr_dst.w = tile_width; + curr_dst.h = tile_height; + for (int y = 0; y < rows; ++y) { + curr_dst.x = dstrect->x; + for (int x = 0; x < cols; ++x) { + if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + curr_dst.x += curr_dst.w; + } + if (remaining_dst_w > 0.0f) { + curr_src.w = remaining_src_w; + curr_dst.w = remaining_dst_w; + if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + curr_src.w = srcrect->w; + curr_dst.w = tile_width; + } + curr_dst.y += curr_dst.h; + } + if (remaining_dst_h > 0.0f) { + curr_src.h = remaining_src_h; + curr_dst.h = remaining_dst_h; + curr_dst.x = dstrect->x; + for (int x = 0; x < cols; ++x) { + if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + curr_dst.x += curr_dst.w; + } + if (remaining_dst_w > 0.0f) { + curr_src.w = remaining_src_w; + curr_dst.w = remaining_dst_w; + if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + } + } + return true; +} + +bool SDL_RenderTextureTiled(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect) +{ + SDL_FRect real_srcrect; + + CHECK_RENDERER_MAGIC(renderer, false); + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + + if (scale <= 0.0f) { + return SDL_InvalidParamError("scale"); + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + real_srcrect.x = 0.0f; + real_srcrect.y = 0.0f; + real_srcrect.w = (float)texture->w; + real_srcrect.h = (float)texture->h; + if (srcrect) { + if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) { + return true; + } + } + + SDL_FRect full_dstrect; + if (!dstrect) { + GetRenderViewportSize(renderer, &full_dstrect); + dstrect = &full_dstrect; + } + + if (texture->native) { + texture = texture->native; + } + + texture->last_command_generation = renderer->render_command_generation; + + // See if we can use geometry with repeating texture coordinates + if (!renderer->software && + (!srcrect || + (real_srcrect.x == 0.0f && real_srcrect.y == 0.0f && + real_srcrect.w == (float)texture->w && real_srcrect.h == (float)texture->h))) { + return SDL_RenderTextureTiled_Wrap(renderer, texture, &real_srcrect, scale, dstrect); + } else { + return SDL_RenderTextureTiled_Iterate(renderer, texture, &real_srcrect, scale, dstrect); + } +} + +bool SDL_RenderTexture9Grid(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float left_width, float right_width, float top_height, float bottom_height, float scale, const SDL_FRect *dstrect) +{ + SDL_FRect full_src, full_dst; + SDL_FRect curr_src, curr_dst; + float dst_left_width; + float dst_right_width; + float dst_top_height; + float dst_bottom_height; + + CHECK_RENDERER_MAGIC(renderer, false); + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + + if (!srcrect) { + full_src.x = 0; + full_src.y = 0; + full_src.w = (float)texture->w; + full_src.h = (float)texture->h; + srcrect = &full_src; + } + + if (!dstrect) { + GetRenderViewportSize(renderer, &full_dst); + dstrect = &full_dst; + } + + if (scale <= 0.0f || scale == 1.0f) { + dst_left_width = SDL_ceilf(left_width); + dst_right_width = SDL_ceilf(right_width); + dst_top_height = SDL_ceilf(top_height); + dst_bottom_height = SDL_ceilf(bottom_height); + } else { + dst_left_width = SDL_ceilf(left_width * scale); + dst_right_width = SDL_ceilf(right_width * scale); + dst_top_height = SDL_ceilf(top_height * scale); + dst_bottom_height = SDL_ceilf(bottom_height * scale); + } + + // Center + curr_src.x = srcrect->x + left_width; + curr_src.y = srcrect->y + top_height; + curr_src.w = srcrect->w - left_width - right_width; + curr_src.h = srcrect->h - top_height - bottom_height; + curr_dst.x = dstrect->x + dst_left_width; + curr_dst.y = dstrect->y + dst_top_height; + curr_dst.w = dstrect->w - dst_left_width - dst_right_width; + curr_dst.h = dstrect->h - dst_top_height - dst_bottom_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Upper-left corner + curr_src.x = srcrect->x; + curr_src.y = srcrect->y; + curr_src.w = left_width; + curr_src.h = top_height; + curr_dst.x = dstrect->x; + curr_dst.y = dstrect->y; + curr_dst.w = dst_left_width; + curr_dst.h = dst_top_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Upper-right corner + curr_src.x = srcrect->x + srcrect->w - right_width; + curr_src.w = right_width; + curr_dst.x = dstrect->x + dstrect->w - dst_right_width; + curr_dst.w = dst_right_width; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Lower-right corner + curr_src.y = srcrect->y + srcrect->h - bottom_height; + curr_src.h = bottom_height; + curr_dst.y = dstrect->y + dstrect->h - dst_bottom_height; + curr_dst.h = dst_bottom_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Lower-left corner + curr_src.x = srcrect->x; + curr_src.w = left_width; + curr_dst.x = dstrect->x; + curr_dst.w = dst_left_width; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Left + curr_src.y = srcrect->y + top_height; + curr_src.h = srcrect->h - top_height - bottom_height; + curr_dst.y = dstrect->y + dst_top_height; + curr_dst.h = dstrect->h - dst_top_height - dst_bottom_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Right + curr_src.x = srcrect->x + srcrect->w - right_width; + curr_src.w = right_width; + curr_dst.x = dstrect->x + dstrect->w - dst_right_width; + curr_dst.w = dst_right_width; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Top + curr_src.x = srcrect->x + left_width; + curr_src.y = srcrect->y; + curr_src.w = srcrect->w - left_width - right_width; + curr_src.h = top_height; + curr_dst.x = dstrect->x + dst_left_width; + curr_dst.y = dstrect->y; + curr_dst.w = dstrect->w - dst_left_width - dst_right_width; + curr_dst.h = dst_top_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + // Bottom + curr_src.y = srcrect->y + srcrect->h - bottom_height; + curr_src.h = bottom_height; + curr_dst.y = dstrect->y + dstrect->h - dst_bottom_height; + curr_dst.h = dst_bottom_height; + if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) { + return false; + } + + return true; +} + +bool SDL_RenderGeometry(SDL_Renderer *renderer, + SDL_Texture *texture, + const SDL_Vertex *vertices, int num_vertices, + const int *indices, int num_indices) +{ + if (vertices) { + const float *xy = &vertices->position.x; + int xy_stride = sizeof(SDL_Vertex); + const SDL_FColor *color = &vertices->color; + int color_stride = sizeof(SDL_Vertex); + const float *uv = &vertices->tex_coord.x; + int uv_stride = sizeof(SDL_Vertex); + int size_indices = 4; + return SDL_RenderGeometryRaw(renderer, texture, xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices, indices, num_indices, size_indices); + } else { + return SDL_InvalidParamError("vertices"); + } +} + +#ifdef SDL_VIDEO_RENDER_SW +static int remap_one_indice( + int prev, + int k, + SDL_Texture *texture, + const float *xy, int xy_stride, + const SDL_FColor *color, int color_stride, + const float *uv, int uv_stride) +{ + const float *xy0_, *xy1_, *uv0_, *uv1_; + const SDL_FColor *col0_, *col1_; + xy0_ = (const float *)((const char *)xy + prev * xy_stride); + xy1_ = (const float *)((const char *)xy + k * xy_stride); + if (xy0_[0] != xy1_[0]) { + return k; + } + if (xy0_[1] != xy1_[1]) { + return k; + } + if (texture) { + uv0_ = (const float *)((const char *)uv + prev * uv_stride); + uv1_ = (const float *)((const char *)uv + k * uv_stride); + if (uv0_[0] != uv1_[0]) { + return k; + } + if (uv0_[1] != uv1_[1]) { + return k; + } + } + col0_ = (const SDL_FColor *)((const char *)color + prev * color_stride); + col1_ = (const SDL_FColor *)((const char *)color + k * color_stride); + + if (SDL_memcmp(col0_, col1_, sizeof(*col0_)) != 0) { + return k; + } + + return prev; +} + +static int remap_indices( + int prev[3], + int k, + SDL_Texture *texture, + const float *xy, int xy_stride, + const SDL_FColor *color, int color_stride, + const float *uv, int uv_stride) +{ + int i; + if (prev[0] == -1) { + return k; + } + + for (i = 0; i < 3; i++) { + int new_k = remap_one_indice(prev[i], k, texture, xy, xy_stride, color, color_stride, uv, uv_stride); + if (new_k != k) { + return new_k; + } + } + return k; +} + +#define DEBUG_SW_RENDER_GEOMETRY 0 +// For the software renderer, try to reinterpret triangles as SDL_Rect +static bool SDLCALL SDL_SW_RenderGeometryRaw(SDL_Renderer *renderer, + 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) +{ + int i; + bool result = true; + int count = indices ? num_indices : num_vertices; + int prev[3]; // Previous triangle vertex indices + float texw = 0.0f, texh = 0.0f; + SDL_BlendMode blendMode = SDL_BLENDMODE_NONE; + float r = 0, g = 0, b = 0, a = 0; + const SDL_RenderViewState *view = renderer->view; + const float scale_x = view->current_scale.x; + const float scale_y = view->current_scale.y; + + // Save + SDL_GetRenderDrawBlendMode(renderer, &blendMode); + SDL_GetRenderDrawColorFloat(renderer, &r, &g, &b, &a); + + if (texture) { + SDL_GetTextureSize(texture, &texw, &texh); + } + + prev[0] = -1; + prev[1] = -1; + prev[2] = -1; + size_indices = indices ? size_indices : 0; + + for (i = 0; i < count; i += 3) { + int k0, k1, k2; // Current triangle indices + int is_quad = 1; +#if DEBUG_SW_RENDER_GEOMETRY + int is_uniform = 1; + int is_rectangle = 1; +#endif + int A = -1; // Top left vertex + int B = -1; // Bottom right vertex + int C = -1; // Third vertex of current triangle + int C2 = -1; // Last, vertex of previous triangle + + if (size_indices == 4) { + k0 = ((const Uint32 *)indices)[i]; + k1 = ((const Uint32 *)indices)[i + 1]; + k2 = ((const Uint32 *)indices)[i + 2]; + } else if (size_indices == 2) { + k0 = ((const Uint16 *)indices)[i]; + k1 = ((const Uint16 *)indices)[i + 1]; + k2 = ((const Uint16 *)indices)[i + 2]; + } else if (size_indices == 1) { + k0 = ((const Uint8 *)indices)[i]; + k1 = ((const Uint8 *)indices)[i + 1]; + k2 = ((const Uint8 *)indices)[i + 2]; + } else { + /* Vertices were not provided by indices. Maybe some are duplicated. + * We try to indentificate the duplicates by comparing with the previous three vertices */ + k0 = remap_indices(prev, i, texture, xy, xy_stride, color, color_stride, uv, uv_stride); + k1 = remap_indices(prev, i + 1, texture, xy, xy_stride, color, color_stride, uv, uv_stride); + k2 = remap_indices(prev, i + 2, texture, xy, xy_stride, color, color_stride, uv, uv_stride); + } + + if (prev[0] == -1) { + prev[0] = k0; + prev[1] = k1; + prev[2] = k2; + continue; + } + + /* Two triangles forming a quadialateral, + * prev and current triangles must have exactly 2 common vertices */ + { + int cnt = 0, j = 3; + while (j--) { + int p = prev[j]; + if (p == k0 || p == k1 || p == k2) { + cnt++; + } + } + is_quad = (cnt == 2); + } + + // Identify vertices + if (is_quad) { + const float *xy0_, *xy1_, *xy2_; + float x0, x1, x2; + float y0, y1, y2; + xy0_ = (const float *)((const char *)xy + k0 * xy_stride); + xy1_ = (const float *)((const char *)xy + k1 * xy_stride); + xy2_ = (const float *)((const char *)xy + k2 * xy_stride); + x0 = xy0_[0]; + y0 = xy0_[1]; + x1 = xy1_[0]; + y1 = xy1_[1]; + x2 = xy2_[0]; + y2 = xy2_[1]; + + // Find top-left + if (x0 <= x1 && y0 <= y1) { + if (x0 <= x2 && y0 <= y2) { + A = k0; + } else { + A = k2; + } + } else { + if (x1 <= x2 && y1 <= y2) { + A = k1; + } else { + A = k2; + } + } + + // Find bottom-right + if (x0 >= x1 && y0 >= y1) { + if (x0 >= x2 && y0 >= y2) { + B = k0; + } else { + B = k2; + } + } else { + if (x1 >= x2 && y1 >= y2) { + B = k1; + } else { + B = k2; + } + } + + // Find C + if (k0 != A && k0 != B) { + C = k0; + } else if (k1 != A && k1 != B) { + C = k1; + } else { + C = k2; + } + + // Find C2 + if (prev[0] != A && prev[0] != B) { + C2 = prev[0]; + } else if (prev[1] != A && prev[1] != B) { + C2 = prev[1]; + } else { + C2 = prev[2]; + } + + xy0_ = (const float *)((const char *)xy + A * xy_stride); + xy1_ = (const float *)((const char *)xy + B * xy_stride); + xy2_ = (const float *)((const char *)xy + C * xy_stride); + x0 = xy0_[0]; + y0 = xy0_[1]; + x1 = xy1_[0]; + y1 = xy1_[1]; + x2 = xy2_[0]; + y2 = xy2_[1]; + + // Check if triangle A B C is rectangle + if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)) { + // ok + } else { + is_quad = 0; +#if DEBUG_SW_RENDER_GEOMETRY + is_rectangle = 0; +#endif + } + + xy2_ = (const float *)((const char *)xy + C2 * xy_stride); + x2 = xy2_[0]; + y2 = xy2_[1]; + + // Check if triangle A B C2 is rectangle + if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)) { + // ok + } else { + is_quad = 0; +#if DEBUG_SW_RENDER_GEOMETRY + is_rectangle = 0; +#endif + } + } + + // Check if uniformly colored + if (is_quad) { + const SDL_FColor *col0_ = (const SDL_FColor *)((const char *)color + A * color_stride); + const SDL_FColor *col1_ = (const SDL_FColor *)((const char *)color + B * color_stride); + const SDL_FColor *col2_ = (const SDL_FColor *)((const char *)color + C * color_stride); + const SDL_FColor *col3_ = (const SDL_FColor *)((const char *)color + C2 * color_stride); + if (SDL_memcmp(col0_, col1_, sizeof(*col0_)) == 0 && + SDL_memcmp(col0_, col2_, sizeof(*col0_)) == 0 && + SDL_memcmp(col0_, col3_, sizeof(*col0_)) == 0) { + // ok + } else { + is_quad = 0; +#if DEBUG_SW_RENDER_GEOMETRY + is_uniform = 0; +#endif + } + } + + // Start rendering rect + if (is_quad) { + SDL_FRect s; + SDL_FRect d; + const float *xy0_, *xy1_, *uv0_, *uv1_; + const SDL_FColor *col0_ = (const SDL_FColor *)((const char *)color + k0 * color_stride); + + xy0_ = (const float *)((const char *)xy + A * xy_stride); + xy1_ = (const float *)((const char *)xy + B * xy_stride); + + if (texture) { + uv0_ = (const float *)((const char *)uv + A * uv_stride); + uv1_ = (const float *)((const char *)uv + B * uv_stride); + s.x = uv0_[0] * texw; + s.y = uv0_[1] * texh; + s.w = uv1_[0] * texw - s.x; + s.h = uv1_[1] * texh - s.y; + } else { + s.x = s.y = s.w = s.h = 0; + } + + d.x = xy0_[0]; + d.y = xy0_[1]; + d.w = xy1_[0] - d.x; + d.h = xy1_[1] - d.y; + + // Rect + texture + if (texture && s.w != 0 && s.h != 0) { + SDL_SetTextureAlphaModFloat(texture, col0_->a); + SDL_SetTextureColorModFloat(texture, col0_->r, col0_->g, col0_->b); + if (s.w > 0 && s.h > 0) { + SDL_RenderTexture(renderer, texture, &s, &d); + } else { + int flags = 0; + if (s.w < 0) { + flags |= SDL_FLIP_HORIZONTAL; + s.w *= -1; + s.x -= s.w; + } + if (s.h < 0) { + flags |= SDL_FLIP_VERTICAL; + s.h *= -1; + s.y -= s.h; + } + SDL_RenderTextureRotated(renderer, texture, &s, &d, 0, NULL, (SDL_FlipMode)flags); + } + +#if DEBUG_SW_RENDER_GEOMETRY + SDL_Log("Rect-COPY: RGB %f %f %f - Alpha:%f - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a, + (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h); +#endif + } else if (d.w != 0.0f && d.h != 0.0f) { // Rect, no texture + SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); + SDL_SetRenderDrawColorFloat(renderer, col0_->r, col0_->g, col0_->b, col0_->a); + SDL_RenderFillRect(renderer, &d); +#if DEBUG_SW_RENDER_GEOMETRY + SDL_Log("Rect-FILL: RGB %f %f %f - Alpha:%f - texture=%p: dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a, + (void *)texture, d.x, d.y, d.w, d.h); + } else { + SDL_Log("Rect-DISMISS: RGB %f %f %f - Alpha:%f - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a, + (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h); +#endif + } + + prev[0] = -1; + } else { + // Render triangles + if (prev[0] != -1) { +#if DEBUG_SW_RENDER_GEOMETRY + SDL_Log("Triangle %d %d %d - is_uniform:%d is_rectangle:%d", prev[0], prev[1], prev[2], is_uniform, is_rectangle); +#endif + result = QueueCmdGeometry(renderer, texture, + xy, xy_stride, color, color_stride, uv, uv_stride, + num_vertices, prev, 3, 4, + scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP); + if (!result) { + goto end; + } + } + + prev[0] = k0; + prev[1] = k1; + prev[2] = k2; + } + } // End for (), next triangle + + if (prev[0] != -1) { + // flush the last triangle +#if DEBUG_SW_RENDER_GEOMETRY + SDL_Log("Last triangle %d %d %d", prev[0], prev[1], prev[2]); +#endif + result = QueueCmdGeometry(renderer, texture, + xy, xy_stride, color, color_stride, uv, uv_stride, + num_vertices, prev, 3, 4, + scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP); + if (!result) { + goto end; + } + } + +end: + // Restore + SDL_SetRenderDrawBlendMode(renderer, blendMode); + SDL_SetRenderDrawColorFloat(renderer, r, g, b, a); + + return result; +} +#endif // SDL_VIDEO_RENDER_SW + +bool SDL_RenderGeometryRaw(SDL_Renderer *renderer, + 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) +{ + int i; + int count = indices ? num_indices : num_vertices; + SDL_TextureAddressMode texture_address_mode; + + CHECK_RENDERER_MAGIC(renderer, false); + + if (!renderer->QueueGeometry) { + return SDL_Unsupported(); + } + + if (texture) { + CHECK_TEXTURE_MAGIC(texture, false); + + if (renderer != texture->renderer) { + return SDL_SetError("Texture was not created with this renderer"); + } + } + + if (!xy) { + return SDL_InvalidParamError("xy"); + } + + if (!color) { + return SDL_InvalidParamError("color"); + } + + if (texture && !uv) { + return SDL_InvalidParamError("uv"); + } + + if (count % 3 != 0) { + return SDL_InvalidParamError(indices ? "num_indices" : "num_vertices"); + } + + if (indices) { + if (size_indices != 1 && size_indices != 2 && size_indices != 4) { + return SDL_InvalidParamError("size_indices"); + } + } else { + size_indices = 0; + } + +#if DONT_DRAW_WHILE_HIDDEN + // Don't draw while we're hidden + if (renderer->hidden) { + return true; + } +#endif + + if (num_vertices < 3) { + return true; + } + + if (texture && texture->native) { + texture = texture->native; + } + + texture_address_mode = renderer->texture_address_mode; + if (texture_address_mode == SDL_TEXTURE_ADDRESS_AUTO && texture) { + texture_address_mode = SDL_TEXTURE_ADDRESS_CLAMP; + for (i = 0; i < num_vertices; ++i) { + const float *uv_ = (const float *)((const char *)uv + i * uv_stride); + float u = uv_[0]; + float v = uv_[1]; + if (u < 0.0f || v < 0.0f || u > 1.0f || v > 1.0f) { + texture_address_mode = SDL_TEXTURE_ADDRESS_WRAP; + break; + } + } + } + + if (indices) { + for (i = 0; i < num_indices; ++i) { + int j; + if (size_indices == 4) { + j = ((const Uint32 *)indices)[i]; + } else if (size_indices == 2) { + j = ((const Uint16 *)indices)[i]; + } else { + j = ((const Uint8 *)indices)[i]; + } + if (j < 0 || j >= num_vertices) { + return SDL_SetError("Values of 'indices' out of bounds"); + } + } + } + + if (texture) { + texture->last_command_generation = renderer->render_command_generation; + } + + // For the software renderer, try to reinterpret triangles as SDL_Rect +#ifdef SDL_VIDEO_RENDER_SW + if (renderer->software && texture_address_mode == SDL_TEXTURE_ADDRESS_CLAMP) { + return SDL_SW_RenderGeometryRaw(renderer, texture, + xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices, + indices, num_indices, size_indices); + } +#endif + + const SDL_RenderViewState *view = renderer->view; + return QueueCmdGeometry(renderer, texture, + xy, xy_stride, color, color_stride, uv, uv_stride, + num_vertices, indices, num_indices, size_indices, + view->current_scale.x, view->current_scale.y, + texture_address_mode); +} + +SDL_Surface *SDL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + + if (!renderer->RenderReadPixels) { + SDL_Unsupported(); + return NULL; + } + + FlushRenderCommands(renderer); // we need to render before we read the results. + + SDL_Rect real_rect = renderer->view->pixel_viewport; + + if (rect) { + if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) { + SDL_SetError("Can't read outside the current viewport"); + return NULL; + } + } + + SDL_Surface *surface = renderer->RenderReadPixels(renderer, &real_rect); + if (surface) { + SDL_PropertiesID props = SDL_GetSurfaceProperties(surface); + + if (renderer->target) { + SDL_Texture *target = renderer->target; + SDL_Texture *parent = SDL_GetPointerProperty(SDL_GetTextureProperties(target), SDL_PROP_TEXTURE_PARENT_POINTER, NULL); + SDL_PixelFormat expected_format = (parent ? parent->format : target->format); + + SDL_SetFloatProperty(props, SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT, target->SDR_white_point); + SDL_SetFloatProperty(props, SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT, target->HDR_headroom); + + // Set the expected surface format + if ((surface->format == SDL_PIXELFORMAT_ARGB8888 && expected_format == SDL_PIXELFORMAT_XRGB8888) || + (surface->format == SDL_PIXELFORMAT_RGBA8888 && expected_format == SDL_PIXELFORMAT_RGBX8888) || + (surface->format == SDL_PIXELFORMAT_ABGR8888 && expected_format == SDL_PIXELFORMAT_XBGR8888) || + (surface->format == SDL_PIXELFORMAT_BGRA8888 && expected_format == SDL_PIXELFORMAT_BGRX8888)) { + surface->format = expected_format; + surface->fmt = SDL_GetPixelFormatDetails(expected_format); + } + } else { + SDL_SetFloatProperty(props, SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT, renderer->SDR_white_point); + SDL_SetFloatProperty(props, SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT, renderer->HDR_headroom); + } + } + return surface; +} + +static void SDL_RenderApplyWindowShape(SDL_Renderer *renderer) +{ + SDL_Surface *shape = (SDL_Surface *)SDL_GetPointerProperty(SDL_GetWindowProperties(renderer->window), SDL_PROP_WINDOW_SHAPE_POINTER, NULL); + if (shape != renderer->shape_surface) { + if (renderer->shape_texture) { + SDL_DestroyTexture(renderer->shape_texture); + renderer->shape_texture = NULL; + } + + if (shape) { + // There's nothing we can do if this fails, so just keep on going + renderer->shape_texture = SDL_CreateTextureFromSurface(renderer, shape); + + SDL_SetTextureBlendMode(renderer->shape_texture, + SDL_ComposeCustomBlendMode( + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD, + SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD)); + } + renderer->shape_surface = shape; + } + + if (renderer->shape_texture) { + SDL_RenderTexture(renderer, renderer->shape_texture, NULL, NULL); + } +} + +static void SDL_SimulateRenderVSync(SDL_Renderer *renderer) +{ + Uint64 now, elapsed; + const Uint64 interval = renderer->simulate_vsync_interval_ns; + + if (!interval) { + // We can't do sub-ns delay, so just return here + return; + } + + now = SDL_GetTicksNS(); + elapsed = (now - renderer->last_present); + if (elapsed < interval) { + Uint64 duration = (interval - elapsed); + SDL_DelayPrecise(duration); + now = SDL_GetTicksNS(); + } + + elapsed = (now - renderer->last_present); + if (!renderer->last_present || elapsed > SDL_MS_TO_NS(1000)) { + // It's been too long, reset the presentation timeline + renderer->last_present = now; + } else { + renderer->last_present += (elapsed / interval) * interval; + } +} + +bool SDL_RenderPresent(SDL_Renderer *renderer) +{ + bool presented = true; + + CHECK_RENDERER_MAGIC(renderer, false); + + SDL_Texture *target = renderer->target; + if (target) { + SDL_SetRenderTarget(renderer, NULL); + } + + SDL_RenderLogicalPresentation(renderer); + + if (renderer->transparent_window) { + SDL_RenderApplyWindowShape(renderer); + } + + FlushRenderCommands(renderer); // time to send everything to the GPU! + +#if DONT_DRAW_WHILE_HIDDEN + // Don't present while we're hidden + if (renderer->hidden) { + presented = false; + } else +#endif + if (!renderer->RenderPresent(renderer)) { + presented = false; + } + + if (target) { + SDL_SetRenderTarget(renderer, target); + } + + if (renderer->simulate_vsync || + (!presented && renderer->wanted_vsync)) { + SDL_SimulateRenderVSync(renderer); + } + return true; +} + +static void SDL_DestroyTextureInternal(SDL_Texture *texture, bool is_destroying) +{ + SDL_Renderer *renderer; + + SDL_DestroyProperties(texture->props); + + renderer = texture->renderer; + if (is_destroying) { + // Renderer get destroyed, avoid to queue more commands + } else { + if (texture == renderer->target) { + SDL_SetRenderTarget(renderer, NULL); // implies command queue flush + } else { + FlushRenderCommandsIfTextureNeeded(texture); + } + } + + SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, false); + + if (texture->next) { + texture->next->prev = texture->prev; + } + if (texture->prev) { + texture->prev->next = texture->next; + } else { + renderer->textures = texture->next; + } + + if (texture->native) { + SDL_DestroyTextureInternal(texture->native, is_destroying); + } +#ifdef SDL_HAVE_YUV + if (texture->yuv) { + SDL_SW_DestroyYUVTexture(texture->yuv); + } +#endif + SDL_free(texture->pixels); + + renderer->DestroyTexture(renderer, texture); + + SDL_DestroySurface(texture->locked_surface); + texture->locked_surface = NULL; + + SDL_free(texture); +} + +void SDL_DestroyTexture(SDL_Texture *texture) +{ + CHECK_TEXTURE_MAGIC(texture, ); + + if (--texture->refcount > 0) { + return; + } + + SDL_DestroyTextureInternal(texture, false /* is_destroying */); +} + +static void SDL_DiscardAllCommands(SDL_Renderer *renderer) +{ + SDL_RenderCommand *cmd; + + if (renderer->render_commands_tail) { + renderer->render_commands_tail->next = renderer->render_commands_pool; + cmd = renderer->render_commands; + } else { + cmd = renderer->render_commands_pool; + } + + renderer->render_commands_pool = NULL; + renderer->render_commands_tail = NULL; + renderer->render_commands = NULL; + renderer->vertex_data_used = 0; + + while (cmd) { + SDL_RenderCommand *next = cmd->next; + SDL_free(cmd); + cmd = next; + } +} + +void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer) +{ + SDL_assert(renderer != NULL); + SDL_assert(!renderer->destroyed); + + renderer->destroyed = true; + + SDL_RemoveWindowEventWatch(SDL_WINDOW_EVENT_WATCH_NORMAL, SDL_RendererEventWatch, renderer); + + if (renderer->window) { + SDL_PropertiesID props = SDL_GetWindowProperties(renderer->window); + if (SDL_GetPointerProperty(props, SDL_PROP_WINDOW_RENDERER_POINTER, NULL) == renderer) { + SDL_ClearProperty(props, SDL_PROP_WINDOW_RENDERER_POINTER); + } + SDL_RemoveWindowRenderer(renderer->window, renderer); + } + + if (renderer->software) { + // Make sure all drawing to a surface is complete + FlushRenderCommands(renderer); + } + SDL_DiscardAllCommands(renderer); + + if (renderer->debug_char_texture_atlas) { + SDL_DestroyTexture(renderer->debug_char_texture_atlas); + renderer->debug_char_texture_atlas = NULL; + } + + // Free existing textures for this renderer + while (renderer->textures) { + SDL_Texture *tex = renderer->textures; + SDL_DestroyTextureInternal(renderer->textures, true /* is_destroying */); + SDL_assert(tex != renderer->textures); // satisfy static analysis. + } + + // Clean up renderer-specific resources + if (renderer->DestroyRenderer) { + renderer->DestroyRenderer(renderer); + } + + if (renderer->target_mutex) { + SDL_DestroyMutex(renderer->target_mutex); + renderer->target_mutex = NULL; + } + if (renderer->vertex_data) { + SDL_free(renderer->vertex_data); + renderer->vertex_data = NULL; + } + if (renderer->texture_formats) { + SDL_free(renderer->texture_formats); + renderer->texture_formats = NULL; + } + if (renderer->props) { + SDL_DestroyProperties(renderer->props); + renderer->props = 0; + } +} + +void SDL_DestroyRenderer(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer,); + + // if we've already destroyed the renderer through SDL_DestroyWindow, we just need + // to free the renderer pointer. This lets apps destroy the window and renderer + // in either order. + if (!renderer->destroyed) { + SDL_DestroyRendererWithoutFreeing(renderer); + } + + SDL_Renderer *curr = SDL_renderers; + SDL_Renderer *prev = NULL; + while (curr) { + if (curr == renderer) { + if (prev) { + prev->next = renderer->next; + } else { + SDL_renderers = renderer->next; + } + break; + } + prev = curr; + curr = curr->next; + } + + SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, false); // It's no longer magical... + + SDL_free(renderer); +} + +void *SDL_GetRenderMetalLayer(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + + if (renderer->GetMetalLayer) { + FlushRenderCommands(renderer); // in case the app is going to mess with it. + return renderer->GetMetalLayer(renderer); + } + return NULL; +} + +void *SDL_GetRenderMetalCommandEncoder(SDL_Renderer *renderer) +{ + CHECK_RENDERER_MAGIC(renderer, NULL); + + if (renderer->GetMetalCommandEncoder) { + FlushRenderCommands(renderer); // in case the app is going to mess with it. + return renderer->GetMetalCommandEncoder(renderer); + } + return NULL; +} + +bool SDL_AddVulkanRenderSemaphores(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + if (!renderer->AddVulkanRenderSemaphores) { + return SDL_Unsupported(); + } + return renderer->AddVulkanRenderSemaphores(renderer, wait_stage_mask, wait_semaphore, signal_semaphore); +} + +static SDL_BlendMode SDL_GetShortBlendMode(SDL_BlendMode blendMode) +{ + if (blendMode == SDL_BLENDMODE_NONE_FULL) { + return SDL_BLENDMODE_NONE; + } + if (blendMode == SDL_BLENDMODE_BLEND_FULL) { + return SDL_BLENDMODE_BLEND; + } + if (blendMode == SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL) { + return SDL_BLENDMODE_BLEND_PREMULTIPLIED; + } + if (blendMode == SDL_BLENDMODE_ADD_FULL) { + return SDL_BLENDMODE_ADD; + } + if (blendMode == SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL) { + return SDL_BLENDMODE_ADD_PREMULTIPLIED; + } + if (blendMode == SDL_BLENDMODE_MOD_FULL) { + return SDL_BLENDMODE_MOD; + } + if (blendMode == SDL_BLENDMODE_MUL_FULL) { + return SDL_BLENDMODE_MUL; + } + return blendMode; +} + +static SDL_BlendMode SDL_GetLongBlendMode(SDL_BlendMode blendMode) +{ + if (blendMode == SDL_BLENDMODE_NONE) { + return SDL_BLENDMODE_NONE_FULL; + } + if (blendMode == SDL_BLENDMODE_BLEND) { + return SDL_BLENDMODE_BLEND_FULL; + } + if (blendMode == SDL_BLENDMODE_BLEND_PREMULTIPLIED) { + return SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL; + } + if (blendMode == SDL_BLENDMODE_ADD) { + return SDL_BLENDMODE_ADD_FULL; + } + if (blendMode == SDL_BLENDMODE_ADD_PREMULTIPLIED) { + return SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL; + } + if (blendMode == SDL_BLENDMODE_MOD) { + return SDL_BLENDMODE_MOD_FULL; + } + if (blendMode == SDL_BLENDMODE_MUL) { + return SDL_BLENDMODE_MUL_FULL; + } + return blendMode; +} + +SDL_BlendMode SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor, + SDL_BlendOperation colorOperation, + SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor, + SDL_BlendOperation alphaOperation) +{ + SDL_BlendMode blendMode = SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, + srcAlphaFactor, dstAlphaFactor, alphaOperation); + return SDL_GetShortBlendMode(blendMode); +} + +SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF); +} + +SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF); +} + +SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF); +} + +SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF); +} + +SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF); +} + +SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode) +{ + blendMode = SDL_GetLongBlendMode(blendMode); + return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF); +} + +bool SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + renderer->wanted_vsync = vsync ? true : false; + + // for the software renderer, forward the call to the WindowTexture renderer +#ifdef SDL_VIDEO_RENDER_SW + if (renderer->software) { + if (!renderer->window) { + if (!vsync) { + return true; + } else { + return SDL_Unsupported(); + } + } + if (SDL_SetWindowTextureVSync(NULL, renderer->window, vsync)) { + renderer->simulate_vsync = false; + return true; + } + } +#endif + + if (!renderer->SetVSync) { + switch (vsync) { + case 0: + renderer->simulate_vsync = false; + break; + case 1: + renderer->simulate_vsync = true; + break; + default: + return SDL_Unsupported(); + } + } else if (!renderer->SetVSync(renderer, vsync)) { + if (vsync == 1) { + renderer->simulate_vsync = true; + } else { + return false; + } + } + SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, vsync); + return true; +} + +bool SDL_GetRenderVSync(SDL_Renderer *renderer, int *vsync) +{ + if (vsync) { + *vsync = 0; + } + + CHECK_RENDERER_MAGIC(renderer, false); + + if (vsync) { + *vsync = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, 0); + } + return true; +} + + +#define SDL_DEBUG_FONT_GLYPHS_PER_ROW 14 + +static bool CreateDebugTextAtlas(SDL_Renderer *renderer) +{ + SDL_assert(renderer->debug_char_texture_atlas == NULL); // don't double-create it! + + const int charWidth = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE; + const int charHeight = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE; + + // actually make each glyph two pixels taller/wider, to prevent scaling artifacts. + const int rows = (SDL_DEBUG_FONT_NUM_GLYPHS / SDL_DEBUG_FONT_GLYPHS_PER_ROW) + 1; + SDL_Surface *atlas = SDL_CreateSurface((charWidth + 2) * SDL_DEBUG_FONT_GLYPHS_PER_ROW, rows * (charHeight + 2), SDL_PIXELFORMAT_RGBA8888); + if (!atlas) { + return false; + } + + const int pitch = atlas->pitch; + SDL_memset(atlas->pixels, '\0', atlas->h * atlas->pitch); + + int column = 0; + int row = 0; + for (int glyph = 0; glyph < SDL_DEBUG_FONT_NUM_GLYPHS; glyph++) { + // find top-left of this glyph in destination surface. The +2's account for glyph padding. + Uint8 *linepos = (((Uint8 *)atlas->pixels) + ((row * (charHeight + 2) + 1) * pitch)) + ((column * (charWidth + 2) + 1) * sizeof (Uint32)); + const Uint8 *charpos = SDL_RenderDebugTextFontData + (glyph * 8); + + // Draw the glyph to the surface... + for (int iy = 0; iy < charHeight; iy++) { + Uint32 *curpos = (Uint32 *)linepos; + for (int ix = 0; ix < charWidth; ix++) { + if ((*charpos) & (1 << ix)) { + *curpos = 0xffffffff; + } else { + *curpos = 0; + } + ++curpos; + } + linepos += pitch; + ++charpos; + } + + // move to next position (and if too far, start the next row). + column++; + if (column >= SDL_DEBUG_FONT_GLYPHS_PER_ROW) { + row++; + column = 0; + } + } + + SDL_assert((row < rows) || ((row == rows) && (column == 0))); // make sure we didn't overflow the surface. + + // Convert temp surface into texture + SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, atlas); + if (texture) { + SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST); + renderer->debug_char_texture_atlas = texture; + } + SDL_DestroySurface(atlas); + + return texture != NULL; +} + +static bool DrawDebugCharacter(SDL_Renderer *renderer, float x, float y, Uint32 c) +{ + SDL_assert(renderer->debug_char_texture_atlas != NULL); // should have been created by now! + + const int charWidth = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE; + const int charHeight = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE; + + // Character index in cache + Uint32 ci = c; + if ((ci <= 32) || ((ci >= 127) && (ci <= 160))) { + return true; // these are just completely blank chars, don't bother doing anything. + } else if (ci >= SDL_DEBUG_FONT_NUM_GLYPHS) { + ci = SDL_DEBUG_FONT_NUM_GLYPHS - 1; // use our "not a valid/supported character" glyph. + } else if (ci < 127) { + ci -= 33; // adjust for the 33 blank glyphs at the start + } else { + ci -= 67; // adjust for the 33 blank glyphs at the start AND the 34 gap in the middle. + } + + const float src_x = (float) (((ci % SDL_DEBUG_FONT_GLYPHS_PER_ROW) * (charWidth + 2)) + 1); + const float src_y = (float) (((ci / SDL_DEBUG_FONT_GLYPHS_PER_ROW) * (charHeight + 2)) + 1); + + // Draw texture onto destination + const SDL_FRect srect = { src_x, src_y, (float) charWidth, (float) charHeight }; + const SDL_FRect drect = { x, y, (float) charWidth, (float) charHeight }; + return SDL_RenderTexture(renderer, renderer->debug_char_texture_atlas, &srect, &drect); +} + +bool SDL_RenderDebugText(SDL_Renderer *renderer, float x, float y, const char *s) +{ + CHECK_RENDERER_MAGIC(renderer, false); + + // Allocate a texture atlas for this renderer if needed. + if (!renderer->debug_char_texture_atlas) { + if (!CreateDebugTextAtlas(renderer)) { + return false; + } + } + + bool result = true; + + Uint8 r, g, b, a; + result &= SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a); + result &= SDL_SetTextureColorMod(renderer->debug_char_texture_atlas, r, g, b); + result &= SDL_SetTextureAlphaMod(renderer->debug_char_texture_atlas, a); + + float curx = x; + Uint32 ch; + + while (result && ((ch = SDL_StepUTF8(&s, NULL)) != 0)) { + result &= DrawDebugCharacter(renderer, curx, y, ch); + curx += SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE; + } + + return result; +} + +bool SDL_RenderDebugTextFormat(SDL_Renderer *renderer, float x, float y, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + + // fast path to avoid unnecessary allocation and copy. If you're going through the dynapi, there's a good chance + // you _always_ hit this path, since it probably had to process varargs before calling into the jumptable. + if (SDL_strcmp(fmt, "%s") == 0) { + const char *str = va_arg(ap, const char *); + va_end(ap); + return SDL_RenderDebugText(renderer, x, y, str); + } + + char *str = NULL; + const int rc = SDL_vasprintf(&str, fmt, ap); + va_end(ap); + + if (rc == -1) { + return false; + } + + const bool retval = SDL_RenderDebugText(renderer, x, y, str); + SDL_free(str); + return retval; +} -- cgit v1.2.3