Merge ea3e29be5c into c73dffbb6f

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [nicbarker]

bindings/D/README.md

@@ -0,0 +1,5 @@
+### D Language Example
+
+```
+dmd main.d clay.c
+```

bindings/D/clay.c

@@ -0,0 +1,2 @@
+#define CLAY_IMPLEMENTATION
+#include "../../clay.h"

bindings/D/main.d

@@ -0,0 +1,88 @@
+import clay;
+
+import core.stdc.stdlib;
+
+__gshared:
+
+Clay_LayoutConfig layoutElement = { padding: {5} };
+
+extern(C) void main()
+{
+    ulong totalMemorySize = Clay_MinMemorySize();
+    Clay_Arena clayMemory = {
+        label: str("Clay Memory Arena"),
+        capacity: totalMemorySize,
+        memory: cast(char*)malloc(totalMemorySize)
+    };
+
+    Clay_Initialize(clayMemory, Clay_Dimensions(1024,768));
+    Clay_BeginLayout();
+    if (ClayBegin( Rectangle(color: Clay_Color(255,255,255,0)), Layout(layoutElement)))
+    {   }
+    ClayEnd();
+}
+
+
+// helper functions
+Clay_String str(string it)
+{
+    return Clay_String(cast(int)it.length, it.ptr);
+}
+
+bool ClayBegin(A...)(A configs)
+{
+    Clay__OpenElement();
+    foreach(config; configs)
+    {
+        alias T = typeof(config);
+        static if (is(T == Clay_ElementId))
+        {
+            Clay__AttachId(config);
+        }
+        else static if(is(T == Clay_LayoutConfig*))
+        {
+            Clay__AttachLayoutConfig(config);
+        }
+        else static if(is(T == Clay_ElementConfig))
+        {
+            Clay__AttachElementConfig(config.config, config.type);
+        }
+        else static assert(0, "unsupported " ~ typeof(config).stringof);
+    }
+
+    Clay__ElementPostConfiguration();
+    return true;
+}
+
+void ClayEnd()
+{
+    Clay__CloseElement();
+}
+
+Clay_ElementId Id(string label)
+{
+     return Clay__HashString(str(label), 0, 0);
+}
+
+Clay_LayoutConfig* Layout(lazy Clay_Sizing sizing = Clay_Sizing.init)
+{
+    Clay_LayoutConfig config;
+    config.sizing = sizing;
+    return Clay__StoreLayoutConfig(config);
+}
+
+Clay_LayoutConfig* Layout(Clay_LayoutConfig config)
+{
+    return Clay__StoreLayoutConfig(config);
+}
+
+Clay_ElementConfig Rectangle(lazy Clay_Color color = Clay_Color.init)
+{
+    Clay_RectangleElementConfig config;
+    config.color = color;
+
+    Clay_ElementConfig ret;
+    ret.type = Clay__ElementConfigType.CLAY__ELEMENT_CONFIG_TYPE_RECTANGLE;
+    ret.config.rectangleElementConfig = Clay__StoreRectangleElementConfig(config);
+    return ret;
+}

clay.h

@@ -1598,6 +1598,25 @@ bool Clay__ElementHasConfig(Clay_LayoutElement *layoutElement, Clay__ElementConf
     return false;
 }
 
+void Clay__UpdateAspectRatioBox(Clay_LayoutElement *layoutElement) {
+    for (int32_t j = 0; j < layoutElement->elementConfigs.length; j++) {
+        Clay_ElementConfig *config = Clay__ElementConfigArraySlice_Get(&layoutElement->elementConfigs, j);
+        if (config->type == CLAY__ELEMENT_CONFIG_TYPE_IMAGE) {
+            Clay_ImageElementConfig *imageConfig = config->config.imageElementConfig;
+            if (imageConfig->sourceDimensions.width == 0 || imageConfig->sourceDimensions.height == 0) {
+                break;
+            }
+            float aspect = imageConfig->sourceDimensions.width / imageConfig->sourceDimensions.height;
+            if (layoutElement->dimensions.width == 0 && layoutElement->dimensions.height != 0) {
+                layoutElement->dimensions.width = layoutElement->dimensions.height * aspect;
+            } else if (layoutElement->dimensions.width != 0 && layoutElement->dimensions.height == 0) {
+                layoutElement->dimensions.height = layoutElement->dimensions.height * (1 / aspect);
+            }
+            break;
+        }
+    }
+}
+
 void Clay__CloseElement(void) {
     Clay_Context* context = Clay_GetCurrentContext();
     if (context->booleanWarnings.maxElementsExceeded) {
@@ -1684,6 +1703,8 @@ void Clay__CloseElement(void) {
         openLayoutElement->dimensions.height = 0;
     }
 
+    Clay__UpdateAspectRatioBox(openLayoutElement);
+
     bool elementIsFloating = Clay__ElementHasConfig(openLayoutElement, CLAY__ELEMENT_CONFIG_TYPE_FLOATING);
 
     // Close the currently open element
@@ -2125,6 +2146,7 @@ void Clay__SizeContainersAlongAxis(bool xAxis) {
                     if (sizingAlongAxis) {
                         innerContentSize += *childSize;
                     }
+                    Clay__UpdateAspectRatioBox(childElement);
                 }
             }
 

examples/SDL3-simple-demo/CMakeLists.txt

@@ -14,7 +14,7 @@ set(FETCHCONTENT_QUIET FALSE)
 FetchContent_Declare(
 	SDL
 	GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-	GIT_TAG preview-3.1.6
+	GIT_TAG release-3.2.4
 	GIT_SHALLOW TRUE
 	GIT_PROGRESS TRUE
 )
@@ -34,11 +34,24 @@ message(STATUS "Using SDL_ttf via FetchContent")
 FetchContent_MakeAvailable(SDL_ttf)
 set_property(DIRECTORY "${sdl_ttf_SOURCE_DIR}" PROPERTY EXCLUDE_FROM_ALL TRUE)
 
+# Download SDL_image
+FetchContent_Declare(
+	SDL_image
+	GIT_REPOSITORY "https://github.com/libsdl-org/SDL_image.git"
+	GIT_TAG release-3.2.0 # Slightly risky to use main branch, but it's the only one available
+	GIT_SHALLOW TRUE
+	GIT_PROGRESS TRUE
+)
+message(STATUS "Using SDL_image via FetchContent")
+FetchContent_MakeAvailable(SDL_image)
+set_property(DIRECTORY "${SDL_image_SOURCE_DIR}" PROPERTY EXCLUDE_FROM_ALL TRUE)
+
 # Example executable
 add_executable(${PROJECT_NAME} main.c)
 target_link_libraries(${PROJECT_NAME} PRIVATE
 	SDL3::SDL3
 	SDL3_ttf::SDL3_ttf
+	SDL3_image::SDL3_image
 )
 
 add_custom_command(

examples/SDL3-simple-demo/main.c

@@ -19,13 +19,16 @@ static const Clay_Color COLOR_LIGHT     = (Clay_Color) {224, 215, 210, 255};
 
 typedef struct app_state {
     SDL_Window *window;
-    SDL_Renderer *renderer;
+    Clay_SDL3RendererData rendererData;
     ClayVideoDemo_Data demoData;
 } AppState;
 
+SDL_Surface *sample_image;
+
 static inline Clay_Dimensions SDL_MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData)
 {
-    TTF_Font *font = gFonts[config->fontId];
+    TTF_Font **fonts = userData;
+    TTF_Font *font = fonts[config->fontId];
     int width, height;
 
     if (!TTF_GetStringSize(font, text.chars, text.length, &width, &height)) {
@@ -54,19 +57,33 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
     }
     *appstate = state;
 
-    if (!SDL_CreateWindowAndRenderer("Clay Demo", 640, 480, 0, &state->window, &state->renderer)) {
+    if (!SDL_CreateWindowAndRenderer("Clay Demo", 640, 480, 0, &state->window, &state->rendererData.renderer)) {
         SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Failed to create window and renderer: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }
     SDL_SetWindowResizable(state->window, true);
 
+    state->rendererData.textEngine = TTF_CreateRendererTextEngine(state->rendererData.renderer);
+    if (!state->rendererData.textEngine) {
+        SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Failed to create text engine from renderer: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    state->rendererData.fonts = SDL_calloc(1, sizeof(TTF_Font *));
+    if (!state->rendererData.fonts) {
+        SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Failed to allocate memory for the font array: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
     TTF_Font *font = TTF_OpenFont("resources/Roboto-Regular.ttf", 24);
     if (!font) {
         SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Failed to load font: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }
 
-    gFonts[FONT_ID] = font;
+    state->rendererData.fonts[FONT_ID] = font;
+
+    sample_image = IMG_Load("resources/sample.png");
 
     /* Initialize Clay */
     uint64_t totalMemorySize = Clay_MinMemorySize();
@@ -78,7 +95,7 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
     int width, height;
     SDL_GetWindowSize(state->window, &width, &height);
     Clay_Initialize(clayMemory, (Clay_Dimensions) { (float) width, (float) height }, (Clay_ErrorHandler) { HandleClayErrors });
-    Clay_SetMeasureTextFunction(SDL_MeasureText, 0);
+    Clay_SetMeasureTextFunction(SDL_MeasureText, state->rendererData.fonts);
 
     state->demoData = ClayVideoDemo_Initialize();
 
@@ -99,10 +116,14 @@ SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
             break;
         case SDL_EVENT_MOUSE_MOTION:
             Clay_SetPointerState((Clay_Vector2) { event->motion.x, event->motion.y },
-                                 event->motion.state & SDL_BUTTON_LEFT);
+                                 event->motion.state & SDL_BUTTON_LMASK);
+            break;
+        case SDL_EVENT_MOUSE_BUTTON_DOWN:
+            Clay_SetPointerState((Clay_Vector2) { event->button.x, event->button.y },
+                                 event->button.button == SDL_BUTTON_LEFT);
             break;
         case SDL_EVENT_MOUSE_WHEEL:
-            Clay_UpdateScrollContainers(true, (Clay_Vector2) { event->motion.xrel, event->motion.yrel }, 0.01f);
+            Clay_UpdateScrollContainers(true, (Clay_Vector2) { event->wheel.x, event->wheel.y }, 0.01f);
             break;
         default:
             break;
@@ -117,12 +138,12 @@ SDL_AppResult SDL_AppIterate(void *appstate)
 
     Clay_RenderCommandArray render_commands = ClayVideoDemo_CreateLayout(&state->demoData);
 
-    SDL_SetRenderDrawColor(state->renderer, 0, 0, 0, 255);
+    SDL_SetRenderDrawColor(state->rendererData.renderer, 0, 0, 0, 255);
-    SDL_RenderClear(state->renderer);
+    SDL_RenderClear(state->rendererData.renderer);
 
-    SDL_RenderClayCommands(state->renderer, &render_commands);
+    SDL_Clay_RenderClayCommands(&state->rendererData, &render_commands);
 
-    SDL_RenderPresent(state->renderer);
+    SDL_RenderPresent(state->rendererData.renderer);
 
     return SDL_APP_CONTINUE;
 }
@@ -138,12 +159,23 @@ void SDL_AppQuit(void *appstate, SDL_AppResult result)
     AppState *state = appstate;
 
     if (state) {
-        if (state->renderer)
+        if (state->rendererData.renderer)
-            SDL_DestroyRenderer(state->renderer);
+            SDL_DestroyRenderer(state->rendererData.renderer);
 
         if (state->window)
             SDL_DestroyWindow(state->window);
 
+        if (state->rendererData.fonts) {
+            for(size_t i = 0; i < sizeof(state->rendererData.fonts) / sizeof(*state->rendererData.fonts); i++) {
+                TTF_CloseFont(state->rendererData.fonts[i]);
+            }
+
+            SDL_free(state->rendererData.fonts);
+        }
+
+        if (state->rendererData.textEngine)
+            TTF_DestroyRendererTextEngine(state->rendererData.textEngine);
+
         SDL_free(state);
     }
     TTF_Quit();

renderers/SDL2/clay_renderer_SDL2.c

@@ -4,6 +4,10 @@
 #include <SDL_image.h>
 #include <stdio.h>
 
+#ifndef M_PI
+    #define M_PI 3.14159
+#endif
+
 #define CLAY_COLOR_TO_SDL_COLOR_ARGS(color) color.r, color.g, color.b, color.a
 
 typedef struct
@@ -48,8 +52,8 @@ static void SDL_RenderFillRoundedRect(SDL_Renderer* renderer, const SDL_FRect re
 
     int indexCount = 0, vertexCount = 0;
 
-    const float minRadius = SDL_min(rect.w, rect.h) / 2.0f;
+    const float maxRadius = SDL_min(rect.w, rect.h) / 2.0f;
-    const float clampedRadius = SDL_min(cornerRadius, minRadius);
+    const float clampedRadius = SDL_min(cornerRadius, maxRadius);
 
     const int numCircleSegments = SDL_max(NUM_CIRCLE_SEGMENTS, (int)clampedRadius * 0.5f);
 
@@ -141,6 +145,121 @@ static void SDL_RenderFillRoundedRect(SDL_Renderer* renderer, const SDL_FRect re
     SDL_RenderGeometry(renderer, NULL, vertices, vertexCount, indices, indexCount);
 }
 
+//all rendering is performed by a single SDL call, using twi sets of arcing triangles, inner and outer, that fit together; along with two tringles to fill the end gaps.
+void SDL_RenderCornerBorder(SDL_Renderer *renderer, Clay_BoundingBox* boundingBox, Clay_BorderRenderData* config, int cornerIndex, Clay_Color _color){
+    /////////////////////////////////
+    //The arc is constructed of outer triangles and inner triangles (if needed).
+    //First three vertices are first outer triangle's vertices
+    //Each two vertices after that are the inner-middle and second-outer vertex of 
+    //each outer triangle after the first, because there first-outer vertex is equal to the
+    //second-outer vertex of the previous triangle. Indices set accordingly.
+    //The final two vertices are the missing vertices for the first and last inner triangles (if needed)
+    //Everything is in clockwise order (CW).
+    /////////////////////////////////
+    const SDL_Color color = (SDL_Color) {
+        .r = (Uint8)_color.r,
+        .g = (Uint8)_color.g,
+        .b = (Uint8)_color.b,
+        .a = (Uint8)_color.a,
+    };
+
+    float centerX, centerY, outerRadius, clampedRadius, startAngle, borderWidth;
+    const float maxRadius = SDL_min(boundingBox->width, boundingBox->height) / 2.0f;
+    
+    SDL_Vertex vertices[512];
+    int indices[512];
+    int indexCount = 0, vertexCount = 0;
+
+    switch (cornerIndex) {
+        case(0):
+            startAngle = M_PI; 
+            outerRadius = SDL_min(config->cornerRadius.topLeft, maxRadius);
+            centerX = boundingBox->x + outerRadius; 
+            centerY = boundingBox->y + outerRadius; 
+            borderWidth = config->width.top;
+        break;
+        case(1):
+            startAngle = 3*M_PI/2;
+            outerRadius = SDL_min(config->cornerRadius.topRight, maxRadius);
+            centerX = boundingBox->x + boundingBox->width - outerRadius; 
+            centerY = boundingBox->y + outerRadius; 
+            borderWidth = config->width.top;
+            break;
+        case(2):
+            startAngle = 0;
+            outerRadius = SDL_min(config->cornerRadius.bottomRight, maxRadius);
+            centerX = boundingBox->x + boundingBox->width - outerRadius; 
+            centerY = boundingBox->y + boundingBox->height - outerRadius; 
+            borderWidth = config->width.bottom;
+            break;
+        case(3):
+            startAngle = M_PI/2;
+            outerRadius = SDL_min(config->cornerRadius.bottomLeft, maxRadius);
+            centerX = boundingBox->x + outerRadius; 
+            centerY = boundingBox->y + boundingBox->height - outerRadius; 
+            borderWidth = config->width.bottom;
+            break;
+        default: break;
+    }
+    
+    const float innerRadius = outerRadius - borderWidth;
+    const int minNumOuterTriangles = NUM_CIRCLE_SEGMENTS;
+    const int numOuterTriangles = SDL_max(minNumOuterTriangles, ceilf(outerRadius * 0.5f));
+    const float angleStep = M_PI / (2.0*(float)numOuterTriangles);
+
+    //outer triangles, in CW order
+    for (int i = 0; i < numOuterTriangles; i++) { 
+        float angle1 =  startAngle + i*angleStep; //first-outer vertex angle
+        float angle2 =  startAngle + ((float)i + 0.5) * angleStep; //inner-middle vertex angle
+        float angle3 =  startAngle + (i+1)*angleStep; // second-outer vertex angle
+
+        if( i == 0){ //first outer triangle
+            vertices[vertexCount++] = (SDL_Vertex){ {centerX + SDL_cosf(angle1) * outerRadius, centerY + SDL_sinf(angle1) * outerRadius}, color, {0, 0} }; //vertex index = 0
+        }
+        indices[indexCount++] = vertexCount - 1; //will be second-outer vertex of last outer triangle if not first outer triangle.
+
+        vertices[vertexCount++] = (innerRadius > 0)?
+            (SDL_Vertex){ {centerX + SDL_cosf(angle2) * (innerRadius), centerY + SDL_sinf(angle2) * (innerRadius)}, color, {0, 0}}:
+            (SDL_Vertex){ {centerX, centerY }, color, {0, 0}};
+        indices[indexCount++] = vertexCount - 1;
+
+        vertices[vertexCount++] = (SDL_Vertex){ {centerX + SDL_cosf(angle3) * outerRadius, centerY + SDL_sinf(angle3) * outerRadius}, color, {0, 0} };
+        indices[indexCount++] = vertexCount - 1;
+    }
+
+    if(innerRadius > 0){
+        // inner triangles in CW order (except the first and last)
+        for (int i = 0; i < numOuterTriangles - 1; i++){ //skip the last outer triangle
+            if(i==0){ //first outer triangle -> second inner triangle
+                indices[indexCount++] = 1; //inner-middle vertex of first outer triangle
+                indices[indexCount++] = 2; //second-outer vertex of first outer triangle
+                indices[indexCount++] = 3; //innder-middle vertex of second-outer triangle
+            }else{
+                int baseIndex = 3; //skip first outer triangle
+                indices[indexCount++] = baseIndex + (i-1)*2; // inner-middle vertex of current outer triangle
+                indices[indexCount++] = baseIndex + (i-1)*2 + 1; // second-outer vertex of current outer triangle
+                indices[indexCount++] = baseIndex + (i-1)*2 + 2; // inner-middle vertex of next outer triangle
+            }
+        }
+
+        float endAngle = startAngle + M_PI/2.0;
+
+        //last inner triangle
+        indices[indexCount++] = vertexCount - 2; //inner-middle vertex of last outer triangle
+        indices[indexCount++] = vertexCount - 1; //second-outer vertex of last outer triangle
+        vertices[vertexCount++] = (SDL_Vertex){ {centerX + SDL_cosf(endAngle) * innerRadius, centerY + SDL_sinf(endAngle) * innerRadius}, color, {0, 0} }; //missing vertex
+        indices[indexCount++] = vertexCount - 1; 
+        
+        // //first inner triangle
+        indices[indexCount++] = 0; //first-outer vertex of first outer triangle
+        indices[indexCount++] = 1; //inner-middle vertex of first outer triangle
+        vertices[vertexCount++] = (SDL_Vertex){ {centerX + SDL_cosf(startAngle) * innerRadius, centerY + SDL_sinf(startAngle) * innerRadius}, color, {0, 0} }; //missing vertex
+        indices[indexCount++] = vertexCount - 1; 
+    }
+
+    SDL_RenderGeometry(renderer, NULL, vertices, vertexCount, indices, indexCount);
+}
+
 SDL_Rect currentClippingRectangle;
 
 static void Clay_SDL2_Render(SDL_Renderer *renderer, Clay_RenderCommandArray renderCommands, SDL2_Font *fonts)
@@ -228,35 +347,74 @@ static void Clay_SDL2_Render(SDL_Renderer *renderer, Clay_RenderCommandArray ren
             }
             case CLAY_RENDER_COMMAND_TYPE_BORDER: {
                 Clay_BorderRenderData *config = &renderCommand->renderData.border;
+                SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
 
-                if (config->width.left > 0) {
+                if(boundingBox.width > 0 & boundingBox.height > 0){
-                    SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
+                    const float maxRadius = SDL_min(boundingBox.width, boundingBox.height) / 2.0f;
-                    SDL_FRect rect = { boundingBox.x, boundingBox.y + config->cornerRadius.topLeft, config->width.left, boundingBox.height - config->cornerRadius.topLeft - config->cornerRadius.bottomLeft };
-                    SDL_RenderFillRectF(renderer, &rect);
-                }
 
-                if (config->width.right > 0) {
+                    if (config->width.left > 0) {
-                    SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
+                        const float clampedRadiusTop = SDL_min((float)config->cornerRadius.topLeft, maxRadius);
-                    SDL_FRect rect = { boundingBox.x + boundingBox.width - config->width.right, boundingBox.y + config->cornerRadius.topRight, config->width.right, boundingBox.height - config->cornerRadius.topRight - config->cornerRadius.bottomRight };
+                        const float clampedRadiusBottom = SDL_min((float)config->cornerRadius.bottomLeft, maxRadius);
-                    SDL_RenderFillRectF(renderer, &rect);
+                        SDL_FRect rect = { 
-                }
+                            boundingBox.x, 
+                            boundingBox.y + clampedRadiusTop, 
+                            (float)config->width.left, 
+                            (float)boundingBox.height - clampedRadiusTop - clampedRadiusBottom
+                        };
+                        SDL_RenderFillRectF(renderer, &rect);
+                    }
+    
+                    if (config->width.right > 0) {
+                        const float clampedRadiusTop = SDL_min((float)config->cornerRadius.topRight, maxRadius);
+                        const float clampedRadiusBottom = SDL_min((float)config->cornerRadius.bottomRight, maxRadius);
+                        SDL_FRect rect = { 
+                            boundingBox.x + boundingBox.width - config->width.right,
+                            boundingBox.y + clampedRadiusTop,
+                            (float)config->width.right,
+                            (float)boundingBox.height - clampedRadiusTop - clampedRadiusBottom
+                        };
+                        SDL_RenderFillRectF(renderer, &rect);
+                    }
+    
+                    if (config->width.top > 0) {
+                        const float clampedRadiusLeft = SDL_min((float)config->cornerRadius.topLeft, maxRadius);
+                        const float clampedRadiusRight = SDL_min((float)config->cornerRadius.topRight, maxRadius);
+                        SDL_FRect rect = { 
+                            boundingBox.x + clampedRadiusLeft, 
+                            boundingBox.y, 
+                            boundingBox.width - clampedRadiusLeft - clampedRadiusRight, 
+                            (float)config->width.top };
+                        SDL_RenderFillRectF(renderer, &rect);
+                    }
+    
+                    if (config->width.bottom > 0) {
+                        const float clampedRadiusLeft = SDL_min((float)config->cornerRadius.bottomLeft, maxRadius);
+                        const float clampedRadiusRight = SDL_min((float)config->cornerRadius.bottomRight, maxRadius);
+                        SDL_FRect rect = { 
+                            boundingBox.x + clampedRadiusLeft, 
+                            boundingBox.y + boundingBox.height - config->width.bottom, 
+                            boundingBox.width - clampedRadiusLeft - clampedRadiusRight, 
+                            (float)config->width.bottom 
+                        };
+                        SDL_RenderFillRectF(renderer, &rect);
+                    }
+    
+                    //corner index: 0->3 topLeft -> CW -> bottonLeft
+                    if (config->width.top > 0 & config->cornerRadius.topLeft > 0) {
+                        SDL_RenderCornerBorder(renderer, &boundingBox, config, 0, config->color);
+                    }
 
-                if (config->width.right > 0) {
+                    if (config->width.top > 0 & config->cornerRadius.topRight> 0) {
-                    SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
+                        SDL_RenderCornerBorder(renderer, &boundingBox, config, 1, config->color);
-                    SDL_FRect rect = { boundingBox.x + boundingBox.width - config->width.right, boundingBox.y + config->cornerRadius.topRight, config->width.right, boundingBox.height - config->cornerRadius.topRight - config->cornerRadius.bottomRight };
+                    }
-                    SDL_RenderFillRectF(renderer, &rect);
-                }
 
-                if (config->width.top > 0) {
+                    if (config->width.bottom > 0 & config->cornerRadius.bottomLeft > 0) {
-                    SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
+                        SDL_RenderCornerBorder(renderer, &boundingBox, config, 2, config->color);
-                    SDL_FRect rect = { boundingBox.x + config->cornerRadius.topLeft, boundingBox.y, boundingBox.width - config->cornerRadius.topLeft - config->cornerRadius.topRight, config->width.top };
+                    }
-                    SDL_RenderFillRectF(renderer, &rect);
-                }
 
-                if (config->width.bottom > 0) {
+                    if (config->width.bottom > 0 & config->cornerRadius.bottomLeft > 0) {
-                    SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
+                        SDL_RenderCornerBorder(renderer, &boundingBox, config, 3, config->color);
-                    SDL_FRect rect = { boundingBox.x + config->cornerRadius.bottomLeft, boundingBox.y + boundingBox.height - config->width.bottom, boundingBox.width - config->cornerRadius.bottomLeft - config->cornerRadius.bottomRight, config->width.bottom };
+                    }
-                    SDL_RenderFillRectF(renderer, &rect);
                 }
 
                 break;

renderers/SDL3/README

@@ -1,4 +0,0 @@
-Please note, the SDL3 renderer is not 100% feature complete. It is currently missing:
-
-- Images
-- Scroll / Scissor handling

renderers/SDL3/clay_renderer_SDL3.c

@@ -2,16 +2,20 @@
 #include <SDL3/SDL_main.h>
 #include <SDL3/SDL.h>
 #include <SDL3_ttf/SDL_ttf.h>
+#include <SDL3_image/SDL_image.h>
+
+typedef struct {
+    SDL_Renderer *renderer;
+    TTF_TextEngine *textEngine;
+    TTF_Font **fonts;
+} Clay_SDL3RendererData;
 
-/* This needs to be global because the "MeasureText" callback doesn't have a
- * user data parameter */
-static TTF_Font *gFonts[1];
 /* Global for convenience. Even in 4K this is enough for smooth curves (low radius or rect size coupled with
  * no AA or low resolution might make it appear as jagged curves) */
 static int NUM_CIRCLE_SEGMENTS = 16;
 
 //all rendering is performed by a single SDL call, avoiding multiple RenderRect + plumbing choice for circles.
-static void SDL_RenderFillRoundedRect(SDL_Renderer *renderer, const SDL_FRect rect, const float cornerRadius, const Clay_Color _color) {
+static void SDL_Clay_RenderFillRoundedRect(Clay_SDL3RendererData *rendererData, const SDL_FRect rect, const float cornerRadius, const Clay_Color _color) {
     const SDL_FColor color = { _color.r/255, _color.g/255, _color.b/255, _color.a/255 };
 
     int indexCount = 0, vertexCount = 0;
@@ -109,11 +113,11 @@ static void SDL_RenderFillRoundedRect(SDL_Renderer *renderer, const SDL_FRect re
     indices[indexCount++] = vertexCount - 1; //LT
 
     // Render everything
-    SDL_RenderGeometry(renderer, NULL, vertices, vertexCount, indices, indexCount);
+    SDL_RenderGeometry(rendererData->renderer, NULL, vertices, vertexCount, indices, indexCount);
 }
 
-static void SDL_RenderArc(SDL_Renderer *renderer, const SDL_FPoint center, const float radius, const float startAngle, const float endAngle, const float thickness, const Clay_Color color) {
+static void SDL_Clay_RenderArc(Clay_SDL3RendererData *rendererData, const SDL_FPoint center, const float radius, const float startAngle, const float endAngle, const float thickness, const Clay_Color color) {
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
+    SDL_SetRenderDrawColor(rendererData->renderer, color.r, color.g, color.b, color.a);
 
     const float radStart = startAngle * (SDL_PI_F / 180.0f);
     const float radEnd = endAngle * (SDL_PI_F / 180.0f);
@@ -133,38 +137,36 @@ static void SDL_RenderArc(SDL_Renderer *renderer, const SDL_FPoint center, const
                     SDL_roundf(center.x + SDL_cosf(angle) * clampedRadius),
                     SDL_roundf(center.y + SDL_sinf(angle) * clampedRadius) };
         }
-        SDL_RenderLines(renderer, points, numCircleSegments + 1);
+        SDL_RenderLines(rendererData->renderer, points, numCircleSegments + 1);
     }
 }
 
-static void SDL_RenderClayCommands(SDL_Renderer *renderer, Clay_RenderCommandArray *rcommands)
+SDL_Rect currentClippingRectangle;
+
+static void SDL_Clay_RenderClayCommands(Clay_SDL3RendererData *rendererData, Clay_RenderCommandArray *rcommands)
 {
     for (size_t i = 0; i < rcommands->length; i++) {
         Clay_RenderCommand *rcmd = Clay_RenderCommandArray_Get(rcommands, i);
         const Clay_BoundingBox bounding_box = rcmd->boundingBox;
-        const SDL_FRect rect = { bounding_box.x, bounding_box.y, bounding_box.width, bounding_box.height };
+        const SDL_FRect rect = { (int)bounding_box.x, (int)bounding_box.y, (int)bounding_box.width, (int)bounding_box.height };
 
         switch (rcmd->commandType) {
             case CLAY_RENDER_COMMAND_TYPE_RECTANGLE: {
                 Clay_RectangleRenderData *config = &rcmd->renderData.rectangle;
-                SDL_SetRenderDrawColor(renderer, config->backgroundColor.r, config->backgroundColor.g, config->backgroundColor.b, config->backgroundColor.a);
+                SDL_SetRenderDrawColor(rendererData->renderer, config->backgroundColor.r, config->backgroundColor.g, config->backgroundColor.b, config->backgroundColor.a);
                 if (config->cornerRadius.topLeft > 0) {
-                    SDL_RenderFillRoundedRect(renderer, rect, config->cornerRadius.topLeft, config->backgroundColor);
+                    SDL_Clay_RenderFillRoundedRect(rendererData, rect, config->cornerRadius.topLeft, config->backgroundColor);
                 } else {
-                    SDL_RenderFillRect(renderer, &rect);
+                    SDL_RenderFillRect(rendererData->renderer, &rect);
                 }
             } break;
             case CLAY_RENDER_COMMAND_TYPE_TEXT: {
                 Clay_TextRenderData *config = &rcmd->renderData.text;
-                const SDL_Color color = { config->textColor.r, config->textColor.g, config->textColor.b, config->textColor.a };
+                TTF_Font *font = rendererData->fonts[config->fontId];
-
+                TTF_Text *text = TTF_CreateText(rendererData->textEngine, font, config->stringContents.chars, config->stringContents.length);
-                TTF_Font *font = gFonts[config->fontId];
+                TTF_SetTextColor(text, config->textColor.r, config->textColor.g, config->textColor.b, config->textColor.a);
-                SDL_Surface *surface = TTF_RenderText_Blended(font, config->stringContents.chars, config->stringContents.length, color);
+                TTF_DrawRendererText(text, rect.x, rect.y);
-                SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
+                TTF_DestroyText(text);
-                SDL_RenderTexture(renderer, texture, NULL, &rect);
-
-                SDL_DestroySurface(surface);
-                SDL_DestroyTexture(texture);
             } break;
             case CLAY_RENDER_COMMAND_TYPE_BORDER: {
                 Clay_BorderRenderData *config = &rcmd->renderData.border;
@@ -177,61 +179,85 @@ static void SDL_RenderClayCommands(SDL_Renderer *renderer, Clay_RenderCommandArr
                     .bottomRight = SDL_min(config->cornerRadius.bottomRight, minRadius)
                 };
                 //edges
-                SDL_SetRenderDrawColor(renderer, config->color.r, config->color.g, config->color.b, config->color.a);
+                SDL_SetRenderDrawColor(rendererData->renderer, config->color.r, config->color.g, config->color.b, config->color.a);
                 if (config->width.left > 0) {
                     const float starting_y = rect.y + clampedRadii.topLeft;
                     const float length = rect.h - clampedRadii.topLeft - clampedRadii.bottomLeft;
                     SDL_FRect line = { rect.x, starting_y, config->width.left, length };
-                    SDL_RenderFillRect(renderer, &line);
+                    SDL_RenderFillRect(rendererData->renderer, &line);
                 }
                 if (config->width.right > 0) {
                     const float starting_x = rect.x + rect.w - (float)config->width.right;
                     const float starting_y = rect.y + clampedRadii.topRight;
                     const float length = rect.h - clampedRadii.topRight - clampedRadii.bottomRight;
                     SDL_FRect line = { starting_x, starting_y, config->width.right, length };
-                    SDL_RenderFillRect(renderer, &line);
+                    SDL_RenderFillRect(rendererData->renderer, &line);
                 }
                 if (config->width.top > 0) {
                     const float starting_x = rect.x + clampedRadii.topLeft;
                     const float length = rect.w - clampedRadii.topLeft - clampedRadii.topRight;
                     SDL_FRect line = { starting_x, rect.y, length, config->width.top };
-                    SDL_RenderFillRect(renderer, &line);
+                    SDL_RenderFillRect(rendererData->renderer, &line);
                 }
                 if (config->width.bottom > 0) {
                     const float starting_x = rect.x + clampedRadii.bottomLeft;
                     const float starting_y = rect.y + rect.h - (float)config->width.bottom;
                     const float length = rect.w - clampedRadii.bottomLeft - clampedRadii.bottomRight;
                     SDL_FRect line = { starting_x, starting_y, length, config->width.bottom };
-                    SDL_SetRenderDrawColor(renderer, config->color.r, config->color.g, config->color.b, config->color.a);
+                    SDL_SetRenderDrawColor(rendererData->renderer, config->color.r, config->color.g, config->color.b, config->color.a);
-                    SDL_RenderFillRect(renderer, &line);
+                    SDL_RenderFillRect(rendererData->renderer, &line);
                 }
                 //corners
                 if (config->cornerRadius.topLeft > 0) {
                     const float centerX = rect.x + clampedRadii.topLeft -1;
                     const float centerY = rect.y + clampedRadii.topLeft;
-                    SDL_RenderArc(renderer, (SDL_FPoint){centerX, centerY}, clampedRadii.topLeft,
+                    SDL_Clay_RenderArc(rendererData, (SDL_FPoint){centerX, centerY}, clampedRadii.topLeft,
                         180.0f, 270.0f, config->width.top, config->color);
                 }
                 if (config->cornerRadius.topRight > 0) {
                     const float centerX = rect.x + rect.w - clampedRadii.topRight -1;
                     const float centerY = rect.y + clampedRadii.topRight;
-                    SDL_RenderArc(renderer, (SDL_FPoint){centerX, centerY}, clampedRadii.topRight,
+                    SDL_Clay_RenderArc(rendererData, (SDL_FPoint){centerX, centerY}, clampedRadii.topRight,
                         270.0f, 360.0f, config->width.top, config->color);
                 }
                 if (config->cornerRadius.bottomLeft > 0) {
                     const float centerX = rect.x + clampedRadii.bottomLeft -1;
                     const float centerY = rect.y + rect.h - clampedRadii.bottomLeft -1;
-                    SDL_RenderArc(renderer, (SDL_FPoint){centerX, centerY}, clampedRadii.bottomLeft,
+                    SDL_Clay_RenderArc(rendererData, (SDL_FPoint){centerX, centerY}, clampedRadii.bottomLeft,
                         90.0f, 180.0f, config->width.bottom, config->color);
                 }
                 if (config->cornerRadius.bottomRight > 0) {
                     const float centerX = rect.x + rect.w - clampedRadii.bottomRight -1; //TODO: why need to -1 in all calculations???
                     const float centerY = rect.y + rect.h - clampedRadii.bottomRight -1;
-                    SDL_RenderArc(renderer, (SDL_FPoint){centerX, centerY}, clampedRadii.bottomRight,
+                    SDL_Clay_RenderArc(rendererData, (SDL_FPoint){centerX, centerY}, clampedRadii.bottomRight,
                         0.0f, 90.0f, config->width.bottom, config->color);
                 }
 
             } break;
+            case CLAY_RENDER_COMMAND_TYPE_SCISSOR_START: {
+                Clay_BoundingBox boundingBox = rcmd->boundingBox;
+                currentClippingRectangle = (SDL_Rect) {
+                        .x = boundingBox.x,
+                        .y = boundingBox.y,
+                        .w = boundingBox.width,
+                        .h = boundingBox.height,
+                };
+                SDL_SetRenderClipRect(rendererData->renderer, &currentClippingRectangle);
+                break;
+            }
+            case CLAY_RENDER_COMMAND_TYPE_SCISSOR_END: {
+                SDL_SetRenderClipRect(rendererData->renderer, NULL);
+                break;
+            }
+            case CLAY_RENDER_COMMAND_TYPE_IMAGE: {
+                SDL_Surface *image = (SDL_Surface *)rcmd->renderData.image.imageData;
+                SDL_Texture *texture = SDL_CreateTextureFromSurface(rendererData->renderer, image);
+                const SDL_FRect dest = { rect.x, rect.y, rect.w, rect.h };
+
+                SDL_RenderTexture(rendererData->renderer, texture, NULL, &dest);
+                SDL_DestroyTexture(texture);
+                break;
+            }
             default:
                 SDL_Log("Unknown render command type: %d", rcmd->commandType);
         }