mirror of
https://github.com/nicbarker/clay.git
synced 2025-11-04 08:36:17 +00:00
271 lines
12 KiB
C
271 lines
12 KiB
C
#include "../../clay.h"
|
|
#include <SDL.h>
|
|
#include <SDL_ttf.h>
|
|
#include <SDL_image.h>
|
|
#include <stdio.h>
|
|
|
|
#define CLAY_COLOR_TO_SDL_COLOR_ARGS(color) color.r, color.g, color.b, color.a
|
|
|
|
typedef struct
|
|
{
|
|
uint32_t fontId;
|
|
TTF_Font *font;
|
|
} SDL2_Font;
|
|
|
|
|
|
static Clay_Dimensions SDL2_MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData)
|
|
{
|
|
SDL2_Font *fonts = (SDL2_Font*)userData;
|
|
|
|
TTF_Font *font = fonts[config->fontId].font;
|
|
char *chars = (char *)calloc(text.length + 1, 1);
|
|
memcpy(chars, text.chars, text.length);
|
|
int width = 0;
|
|
int height = 0;
|
|
if (TTF_SizeUTF8(font, chars, &width, &height) < 0) {
|
|
fprintf(stderr, "Error: could not measure text: %s\n", TTF_GetError());
|
|
exit(1);
|
|
}
|
|
free(chars);
|
|
return (Clay_Dimensions) {
|
|
.width = (float)width,
|
|
.height = (float)height,
|
|
};
|
|
}
|
|
|
|
/* 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) {
|
|
const SDL_Color color = (SDL_Color) {
|
|
.r = (Uint8)_color.r,
|
|
.g = (Uint8)_color.g,
|
|
.b = (Uint8)_color.b,
|
|
.a = (Uint8)_color.a,
|
|
};
|
|
|
|
int indexCount = 0, vertexCount = 0;
|
|
|
|
const float minRadius = SDL_min(rect.w, rect.h) / 2.0f;
|
|
const float clampedRadius = SDL_min(cornerRadius, minRadius);
|
|
|
|
const int numCircleSegments = SDL_max(NUM_CIRCLE_SEGMENTS, (int)clampedRadius * 0.5f);
|
|
|
|
SDL_Vertex vertices[512];
|
|
int indices[512];
|
|
|
|
//define center rectangle
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + clampedRadius, rect.y + clampedRadius}, color, {0, 0} }; //0 center TL
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w - clampedRadius, rect.y + clampedRadius}, color, {1, 0} }; //1 center TR
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w - clampedRadius, rect.y + rect.h - clampedRadius}, color, {1, 1} }; //2 center BR
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + clampedRadius, rect.y + rect.h - clampedRadius}, color, {0, 1} }; //3 center BL
|
|
|
|
indices[indexCount++] = 0;
|
|
indices[indexCount++] = 1;
|
|
indices[indexCount++] = 3;
|
|
indices[indexCount++] = 1;
|
|
indices[indexCount++] = 2;
|
|
indices[indexCount++] = 3;
|
|
|
|
//define rounded corners as triangle fans
|
|
const float step = (M_PI / 2) / numCircleSegments;
|
|
for (int i = 0; i < numCircleSegments; i++) {
|
|
const float angle1 = (float)i * step;
|
|
const float angle2 = ((float)i + 1.0f) * step;
|
|
|
|
for (int j = 0; j < 4; j++) { // Iterate over four corners
|
|
float cx, cy, signX, signY;
|
|
|
|
switch (j) {
|
|
case 0: cx = rect.x + clampedRadius; cy = rect.y + clampedRadius; signX = -1; signY = -1; break; // Top-left
|
|
case 1: cx = rect.x + rect.w - clampedRadius; cy = rect.y + clampedRadius; signX = 1; signY = -1; break; // Top-right
|
|
case 2: cx = rect.x + rect.w - clampedRadius; cy = rect.y + rect.h - clampedRadius; signX = 1; signY = 1; break; // Bottom-right
|
|
case 3: cx = rect.x + clampedRadius; cy = rect.y + rect.h - clampedRadius; signX = -1; signY = 1; break; // Bottom-left
|
|
default: return;
|
|
}
|
|
|
|
vertices[vertexCount++] = (SDL_Vertex){ {cx + SDL_cosf(angle1) * clampedRadius * signX, cy + SDL_sinf(angle1) * clampedRadius * signY}, color, {0, 0} };
|
|
vertices[vertexCount++] = (SDL_Vertex){ {cx + SDL_cosf(angle2) * clampedRadius * signX, cy + SDL_sinf(angle2) * clampedRadius * signY}, color, {0, 0} };
|
|
|
|
indices[indexCount++] = j; // Connect to corresponding central rectangle vertex
|
|
indices[indexCount++] = vertexCount - 2;
|
|
indices[indexCount++] = vertexCount - 1;
|
|
}
|
|
}
|
|
|
|
//Define edge rectangles
|
|
// Top edge
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + clampedRadius, rect.y}, color, {0, 0} }; //TL
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w - clampedRadius, rect.y}, color, {1, 0} }; //TR
|
|
|
|
indices[indexCount++] = 0;
|
|
indices[indexCount++] = vertexCount - 2; //TL
|
|
indices[indexCount++] = vertexCount - 1; //TR
|
|
indices[indexCount++] = 1;
|
|
indices[indexCount++] = 0;
|
|
indices[indexCount++] = vertexCount - 1; //TR
|
|
// Right edge
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w, rect.y + clampedRadius}, color, {1, 0} }; //RT
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w, rect.y + rect.h - clampedRadius}, color, {1, 1} }; //RB
|
|
|
|
indices[indexCount++] = 1;
|
|
indices[indexCount++] = vertexCount - 2; //RT
|
|
indices[indexCount++] = vertexCount - 1; //RB
|
|
indices[indexCount++] = 2;
|
|
indices[indexCount++] = 1;
|
|
indices[indexCount++] = vertexCount - 1; //RB
|
|
// Bottom edge
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + rect.w - clampedRadius, rect.y + rect.h}, color, {1, 1} }; //BR
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x + clampedRadius, rect.y + rect.h}, color, {0, 1} }; //BL
|
|
|
|
indices[indexCount++] = 2;
|
|
indices[indexCount++] = vertexCount - 2; //BR
|
|
indices[indexCount++] = vertexCount - 1; //BL
|
|
indices[indexCount++] = 3;
|
|
indices[indexCount++] = 2;
|
|
indices[indexCount++] = vertexCount - 1; //BL
|
|
// Left edge
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x, rect.y + rect.h - clampedRadius}, color, {0, 1} }; //LB
|
|
vertices[vertexCount++] = (SDL_Vertex){ {rect.x, rect.y + clampedRadius}, color, {0, 0} }; //LT
|
|
|
|
indices[indexCount++] = 3;
|
|
indices[indexCount++] = vertexCount - 2; //LB
|
|
indices[indexCount++] = vertexCount - 1; //LT
|
|
indices[indexCount++] = 0;
|
|
indices[indexCount++] = 3;
|
|
indices[indexCount++] = vertexCount - 1; //LT
|
|
|
|
// Render everything
|
|
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)
|
|
{
|
|
for (uint32_t i = 0; i < renderCommands.length; i++)
|
|
{
|
|
Clay_RenderCommand *renderCommand = Clay_RenderCommandArray_Get(&renderCommands, i);
|
|
Clay_BoundingBox boundingBox = renderCommand->boundingBox;
|
|
switch (renderCommand->commandType)
|
|
{
|
|
case CLAY_RENDER_COMMAND_TYPE_RECTANGLE: {
|
|
Clay_RectangleRenderData *config = &renderCommand->renderData.rectangle;
|
|
Clay_Color color = config->backgroundColor;
|
|
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
|
|
SDL_FRect rect = (SDL_FRect) {
|
|
.x = boundingBox.x,
|
|
.y = boundingBox.y,
|
|
.w = boundingBox.width,
|
|
.h = boundingBox.height,
|
|
};
|
|
if (config->cornerRadius.topLeft > 0) {
|
|
SDL_RenderFillRoundedRect(renderer, rect, config->cornerRadius.topLeft, color);
|
|
}
|
|
else {
|
|
SDL_RenderFillRectF(renderer, &rect);
|
|
}
|
|
break;
|
|
}
|
|
case CLAY_RENDER_COMMAND_TYPE_TEXT: {
|
|
Clay_TextRenderData *config = &renderCommand->renderData.text;
|
|
char *cloned = (char *)calloc(config->stringContents.length + 1, 1);
|
|
memcpy(cloned, config->stringContents.chars, config->stringContents.length);
|
|
TTF_Font* font = fonts[config->fontId].font;
|
|
SDL_Surface *surface = TTF_RenderUTF8_Blended(font, cloned, (SDL_Color) {
|
|
.r = (Uint8)config->textColor.r,
|
|
.g = (Uint8)config->textColor.g,
|
|
.b = (Uint8)config->textColor.b,
|
|
.a = (Uint8)config->textColor.a,
|
|
});
|
|
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
|
|
|
|
SDL_Rect destination = (SDL_Rect){
|
|
.x = boundingBox.x,
|
|
.y = boundingBox.y,
|
|
.w = boundingBox.width,
|
|
.h = boundingBox.height,
|
|
};
|
|
SDL_RenderCopy(renderer, texture, NULL, &destination);
|
|
|
|
SDL_DestroyTexture(texture);
|
|
SDL_FreeSurface(surface);
|
|
free(cloned);
|
|
break;
|
|
}
|
|
case CLAY_RENDER_COMMAND_TYPE_SCISSOR_START: {
|
|
currentClippingRectangle = (SDL_Rect) {
|
|
.x = boundingBox.x,
|
|
.y = boundingBox.y,
|
|
.w = boundingBox.width,
|
|
.h = boundingBox.height,
|
|
};
|
|
SDL_RenderSetClipRect(renderer, ¤tClippingRectangle);
|
|
break;
|
|
}
|
|
case CLAY_RENDER_COMMAND_TYPE_SCISSOR_END: {
|
|
SDL_RenderSetClipRect(renderer, NULL);
|
|
break;
|
|
}
|
|
case CLAY_RENDER_COMMAND_TYPE_IMAGE: {
|
|
Clay_ImageRenderData *config = &renderCommand->renderData.image;
|
|
|
|
SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, config->imageData);
|
|
|
|
SDL_Rect destination = (SDL_Rect){
|
|
.x = boundingBox.x,
|
|
.y = boundingBox.y,
|
|
.w = boundingBox.width,
|
|
.h = boundingBox.height,
|
|
};
|
|
|
|
SDL_RenderCopy(renderer, texture, NULL, &destination);
|
|
|
|
SDL_DestroyTexture(texture);
|
|
break;
|
|
}
|
|
case CLAY_RENDER_COMMAND_TYPE_BORDER: {
|
|
Clay_BorderRenderData *config = &renderCommand->renderData.border;
|
|
|
|
if (config->width.left > 0) {
|
|
SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(config->color));
|
|
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) {
|
|
SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(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.right > 0) {
|
|
SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(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) {
|
|
SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(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) {
|
|
SDL_SetRenderDrawColor(renderer, CLAY_COLOR_TO_SDL_COLOR_ARGS(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;
|
|
}
|
|
default: {
|
|
fprintf(stderr, "Error: unhandled render command: %d\n", renderCommand->commandType);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
}
|