Initial Commit

2026-02-12 11:46:06 +03:00
commit b044c8d1a5
3973 changed files with 1599881 additions and 0 deletions
--- a/thirdparty/SDL3-3.4.0/src/render/ngage/SDL_render_ngage.c
+++ b/thirdparty/SDL3-3.4.0/src/render/ngage/SDL_render_ngage.c
@@ -0,0 +1,536 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  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"
+
+#ifdef SDL_VIDEO_RENDER_NGAGE
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#ifndef Int2Fix
+#define Int2Fix(i) ((i) << 16)
+#endif
+
+#ifndef Fix2Int
+#define Fix2Int(i) ((((unsigned int)(i) > 0xFFFF0000) ? 0 : ((i) >> 16)))
+#endif
+
+#ifndef Fix2Real
+#define Fix2Real(i) ((i) / 65536.0)
+#endif
+
+#ifndef Real2Fix
+#define Real2Fix(i) ((int)((i) * 65536.0))
+#endif
+
+#include "../SDL_sysrender.h"
+#include "SDL_render_ngage_c.h"
+
+static void NGAGE_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event);
+static bool NGAGE_GetOutputSize(SDL_Renderer *renderer, int *w, int *h);
+static bool NGAGE_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+static bool NGAGE_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);
+static bool NGAGE_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+static bool NGAGE_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+static bool NGAGE_QueueDrawVertices(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count);
+static bool NGAGE_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count);
+static bool NGAGE_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect);
+static bool NGAGE_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y);
+static bool NGAGE_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, int num_vertices, const void *indices, int num_indices, int size_indices, float scale_x, float scale_y);
+
+static void NGAGE_InvalidateCachedState(SDL_Renderer *renderer);
+static bool NGAGE_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
+static bool NGAGE_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch);
+
+static bool NGAGE_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch);
+static void NGAGE_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+static bool NGAGE_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture);
+static SDL_Surface *NGAGE_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect);
+static bool NGAGE_RenderPresent(SDL_Renderer *renderer);
+static void NGAGE_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+
+static void NGAGE_DestroyRenderer(SDL_Renderer *renderer);
+
+static bool NGAGE_SetVSync(SDL_Renderer *renderer, int vsync);
+
+static bool NGAGE_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_RGB_DEFAULT) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    NGAGE_RendererData *phdata = SDL_calloc(1, sizeof(NGAGE_RendererData));
+    if (!phdata) {
+        SDL_OutOfMemory();
+        return false;
+    }
+
+    renderer->WindowEvent = NGAGE_WindowEvent;
+    renderer->GetOutputSize = NGAGE_GetOutputSize;
+    renderer->SupportsBlendMode = NGAGE_SupportsBlendMode;
+    renderer->CreateTexture = NGAGE_CreateTexture;
+    renderer->QueueSetViewport = NGAGE_QueueSetViewport;
+    renderer->QueueSetDrawColor = NGAGE_QueueSetDrawColor;
+    renderer->QueueDrawPoints = NGAGE_QueueDrawVertices;
+    renderer->QueueDrawLines = NGAGE_QueueDrawVertices;
+    renderer->QueueFillRects = NGAGE_QueueFillRects;
+    renderer->QueueCopy = NGAGE_QueueCopy;
+    renderer->QueueCopyEx = NGAGE_QueueCopyEx;
+    renderer->QueueGeometry = NGAGE_QueueGeometry;
+    renderer->InvalidateCachedState = NGAGE_InvalidateCachedState;
+    renderer->RunCommandQueue = NGAGE_RunCommandQueue;
+    renderer->UpdateTexture = NGAGE_UpdateTexture;
+    renderer->LockTexture = NGAGE_LockTexture;
+    renderer->UnlockTexture = NGAGE_UnlockTexture;
+    renderer->SetRenderTarget = NGAGE_SetRenderTarget;
+    renderer->RenderReadPixels = NGAGE_RenderReadPixels;
+    renderer->RenderPresent = NGAGE_RenderPresent;
+    renderer->DestroyTexture = NGAGE_DestroyTexture;
+    renderer->DestroyRenderer = NGAGE_DestroyRenderer;
+    renderer->SetVSync = NGAGE_SetVSync;
+
+    renderer->name = NGAGE_RenderDriver.name;
+    renderer->window = window;
+    renderer->internal = phdata;
+    renderer->npot_texture_wrap_unsupported = true;
+
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB4444);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 1024);
+    SDL_SetHintWithPriority(SDL_HINT_RENDER_LINE_METHOD, "2", SDL_HINT_OVERRIDE);
+
+    return true;
+}
+
+SDL_RenderDriver NGAGE_RenderDriver = {
+    NGAGE_CreateRenderer,
+    "N-Gage"
+};
+
+static void NGAGE_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    return;
+}
+
+static bool NGAGE_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
+{
+    return true;
+}
+
+static bool NGAGE_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    switch (blendMode) {
+    case SDL_BLENDMODE_NONE:
+    case SDL_BLENDMODE_MOD:
+        return true;
+    default:
+        return false;
+    }
+}
+
+static bool NGAGE_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    NGAGE_TextureData *data = (NGAGE_TextureData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    if (!NGAGE_CreateTextureData(data, texture->w, texture->h)) {
+        SDL_free(data);
+        return false;
+    }
+
+    SDL_Surface *surface = SDL_CreateSurface(texture->w, texture->h, texture->format);
+    if (!surface) {
+        SDL_free(data);
+        return false;
+    }
+
+    data->surface = surface;
+    texture->internal = data;
+
+    return true;
+}
+
+static bool NGAGE_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    if (!cmd->data.viewport.rect.w && !cmd->data.viewport.rect.h) {
+        SDL_Rect viewport = { 0, 0, NGAGE_SCREEN_WIDTH, NGAGE_SCREEN_HEIGHT };
+        SDL_SetRenderViewport(renderer, &viewport);
+    }
+
+    return true;
+}
+
+static bool NGAGE_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true;
+}
+
+static bool NGAGE_QueueDrawVertices(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    NGAGE_Vertex *verts = (NGAGE_Vertex *)SDL_AllocateRenderVertices(renderer, count * sizeof(NGAGE_Vertex), 0, &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    for (int i = 0; i < count; i++, points++) {
+        int fixed_x = Real2Fix(points->x);
+        int fixed_y = Real2Fix(points->y);
+
+        verts[i].x = Fix2Int(fixed_x);
+        verts[i].y = Fix2Int(fixed_y);
+
+        Uint32 color = NGAGE_ConvertColor(cmd->data.draw.color.r, cmd->data.draw.color.g, cmd->data.draw.color.b, cmd->data.draw.color.a, cmd->data.draw.color_scale);
+
+        verts[i].color.a = (Uint8)(color >> 24);
+        verts[i].color.b = (Uint8)(color >> 16);
+        verts[i].color.g = (Uint8)(color >> 8);
+        verts[i].color.r = (Uint8)color;
+    }
+
+    return true;
+}
+
+static bool NGAGE_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
+{
+    NGAGE_Vertex *verts = (NGAGE_Vertex *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(NGAGE_Vertex), 0, &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    for (int i = 0; i < count; i++, rects++) {
+        verts[i * 2].x = Real2Fix(rects->x);
+        verts[i * 2].y = Real2Fix(rects->y);
+        verts[i * 2 + 1].x = Real2Fix(rects->w);
+        verts[i * 2 + 1].y = Real2Fix(rects->h);
+
+        verts[i * 2].x = Fix2Int(verts[i * 2].x);
+        verts[i * 2].y = Fix2Int(verts[i * 2].y);
+        verts[i * 2 + 1].x = Fix2Int(verts[i * 2 + 1].x);
+        verts[i * 2 + 1].y = Fix2Int(verts[i * 2 + 1].y);
+
+        Uint32 color = NGAGE_ConvertColor(cmd->data.draw.color.r, cmd->data.draw.color.g, cmd->data.draw.color.b, cmd->data.draw.color.a, cmd->data.draw.color_scale);
+
+        verts[i * 2].color.a = (Uint8)(color >> 24);
+        verts[i * 2].color.b = (Uint8)(color >> 16);
+        verts[i * 2].color.g = (Uint8)(color >> 8);
+        verts[i * 2].color.r = (Uint8)color;
+    }
+
+    return true;
+}
+
+static bool NGAGE_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    SDL_Rect *verts = (SDL_Rect *)SDL_AllocateRenderVertices(renderer, 2 * sizeof(SDL_Rect), 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = 1;
+
+    verts->x = (int)srcrect->x;
+    verts->y = (int)srcrect->y;
+    verts->w = (int)srcrect->w;
+    verts->h = (int)srcrect->h;
+
+    verts++;
+
+    verts->x = (int)dstrect->x;
+    verts->y = (int)dstrect->y;
+    verts->w = (int)dstrect->w;
+    verts->h = (int)dstrect->h;
+
+    return true;
+}
+
+static bool NGAGE_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_FRect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
+{
+    NGAGE_CopyExData *verts = (NGAGE_CopyExData *)SDL_AllocateRenderVertices(renderer, sizeof(NGAGE_CopyExData), 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = 1;
+
+    verts->srcrect.x = (int)srcquad->x;
+    verts->srcrect.y = (int)srcquad->y;
+    verts->srcrect.w = (int)srcquad->w;
+    verts->srcrect.h = (int)srcquad->h;
+    verts->dstrect.x = (int)dstrect->x;
+    verts->dstrect.y = (int)dstrect->y;
+    verts->dstrect.w = (int)dstrect->w;
+    verts->dstrect.h = (int)dstrect->h;
+
+    verts->angle = Real2Fix(angle);
+    verts->center.x = Real2Fix(center->x);
+    verts->center.y = Real2Fix(center->y);
+    verts->scale_x = Real2Fix(scale_x);
+    verts->scale_y = Real2Fix(scale_y);
+
+    verts->flip = flip;
+
+    return true;
+}
+
+static bool NGAGE_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride, int num_vertices, const void *indices, int num_indices, int size_indices, float scale_x, float scale_y)
+{
+    return true;
+}
+
+static void NGAGE_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    return;
+}
+
+static bool NGAGE_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    NGAGE_RendererData *phdata = (NGAGE_RendererData *)renderer->internal;
+    if (!phdata) {
+        return false;
+    }
+    phdata->viewport = 0;
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        case SDL_RENDERCMD_SETVIEWPORT:
+            phdata->viewport = &cmd->data.viewport.rect;
+            break;
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+
+            if (cmd->data.cliprect.enabled) {
+                NGAGE_SetClipRect(rect);
+            }
+
+            break;
+        }
+
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            Uint32 color = NGAGE_ConvertColor(cmd->data.color.color.r, cmd->data.color.color.g, cmd->data.color.color.b, cmd->data.color.color.a, cmd->data.color.color_scale);
+
+            NGAGE_Clear(color);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const int count = cmd->data.draw.count;
+
+            // Apply viewport.
+            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
+                for (int i = 0; i < count; i++) {
+                    verts[i].x += phdata->viewport->x;
+                    verts[i].y += phdata->viewport->y;
+                }
+            }
+
+            NGAGE_DrawPoints(verts, count);
+            break;
+        }
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const int count = cmd->data.draw.count;
+
+            // Apply viewport.
+            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
+                for (int i = 0; i < count; i++) {
+                    verts[i].x += phdata->viewport->x;
+                    verts[i].y += phdata->viewport->y;
+                }
+            }
+
+            NGAGE_DrawLines(verts, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS:
+        {
+            NGAGE_Vertex *verts = (NGAGE_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const int count = cmd->data.draw.count;
+
+            // Apply viewport.
+            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
+                for (int i = 0; i < count; i++) {
+                    verts[i].x += phdata->viewport->x;
+                    verts[i].y += phdata->viewport->y;
+                }
+            }
+
+            NGAGE_FillRects(verts, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY:
+        {
+            SDL_Rect *verts = (SDL_Rect *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            SDL_Rect *srcrect = verts;
+            SDL_Rect *dstrect = verts + 1;
+            SDL_Texture *texture = cmd->data.draw.texture;
+
+            // Apply viewport.
+            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
+                dstrect->x += phdata->viewport->x;
+                dstrect->y += phdata->viewport->y;
+            }
+
+            NGAGE_Copy(renderer, texture, srcrect, dstrect);
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY_EX:
+        {
+            NGAGE_CopyExData *copydata = (NGAGE_CopyExData *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            SDL_Texture *texture = cmd->data.draw.texture;
+
+            // Apply viewport.
+            if (phdata->viewport && (phdata->viewport->x || phdata->viewport->y)) {
+                copydata->dstrect.x += phdata->viewport->x;
+                copydata->dstrect.y += phdata->viewport->y;
+            }
+
+            NGAGE_CopyEx(renderer, texture, copydata);
+            break;
+        }
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            break;
+        }
+        }
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static bool NGAGE_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    NGAGE_TextureData *phdata = (NGAGE_TextureData *)texture->internal;
+
+    SDL_Surface *surface = phdata->surface;
+    Uint8 *src, *dst;
+    int row;
+    size_t length;
+
+    if (SDL_MUSTLOCK(surface)) {
+        if (!SDL_LockSurface(surface)) {
+            return false;
+        }
+    }
+    src = (Uint8 *)pixels;
+    dst = (Uint8 *)surface->pixels +
+          rect->y * surface->pitch +
+          rect->x * surface->fmt->bytes_per_pixel;
+
+    length = (size_t)rect->w * surface->fmt->bytes_per_pixel;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += pitch;
+        dst += surface->pitch;
+    }
+    if (SDL_MUSTLOCK(surface)) {
+        SDL_UnlockSurface(surface);
+    }
+
+    return true;
+}
+
+static bool NGAGE_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    NGAGE_TextureData *phdata = (NGAGE_TextureData *)texture->internal;
+    SDL_Surface *surface = phdata->surface;
+
+    *pixels =
+        (void *)((Uint8 *)surface->pixels + rect->y * surface->pitch +
+                 rect->x * surface->fmt->bytes_per_pixel);
+    *pitch = surface->pitch;
+    return true;
+}
+
+static void NGAGE_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+}
+
+static bool NGAGE_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    return true;
+}
+
+static SDL_Surface *NGAGE_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    return (SDL_Surface *)0;
+}
+
+static bool NGAGE_RenderPresent(SDL_Renderer *renderer)
+{
+    NGAGE_Flip();
+
+    return true;
+}
+
+static void NGAGE_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    NGAGE_TextureData *data = (NGAGE_TextureData *)texture->internal;
+    if (data) {
+        SDL_DestroySurface(data->surface);
+        NGAGE_DestroyTextureData(data);
+        SDL_free(data);
+        texture->internal = 0;
+    }
+}
+
+static void NGAGE_DestroyRenderer(SDL_Renderer *renderer)
+{
+    NGAGE_RendererData *phdata = (NGAGE_RendererData *)renderer->internal;
+    if (phdata) {
+        SDL_free(phdata);
+        renderer->internal = 0;
+    }
+}
+
+static bool NGAGE_SetVSync(SDL_Renderer *renderer, int vsync)
+{
+    return true;
+}
+
+#endif // SDL_VIDEO_RENDER_NGAGE