From 85840db0f1670f80ab021680e99cc1e2e64c4318 Mon Sep 17 00:00:00 2001 From: Synthasmagoria Date: Tue, 21 Jul 2026 17:35:02 +0200 Subject: [PATCH] lil ui --- libraries/clay/LICENSE.md | 22 + libraries/clay/README.md | 203 + libraries/clay/build-clay-lib.sh | 19 + libraries/clay/clay-odin/clay.c | 2 + libraries/clay/clay-odin/clay.h | 5058 +++++++++++++++++++ libraries/clay/clay-odin/linux/clay.a | Bin 0 -> 267396 bytes libraries/clay/clay-odin/macos-arm64/clay.a | Bin 0 -> 631268 bytes libraries/clay/clay-odin/macos/clay.a | Bin 0 -> 187844 bytes libraries/clay/clay-odin/wasm/clay.o | Bin 0 -> 234467 bytes libraries/clay/clay-odin/windows/clay.lib | Bin 0 -> 212419 bytes libraries/clay/clay.odin | 601 +++ main.odin | 5 - program.odin | 107 +- 13 files changed, 6010 insertions(+), 7 deletions(-) create mode 100644 libraries/clay/LICENSE.md create mode 100644 libraries/clay/README.md create mode 100755 libraries/clay/build-clay-lib.sh create mode 100644 libraries/clay/clay-odin/clay.c create mode 100644 libraries/clay/clay-odin/clay.h create mode 100644 libraries/clay/clay-odin/linux/clay.a create mode 100644 libraries/clay/clay-odin/macos-arm64/clay.a create mode 100644 libraries/clay/clay-odin/macos/clay.a create mode 100644 libraries/clay/clay-odin/wasm/clay.o create mode 100644 libraries/clay/clay-odin/windows/clay.lib create mode 100644 libraries/clay/clay.odin diff --git a/libraries/clay/LICENSE.md b/libraries/clay/LICENSE.md new file mode 100644 index 0000000..d2511cd --- /dev/null +++ b/libraries/clay/LICENSE.md @@ -0,0 +1,22 @@ +zlib/libpng license + +Copyright (c) 2024 Nic Barker + +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. diff --git a/libraries/clay/README.md b/libraries/clay/README.md new file mode 100644 index 0000000..bf80994 --- /dev/null +++ b/libraries/clay/README.md @@ -0,0 +1,203 @@ +### Odin Language Bindings + +This directory contains bindings for the [Odin](odin-lang.org) programming language, as well as an example implementation of the [Clay website](https://nicbarker.com/clay) in Odin. + +Special thanks to + +- [laytan](https://github.com/laytan) +- [Dudejoe870](https://github.com/Dudejoe870) +- MrStevns from the Odin Discord server + +If you haven't taken a look at the [full documentation for Clay](https://github.com/nicbarker/clay/blob/main/README.md), it's recommended that you take a look there first to familiarise yourself with the general concepts. This README is abbreviated and applies to using Clay in Odin specifically. + +The **most notable difference** between the C API and the Odin bindings is the use of `if` statements to create the scope for declaring child elements, when using the equivalent of the [Element Macros](https://github.com/nicbarker/clay/blob/main/README.md#element-macros): +```C +// C form of element macros +// Define an element with 16px of x and y padding +CLAY({ .id = CLAY_ID("Outer"), .layout = { .padding = CLAY_PADDING_ALL(16) } }) { + // Child elements here +} +``` + +```Odin +// Odin form of element macros +if clay.UI(clay.ID("Outer"))({ layout = { padding = clay.PaddingAll(16) }}) { + // Child elements here +} +``` + +### Quick Start + +1. Download the [clay-odin](https://github.com/nicbarker/clay/tree/main/bindings/odin/clay-odin) directory and copy it into your project. + +```Odin +import clay "clay-odin" +``` + +2. Ask Clay for how much static memory it needs using [clay.MinMemorySize()](https://github.com/nicbarker/clay/blob/main/README.md#clay_minmemorysize), create an Arena for it to use with [clay.CreateArenaWithCapacityAndMemory(minMemorySize, memory)](https://github.com/nicbarker/clay/blob/main/README.md#clay_createarenawithcapacityandmemory), and initialize it with [clay.Initialize(clay.Arena, clay.Dimensions, clay.ErrorHandler)](https://github.com/nicbarker/clay/blob/main/README.md#clay_initialize). + +```Odin +error_handler :: proc "c" (errorData: clay.ErrorData) { + // Do something with the error data. +} + +min_memory_size := clay.MinMemorySize() +memory := make([^]u8, min_memory_size) +arena: clay.Arena = clay.CreateArenaWithCapacityAndMemory(uint(min_memory_size), memory) +clay.Initialize(arena, {1080, 720}, { handler = error_handler }) +``` + +3. Provide a `measure_text(text, config)` proc "c" with [clay.SetMeasureTextFunction(function)](https://github.com/nicbarker/clay/blob/main/README.md#clay_setmeasuretextfunction) so that Clay can measure and wrap text. + +```Odin +// Example measure text function +measure_text :: proc "c" ( + text: clay.StringSlice, + config: ^clay.TextElementConfig, + userData: rawptr, +) -> clay.Dimensions { + // clay.TextElementConfig contains members such as fontId, fontSize, letterSpacing, etc.. + // Note: clay.String->chars is not guaranteed to be null terminated + return { + width = f32(text.length * i32(config.fontSize)), + height = f32(config.fontSize), + } +} + + +// Tell clay how to measure text +clay.SetMeasureTextFunction(measure_text, nil) +``` + +4. **Optional** - Call [clay.SetPointerState(pointerPosition, isPointerDown)](https://github.com/nicbarker/clay/blob/main/README.md#clay_setpointerstate) if you want to use mouse interactions. + +```Odin +// Update internal pointer position for handling mouseover / click / touch events +clay.SetPointerState( + { mouse_pos_x, mouse_pos_y }, + is_mouse_down, +) +``` + +5. Call [clay.BeginLayout()](https://github.com/nicbarker/clay/blob/main/README.md#clay_beginlayout) and declare your layout using the provided macros. + +```Odin +// Define some colors. +COLOR_LIGHT :: clay.Color{224, 215, 210, 255} +COLOR_RED :: clay.Color{168, 66, 28, 255} +COLOR_ORANGE :: clay.Color{225, 138, 50, 255} +COLOR_BLACK :: clay.Color{0, 0, 0, 255} + +// Layout config is just a struct that can be declared statically, or inline +sidebar_item_layout := clay.LayoutConfig { + sizing = { + width = clay.SizingGrow({}), + height = clay.SizingFixed(50) + }, +} + +// Re-useable components are just normal procs. +sidebar_item_component :: proc(index: u32) { + if clay.UI()({ + id = clay.ID("SidebarBlob", index), + layout = sidebar_item_layout, + backgroundColor = COLOR_ORANGE, + }) {} +} + +// An example function to create your layout tree +create_layout :: proc() -> clay.ClayArray(clay.RenderCommand) { + // Begin constructing the layout. + clay.BeginLayout() + + // An example of laying out a UI with a fixed-width sidebar and flexible-width main content + // NOTE: To create a scope for child components, the Odin API uses `if` with components that have children + if clay.UI()({ + id = clay.ID("OuterContainer"), + layout = { + sizing = { width = clay.SizingGrow({}), height = clay.SizingGrow({}) }, + padding = { 16, 16, 16, 16 }, + childGap = 16, + }, + backgroundColor = { 250, 250, 255, 255 }, + }) { + if clay.UI()({ + id = clay.ID("SideBar"), + layout = { + layoutDirection = .TopToBottom, + sizing = { width = clay.SizingFixed(300), height = clay.SizingGrow({}) }, + padding = { 16, 16, 16, 16 }, + childGap = 16, + }, + backgroundColor = COLOR_LIGHT, + }) { + if clay.UI()({ + id = clay.ID("ProfilePictureOuter"), + layout = { + sizing = { width = clay.SizingGrow({}) }, + padding = { 16, 16, 16, 16 }, + childGap = 16, + childAlignment = { y = .Center }, + }, + backgroundColor = COLOR_RED, + cornerRadius = { 6, 6, 6, 6 }, + }) { + if clay.UI()({ + id = clay.ID("ProfilePicture"), + layout = { + sizing = { width = clay.SizingFixed(60), height = clay.SizingFixed(60) }, + }, + image = { + // How you define `profile_picture` depends on your renderer. + imageData = &profile_picture, + sourceDimensions = { + width = 60, + height = 60, + }, + }, + }) {} + + clay.Text( + "Clay - UI Library", + clay.TextConfig({ textColor = COLOR_BLACK, fontSize = 16 }), + ) + } + + // Standard Odin code like loops, etc. work inside components. + // Here we render 5 sidebar items. + for i in u32(0)..<5 { + sidebar_item_component(i) + } + } + + if clay.UI()({ + id = clay.ID("MainContent"), + layout = { + sizing = { width = clay.SizingGrow({}), height = clay.SizingGrow({}) }, + }, + backgroundColor = COLOR_LIGHT, + }) {} + } + + // Returns a list of render commands + return clay.EndLayout() +} +``` + +6. Call your layout proc and process the resulting [clay.ClayArray(clay.RenderCommand)](https://github.com/nicbarker/clay/blob/main/README.md#clay_rendercommandarray) in your choice of renderer. + +```Odin +render_commands := create_layout() + +for i in 0.. `clay.ID` (Odin). diff --git a/libraries/clay/build-clay-lib.sh b/libraries/clay/build-clay-lib.sh new file mode 100755 index 0000000..ce55623 --- /dev/null +++ b/libraries/clay/build-clay-lib.sh @@ -0,0 +1,19 @@ +# Intel Mac +rm -f clay-odin/macos/clay.a +clang -c -o clay.o -ffreestanding -static -target x86_64-apple-darwin clay-odin/clay.c -fPIC -O3 +ar r clay-odin/macos/clay.a clay.o; +# ARM Mac +rm -f clay-odin/macos-arm64/clay.a +clang -c -g -o clay.o -static clay-odin/clay.c -fPIC -O3 +ar r clay-odin/macos-arm64/clay.a clay.o; +# x64 Windows +rm -f clay-odin/windows/clay.lib +clang -c -o clay-odin/windows/clay.lib -ffreestanding -target x86_64-pc-windows-msvc -fuse-ld=llvm-lib -static -O3 clay-odin/clay.c; +# Linux +rm -f clay-odin/linux/clay.a +clang -c -o clay.o -ffreestanding -static -target x86_64-unknown-linux-gnu clay-odin/clay.c -fPIC -O3 +ar r clay-odin/linux/clay.a clay.o; +# WASM +rm -f clay-odin/wasm/clay.o +clang -c -o clay-odin/wasm/clay.o -target wasm32 -nostdlib -static -O3 clay-odin/clay.c; +rm clay.o; diff --git a/libraries/clay/clay-odin/clay.c b/libraries/clay/clay-odin/clay.c new file mode 100644 index 0000000..cbc311b --- /dev/null +++ b/libraries/clay/clay-odin/clay.c @@ -0,0 +1,2 @@ +#define CLAY_IMPLEMENTATION +#include "clay.h" diff --git a/libraries/clay/clay-odin/clay.h b/libraries/clay/clay-odin/clay.h new file mode 100644 index 0000000..7d9cf4c --- /dev/null +++ b/libraries/clay/clay-odin/clay.h @@ -0,0 +1,5058 @@ +// VERSION: 0.14 + +/* + NOTE: In order to use this library you must define + the following macro in exactly one file, _before_ including clay.h: + + #define CLAY_IMPLEMENTATION + #include "clay.h" + + See the examples folder for details. +*/ + +#include +#include +#include + +// SIMD includes on supported platforms +#if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)) +#include +#elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__) +#include +#endif +#if __CLION_IDE__ +#define CLAY_IMPLEMENTATION +#endif + +// ----------------------------------------- +// HEADER DECLARATIONS --------------------- +// ----------------------------------------- + +#ifndef CLAY_HEADER +#define CLAY_HEADER + +#if !( \ + (defined(__cplusplus) && __cplusplus >= 202002L) || \ + (defined(__STDC__) && __STDC__ == 1 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ + defined(_MSC_VER) || \ + defined(__OBJC__) \ +) +#error "Clay requires C99, C++20, or MSVC" +#endif + +#ifdef CLAY_WASM +#define CLAY_WASM_EXPORT(name) __attribute__((export_name(name))) +#else +#define CLAY_WASM_EXPORT(null) +#endif + +#ifdef CLAY_DLL +#define CLAY_DLL_EXPORT __declspec(dllexport) __stdcall +#else +#define CLAY_DLL_EXPORT +#endif + +// Public Macro API ------------------------ + +#define CLAY__MAX(x, y) (((x) > (y)) ? (x) : (y)) +#define CLAY__MIN(x, y) (((x) < (y)) ? (x) : (y)) + +#define CLAY_TEXT_CONFIG(...) __VA_ARGS__ + +#define CLAY_BORDER_OUTSIDE(widthValue) {widthValue, widthValue, widthValue, widthValue, 0} + +#define CLAY_BORDER_ALL(widthValue) {widthValue, widthValue, widthValue, widthValue, widthValue} + +#define CLAY_CORNER_RADIUS(radius) (CLAY__INIT(Clay_CornerRadius) { radius, radius, radius, radius }) + +#define CLAY_PADDING_ALL(padding) CLAY__CONFIG_WRAPPER(Clay_Padding, { padding, padding, padding, padding }) + +#define CLAY_SIZING_FIT(...) (CLAY__INIT(Clay_SizingAxis) { .size = { .minMax = { __VA_ARGS__ } }, .type = CLAY__SIZING_TYPE_FIT }) + +#define CLAY_SIZING_GROW(...) (CLAY__INIT(Clay_SizingAxis) { .size = { .minMax = { __VA_ARGS__ } }, .type = CLAY__SIZING_TYPE_GROW }) + +#define CLAY_SIZING_FIXED(fixedSize) (CLAY__INIT(Clay_SizingAxis) { .size = { .minMax = { fixedSize, fixedSize } }, .type = CLAY__SIZING_TYPE_FIXED }) + +#define CLAY_SIZING_PERCENT(percentOfParent) (CLAY__INIT(Clay_SizingAxis) { .size = { .percent = (percentOfParent) }, .type = CLAY__SIZING_TYPE_PERCENT }) + +// Note: If a compile error led you here, you might be trying to use CLAY_ID with something other than a string literal. To construct an ID with a dynamic string, use CLAY_SID instead. +#define CLAY_ID(label) CLAY_SID(CLAY_STRING(label)) + +#define CLAY_SID(label) Clay__HashString(label, 0) + +// Note: If a compile error led you here, you might be trying to use CLAY_IDI with something other than a string literal. To construct an ID with a dynamic string, use CLAY_SIDI instead. +#define CLAY_IDI(label, index) CLAY_SIDI(CLAY_STRING(label), index) + +#define CLAY_SIDI(label, index) Clay__HashStringWithOffset(label, index, 0) + +// Note: If a compile error led you here, you might be trying to use CLAY_ID_LOCAL with something other than a string literal. To construct an ID with a dynamic string, use CLAY_SID_LOCAL instead. +#define CLAY_ID_LOCAL(label) CLAY_SID_LOCAL(CLAY_STRING(label)) + +#define CLAY_SID_LOCAL(label) Clay__HashString(label, Clay_GetOpenElementId()) + +// Note: If a compile error led you here, you might be trying to use CLAY_IDI_LOCAL with something other than a string literal. To construct an ID with a dynamic string, use CLAY_SIDI_LOCAL instead. +#define CLAY_IDI_LOCAL(label, index) CLAY_SIDI_LOCAL(CLAY_STRING(label), index) + +#define CLAY_SIDI_LOCAL(label, index) Clay__HashStringWithOffset(label, index, Clay_GetOpenElementId()) + +#define CLAY__STRING_LENGTH(s) ((sizeof(s) / sizeof((s)[0])) - sizeof((s)[0])) + +#define CLAY__ENSURE_STRING_LITERAL(x) ("" x "") + +// Note: If an error led you here, it's because CLAY_STRING can only be used with string literals, i.e. CLAY_STRING("SomeString") and not CLAY_STRING(yourString) +#define CLAY_STRING(string) (CLAY__INIT(Clay_String) { .isStaticallyAllocated = true, .length = CLAY__STRING_LENGTH(CLAY__ENSURE_STRING_LITERAL(string)), .chars = (string) }) + +#define CLAY_STRING_CONST(string) { .isStaticallyAllocated = true, .length = CLAY__STRING_LENGTH(CLAY__ENSURE_STRING_LITERAL(string)), .chars = (string) } + +static uint8_t CLAY__ELEMENT_DEFINITION_LATCH; + +// GCC marks the above CLAY__ELEMENT_DEFINITION_LATCH as an unused variable for files that include clay.h but don't declare any layout +// This is to suppress that warning +static inline void Clay__SuppressUnusedLatchDefinitionVariableWarning(void) { (void) CLAY__ELEMENT_DEFINITION_LATCH; } + +// Publicly visible layout element macros ----------------------------------------------------- + +/* This macro looks scary on the surface, but is actually quite simple. + It turns a macro call like this: + + CLAY({ + .id = CLAY_ID("Container"), + .backgroundColor = { 255, 200, 200, 255 } + }) { + ...children declared here + } + + Into calls like this: + + Clay__OpenElement(); + Clay__ConfigureOpenElement((Clay_ElementDeclaration) { + .id = CLAY_ID("Container"), + .backgroundColor = { 255, 200, 200, 255 } + }); + ...children declared here + Clay__CloseElement(); + + The for loop will only ever run a single iteration, putting Clay__CloseElement() in the increment of the loop + means that it will run after the body - where the children are declared. It just exists to make sure you don't forget + to call Clay_CloseElement(). +*/ +#define CLAY_AUTO_ID(...) \ + for ( \ + CLAY__ELEMENT_DEFINITION_LATCH = (Clay__OpenElement(), Clay__ConfigureOpenElement(CLAY__CONFIG_WRAPPER(Clay_ElementDeclaration, __VA_ARGS__)), 0); \ + CLAY__ELEMENT_DEFINITION_LATCH < 1; \ + CLAY__ELEMENT_DEFINITION_LATCH=1, Clay__CloseElement() \ + ) + +#define CLAY(id, ...) \ + for ( \ + CLAY__ELEMENT_DEFINITION_LATCH = (Clay__OpenElementWithId(id), Clay__ConfigureOpenElement(CLAY__CONFIG_WRAPPER(Clay_ElementDeclaration, __VA_ARGS__)), 0); \ + CLAY__ELEMENT_DEFINITION_LATCH < 1; \ + CLAY__ELEMENT_DEFINITION_LATCH=1, Clay__CloseElement() \ + ) + +// These macros exist to allow the CLAY() macro to be called both with an inline struct definition, such as +// CLAY({ .id = something... }); +// As well as by passing a predefined declaration struct +// Clay_ElementDeclaration declarationStruct = ... +// CLAY(declarationStruct); +#define CLAY__WRAPPER_TYPE(type) Clay__##type##Wrapper +#define CLAY__WRAPPER_STRUCT(type) typedef struct { type wrapped; } CLAY__WRAPPER_TYPE(type) +#define CLAY__CONFIG_WRAPPER(type, ...) (CLAY__INIT(CLAY__WRAPPER_TYPE(type)) { __VA_ARGS__ }).wrapped + +#define CLAY_TEXT(text, ...) Clay__OpenTextElement(text, CLAY__CONFIG_WRAPPER(Clay_TextElementConfig, __VA_ARGS__)) + +#ifdef __cplusplus + +#define CLAY__INIT(type) type + +#define CLAY_PACKED_ENUM enum : uint8_t + +#define CLAY__DEFAULT_STRUCT {} + +#else + +#define CLAY__INIT(type) (type) + +#if defined(_MSC_VER) && !defined(__clang__) +#define CLAY_PACKED_ENUM __pragma(pack(push, 1)) enum __pragma(pack(pop)) +#else +#define CLAY_PACKED_ENUM enum __attribute__((__packed__)) +#endif + +#if __STDC_VERSION__ >= 202311L +#define CLAY__DEFAULT_STRUCT {} +#else +#define CLAY__DEFAULT_STRUCT {0} +#endif + +#endif // __cplusplus + +#ifdef __cplusplus +extern "C" { +#endif + +// Utility Structs ------------------------- + +// Note: Clay_String is not guaranteed to be null terminated. It may be if created from a literal C string, +// but it is also used to represent slices. +typedef struct Clay_String { + // Set this boolean to true if the char* data underlying this string will live for the entire lifetime of the program. + // This will automatically be set for strings created with CLAY_STRING, as the macro requires a string literal. + bool isStaticallyAllocated; + int32_t length; + // The underlying character memory. Note: this will not be copied and will not extend the lifetime of the underlying memory. + const char *chars; +} Clay_String; + +// Clay_StringSlice is used to represent non owning string slices, and includes +// a baseChars field which points to the string this slice is derived from. +typedef struct Clay_StringSlice { + int32_t length; + const char *chars; + const char *baseChars; // The source string / char* that this slice was derived from +} Clay_StringSlice; + +typedef struct Clay_Context Clay_Context; + +// Clay_Arena is a memory arena structure that is used by clay to manage its internal allocations. +// Rather than creating it by hand, it's easier to use Clay_CreateArenaWithCapacityAndMemory() +typedef struct Clay_Arena { + uintptr_t nextAllocation; + size_t capacity; + char *memory; +} Clay_Arena; + +typedef struct Clay_Dimensions { + float width, height; +} Clay_Dimensions; + +typedef struct Clay_Vector2 { + float x, y; +} Clay_Vector2; + +// Internally clay conventionally represents colors as 0-255, but interpretation is up to the renderer. +typedef struct Clay_Color { + float r, g, b, a; +} Clay_Color; + +typedef struct Clay_BoundingBox { + float x, y, width, height; +} Clay_BoundingBox; + +// Primarily created via the CLAY_ID(), CLAY_IDI(), CLAY_ID_LOCAL() and CLAY_IDI_LOCAL() macros. +// Represents a hashed string ID used for identifying and finding specific clay UI elements, required +// by functions such as Clay_PointerOver() and Clay_GetElementData(). +typedef struct Clay_ElementId { + uint32_t id; // The resulting hash generated from the other fields. + uint32_t offset; // A numerical offset applied after computing the hash from stringId. + uint32_t baseId; // A base hash value to start from, for example the parent element ID is used when calculating CLAY_ID_LOCAL(). + Clay_String stringId; // The string id to hash. +} Clay_ElementId; + +// A sized array of Clay_ElementId. +typedef struct +{ + int32_t capacity; + int32_t length; + Clay_ElementId *internalArray; +} Clay_ElementIdArray; + +// Controls the "radius", or corner rounding of elements, including rectangles, borders and images. +// The rounding is determined by drawing a circle inset into the element corner by (radius, radius) pixels. +typedef struct Clay_CornerRadius { + float topLeft; + float topRight; + float bottomLeft; + float bottomRight; +} Clay_CornerRadius; + +// Element Configs --------------------------- + +// Controls the direction in which child elements will be automatically laid out. +typedef CLAY_PACKED_ENUM { + // (Default) Lays out child elements from left to right with increasing x. + CLAY_LEFT_TO_RIGHT, + // Lays out child elements from top to bottom with increasing y. + CLAY_TOP_TO_BOTTOM, +} Clay_LayoutDirection; + +// Controls the alignment along the x axis (horizontal) of child elements. +typedef CLAY_PACKED_ENUM { + // (Default) Aligns child elements to the left hand side of this element, offset by padding.width.left + CLAY_ALIGN_X_LEFT, + // Aligns child elements to the right hand side of this element, offset by padding.width.right + CLAY_ALIGN_X_RIGHT, + // Aligns child elements horizontally to the center of this element + CLAY_ALIGN_X_CENTER, +} Clay_LayoutAlignmentX; + +// Controls the alignment along the y axis (vertical) of child elements. +typedef CLAY_PACKED_ENUM { + // (Default) Aligns child elements to the top of this element, offset by padding.width.top + CLAY_ALIGN_Y_TOP, + // Aligns child elements to the bottom of this element, offset by padding.width.bottom + CLAY_ALIGN_Y_BOTTOM, + // Aligns child elements vertically to the center of this element + CLAY_ALIGN_Y_CENTER, +} Clay_LayoutAlignmentY; + +// Controls how the element takes up space inside its parent container. +typedef CLAY_PACKED_ENUM { + // (default) Wraps tightly to the size of the element's contents. + CLAY__SIZING_TYPE_FIT, + // Expands along this axis to fill available space in the parent element, sharing it with other GROW elements. + CLAY__SIZING_TYPE_GROW, + // Expects 0-1 range. Clamps the axis size to a percent of the parent container's axis size minus padding and child gaps. + CLAY__SIZING_TYPE_PERCENT, + // Clamps the axis size to an exact size in pixels. + CLAY__SIZING_TYPE_FIXED, +} Clay__SizingType; + +// Controls how child elements are aligned on each axis. +typedef struct Clay_ChildAlignment { + Clay_LayoutAlignmentX x; // Controls alignment of children along the x axis. + Clay_LayoutAlignmentY y; // Controls alignment of children along the y axis. +} Clay_ChildAlignment; + +// Controls the minimum and maximum size in pixels that this element is allowed to grow or shrink to, +// overriding sizing types such as FIT or GROW. +typedef struct Clay_SizingMinMax { + float min; // The smallest final size of the element on this axis will be this value in pixels. + float max; // The largest final size of the element on this axis will be this value in pixels. +} Clay_SizingMinMax; + +// Controls the sizing of this element along one axis inside its parent container. +typedef struct Clay_SizingAxis { + union { + Clay_SizingMinMax minMax; // Controls the minimum and maximum size in pixels that this element is allowed to grow or shrink to, overriding sizing types such as FIT or GROW. + float percent; // Expects 0-1 range. Clamps the axis size to a percent of the parent container's axis size minus padding and child gaps. + } size; + Clay__SizingType type; // Controls how the element takes up space inside its parent container. +} Clay_SizingAxis; + +// Controls the sizing of this element along one axis inside its parent container. +typedef struct Clay_Sizing { + Clay_SizingAxis width; // Controls the width sizing of the element, along the x axis. + Clay_SizingAxis height; // Controls the height sizing of the element, along the y axis. +} Clay_Sizing; + +// Controls "padding" in pixels, which is a gap between the bounding box of this element and where its children +// will be placed. +typedef struct Clay_Padding { + uint16_t left; + uint16_t right; + uint16_t top; + uint16_t bottom; +} Clay_Padding; + +CLAY__WRAPPER_STRUCT(Clay_Padding); + +// Controls various settings that affect the size and position of an element, as well as the sizes and positions +// of any child elements. +typedef struct Clay_LayoutConfig { + Clay_Sizing sizing; // Controls the sizing of this element inside it's parent container, including FIT, GROW, PERCENT and FIXED sizing. + Clay_Padding padding; // Controls "padding" in pixels, which is a gap between the bounding box of this element and where its children will be placed. + uint16_t childGap; // Controls the gap in pixels between child elements along the layout axis (horizontal gap for LEFT_TO_RIGHT, vertical gap for TOP_TO_BOTTOM). + Clay_ChildAlignment childAlignment; // Controls how child elements are aligned on each axis. + Clay_LayoutDirection layoutDirection; // Controls the direction in which child elements will be automatically laid out. +} Clay_LayoutConfig; + +CLAY__WRAPPER_STRUCT(Clay_LayoutConfig); + +extern Clay_LayoutConfig CLAY_LAYOUT_DEFAULT; + +// Controls how text "wraps", that is how it is broken into multiple lines when there is insufficient horizontal space. +typedef CLAY_PACKED_ENUM { + // (default) breaks on whitespace characters. + CLAY_TEXT_WRAP_WORDS, + // Don't break on space characters, only on newlines. + CLAY_TEXT_WRAP_NEWLINES, + // Disable text wrapping entirely. + CLAY_TEXT_WRAP_NONE, +} Clay_TextElementConfigWrapMode; + +// Controls how wrapped lines of text are horizontally aligned within the outer text bounding box. +typedef CLAY_PACKED_ENUM { + // (default) Horizontally aligns wrapped lines of text to the left hand side of their bounding box. + CLAY_TEXT_ALIGN_LEFT, + // Horizontally aligns wrapped lines of text to the center of their bounding box. + CLAY_TEXT_ALIGN_CENTER, + // Horizontally aligns wrapped lines of text to the right hand side of their bounding box. + CLAY_TEXT_ALIGN_RIGHT, +} Clay_TextAlignment; + +// Controls various functionality related to text elements. +typedef struct Clay_TextElementConfig { + // A pointer that will be transparently passed through to the resulting render command. + void *userData; + // The RGBA color of the font to render, conventionally specified as 0-255. + Clay_Color textColor; + // An integer transparently passed to Clay_MeasureText to identify the font to use. + // The debug view will pass fontId = 0 for its internal text. + uint16_t fontId; + // Controls the size of the font. Handled by the function provided to Clay_MeasureText. + uint16_t fontSize; + // Controls extra horizontal spacing between characters. Handled by the function provided to Clay_MeasureText. + uint16_t letterSpacing; + // Controls additional vertical space between wrapped lines of text. + uint16_t lineHeight; + // Controls how text "wraps", that is how it is broken into multiple lines when there is insufficient horizontal space. + // CLAY_TEXT_WRAP_WORDS (default) breaks on whitespace characters. + // CLAY_TEXT_WRAP_NEWLINES doesn't break on space characters, only on newlines. + // CLAY_TEXT_WRAP_NONE disables wrapping entirely. + Clay_TextElementConfigWrapMode wrapMode; + // Controls how wrapped lines of text are horizontally aligned within the outer text bounding box. + // CLAY_TEXT_ALIGN_LEFT (default) - Horizontally aligns wrapped lines of text to the left hand side of their bounding box. + // CLAY_TEXT_ALIGN_CENTER - Horizontally aligns wrapped lines of text to the center of their bounding box. + // CLAY_TEXT_ALIGN_RIGHT - Horizontally aligns wrapped lines of text to the right hand side of their bounding box. + Clay_TextAlignment textAlignment; +} Clay_TextElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_TextElementConfig); + +// Aspect Ratio -------------------------------- + +// Controls various settings related to aspect ratio scaling element. +typedef struct Clay_AspectRatioElementConfig { + float aspectRatio; // A float representing the target "Aspect ratio" for an element, which is its final width divided by its final height. +} Clay_AspectRatioElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_AspectRatioElementConfig); + +// Image -------------------------------- + +// Controls various settings related to image elements. +typedef struct Clay_ImageElementConfig { + void* imageData; // A transparent pointer used to pass image data through to the renderer. +} Clay_ImageElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_ImageElementConfig); + +// Floating ----------------------------- + +// Controls where a floating element is offset relative to its parent element. +// Note: see https://github.com/user-attachments/assets/b8c6dfaa-c1b1-41a4-be55-013473e4a6ce for a visual explanation. +typedef CLAY_PACKED_ENUM { + CLAY_ATTACH_POINT_LEFT_TOP, + CLAY_ATTACH_POINT_LEFT_CENTER, + CLAY_ATTACH_POINT_LEFT_BOTTOM, + CLAY_ATTACH_POINT_CENTER_TOP, + CLAY_ATTACH_POINT_CENTER_CENTER, + CLAY_ATTACH_POINT_CENTER_BOTTOM, + CLAY_ATTACH_POINT_RIGHT_TOP, + CLAY_ATTACH_POINT_RIGHT_CENTER, + CLAY_ATTACH_POINT_RIGHT_BOTTOM, +} Clay_FloatingAttachPointType; + +// Controls where a floating element is offset relative to its parent element. +typedef struct Clay_FloatingAttachPoints { + Clay_FloatingAttachPointType element; // Controls the origin point on a floating element that attaches to its parent. + Clay_FloatingAttachPointType parent; // Controls the origin point on the parent element that the floating element attaches to. +} Clay_FloatingAttachPoints; + +// Controls how mouse pointer events like hover and click are captured or passed through to elements underneath a floating element. +typedef CLAY_PACKED_ENUM { + // (default) "Capture" the pointer event and don't allow events like hover and click to pass through to elements underneath. + CLAY_POINTER_CAPTURE_MODE_CAPTURE, + // CLAY_POINTER_CAPTURE_MODE_PARENT, TODO pass pointer through to attached parent + // Transparently pass through pointer events like hover and click to elements underneath the floating element. + CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH, +} Clay_PointerCaptureMode; + +// Controls which element a floating element is "attached" to (i.e. relative offset from). +typedef CLAY_PACKED_ENUM { + // (default) Disables floating for this element. + CLAY_ATTACH_TO_NONE, + // Attaches this floating element to its parent, positioned based on the .attachPoints and .offset fields. + CLAY_ATTACH_TO_PARENT, + // Attaches this floating element to an element with a specific ID, specified with the .parentId field. positioned based on the .attachPoints and .offset fields. + CLAY_ATTACH_TO_ELEMENT_WITH_ID, + // Attaches this floating element to the root of the layout, which combined with the .offset field provides functionality similar to "absolute positioning". + CLAY_ATTACH_TO_ROOT, +} Clay_FloatingAttachToElement; + +// Controls whether or not a floating element is clipped to the same clipping rectangle as the element it's attached to. +typedef CLAY_PACKED_ENUM { + // (default) - The floating element does not inherit clipping. + CLAY_CLIP_TO_NONE, + // The floating element is clipped to the same clipping rectangle as the element it's attached to. + CLAY_CLIP_TO_ATTACHED_PARENT +} Clay_FloatingClipToElement; + +// Controls various settings related to "floating" elements, which are elements that "float" above other elements, potentially overlapping their boundaries, +// and not affecting the layout of sibling or parent elements. +typedef struct Clay_FloatingElementConfig { + // Offsets this floating element by the provided x,y coordinates from its attachPoints. + Clay_Vector2 offset; + // Expands the boundaries of the outer floating element without affecting its children. + Clay_Dimensions expand; + // When used in conjunction with .attachTo = CLAY_ATTACH_TO_ELEMENT_WITH_ID, attaches this floating element to the element in the hierarchy with the provided ID. + // Hint: attach the ID to the other element with .id = CLAY_ID("yourId"), and specify the id the same way, with .parentId = CLAY_ID("yourId").id + uint32_t parentId; + // Controls the z index of this floating element and all its children. Floating elements are sorted in ascending z order before output. + // zIndex is also passed to the renderer for all elements contained within this floating element. + int16_t zIndex; + // Controls how mouse pointer events like hover and click are captured or passed through to elements underneath / behind a floating element. + // Enum is of the form CLAY_ATTACH_POINT_foo_bar. See Clay_FloatingAttachPoints for more details. + // Note: see for a visual explanation. + Clay_FloatingAttachPoints attachPoints; + // Controls how mouse pointer events like hover and click are captured or passed through to elements underneath a floating element. + // CLAY_POINTER_CAPTURE_MODE_CAPTURE (default) - "Capture" the pointer event and don't allow events like hover and click to pass through to elements underneath. + // CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH - Transparently pass through pointer events like hover and click to elements underneath the floating element. + Clay_PointerCaptureMode pointerCaptureMode; + // Controls which element a floating element is "attached" to (i.e. relative offset from). + // CLAY_ATTACH_TO_NONE (default) - Disables floating for this element. + // CLAY_ATTACH_TO_PARENT - Attaches this floating element to its parent, positioned based on the .attachPoints and .offset fields. + // CLAY_ATTACH_TO_ELEMENT_WITH_ID - Attaches this floating element to an element with a specific ID, specified with the .parentId field. positioned based on the .attachPoints and .offset fields. + // CLAY_ATTACH_TO_ROOT - Attaches this floating element to the root of the layout, which combined with the .offset field provides functionality similar to "absolute positioning". + Clay_FloatingAttachToElement attachTo; + // Controls whether or not a floating element is clipped to the same clipping rectangle as the element it's attached to. + // CLAY_CLIP_TO_NONE (default) - The floating element does not inherit clipping. + // CLAY_CLIP_TO_ATTACHED_PARENT - The floating element is clipped to the same clipping rectangle as the element it's attached to. + Clay_FloatingClipToElement clipTo; +} Clay_FloatingElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_FloatingElementConfig); + +// Custom ----------------------------- + +// Controls various settings related to custom elements. +typedef struct Clay_CustomElementConfig { + // A transparent pointer through which you can pass custom data to the renderer. + // Generates CUSTOM render commands. + void* customData; +} Clay_CustomElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_CustomElementConfig); + +// Scroll ----------------------------- + +// Controls the axis on which an element switches to "scrolling", which clips the contents and allows scrolling in that direction. +typedef struct Clay_ClipElementConfig { + bool horizontal; // Clip overflowing elements on the X axis. + bool vertical; // Clip overflowing elements on the Y axis. + Clay_Vector2 childOffset; // Offsets the x,y positions of all child elements. Used primarily for scrolling containers. +} Clay_ClipElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_ClipElementConfig); + +// Border ----------------------------- + +// Controls the widths of individual element borders. +typedef struct Clay_BorderWidth { + uint16_t left; + uint16_t right; + uint16_t top; + uint16_t bottom; + // Creates borders between each child element, depending on the .layoutDirection. + // e.g. for LEFT_TO_RIGHT, borders will be vertical lines, and for TOP_TO_BOTTOM borders will be horizontal lines. + // .betweenChildren borders will result in individual RECTANGLE render commands being generated. + uint16_t betweenChildren; +} Clay_BorderWidth; + +// Controls settings related to element borders. +typedef struct Clay_BorderElementConfig { + Clay_Color color; // Controls the color of all borders with width > 0. Conventionally represented as 0-255, but interpretation is up to the renderer. + Clay_BorderWidth width; // Controls the widths of individual borders. At least one of these should be > 0 for a BORDER render command to be generated. +} Clay_BorderElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_BorderElementConfig); + +typedef struct { + Clay_BoundingBox boundingBox; + Clay_Color backgroundColor; + Clay_Color overlayColor; + Clay_Color borderColor; + Clay_BorderWidth borderWidth; +} Clay_TransitionData; + +typedef enum { + CLAY_TRANSITION_STATE_IDLE, + CLAY_TRANSITION_STATE_ENTERING, + CLAY_TRANSITION_STATE_TRANSITIONING, + CLAY_TRANSITION_STATE_EXITING, +} Clay_TransitionState; + +typedef enum { + CLAY_TRANSITION_PROPERTY_NONE = 0, + CLAY_TRANSITION_PROPERTY_X = 1, + CLAY_TRANSITION_PROPERTY_Y = 2, + CLAY_TRANSITION_PROPERTY_POSITION = CLAY_TRANSITION_PROPERTY_X | CLAY_TRANSITION_PROPERTY_Y, + CLAY_TRANSITION_PROPERTY_WIDTH = 4, + CLAY_TRANSITION_PROPERTY_HEIGHT = 8, + CLAY_TRANSITION_PROPERTY_DIMENSIONS = CLAY_TRANSITION_PROPERTY_WIDTH | CLAY_TRANSITION_PROPERTY_HEIGHT, + CLAY_TRANSITION_PROPERTY_BOUNDING_BOX = CLAY_TRANSITION_PROPERTY_POSITION | CLAY_TRANSITION_PROPERTY_DIMENSIONS, + CLAY_TRANSITION_PROPERTY_BACKGROUND_COLOR = 16, + CLAY_TRANSITION_PROPERTY_OVERLAY_COLOR = 32, + CLAY_TRANSITION_PROPERTY_CORNER_RADIUS = 64, + CLAY_TRANSITION_PROPERTY_BORDER_COLOR = 128, + CLAY_TRANSITION_PROPERTY_BORDER_WIDTH = 256, + CLAY_TRANSITION_PROPERTY_BORDER = CLAY_TRANSITION_PROPERTY_BORDER_COLOR | CLAY_TRANSITION_PROPERTY_BORDER_WIDTH +} Clay_TransitionProperty; + +typedef struct { + Clay_TransitionState transitionState; + Clay_TransitionData initial; + Clay_TransitionData *current; + Clay_TransitionData target; + float elapsedTime; + float duration; + Clay_TransitionProperty properties; +} Clay_TransitionCallbackArguments; + +typedef CLAY_PACKED_ENUM { + CLAY_TRANSITION_ENTER_SKIP_ON_FIRST_PARENT_FRAME, + CLAY_TRANSITION_ENTER_TRIGGER_ON_FIRST_PARENT_FRAME, +} Clay_TransitionEnterTriggerType; + +typedef CLAY_PACKED_ENUM { + CLAY_TRANSITION_EXIT_SKIP_WHEN_PARENT_EXITS, + CLAY_TRANSITION_EXIT_TRIGGER_WHEN_PARENT_EXITS, +} Clay_TransitionExitTriggerType; + +typedef CLAY_PACKED_ENUM { + CLAY_TRANSITION_DISABLE_INTERACTIONS_WHILE_TRANSITIONING_POSITION, + CLAY_TRANSITION_ALLOW_INTERACTIONS_WHILE_TRANSITIONING_POSITION, +} Clay_TransitionInteractionHandlingType; + +typedef CLAY_PACKED_ENUM { + CLAY_EXIT_TRANSITION_ORDERING_UNDERNEATH_SIBLINGS, + CLAY_EXIT_TRANSITION_ORDERING_NATURAL_ORDER, + CLAY_EXIT_TRANSITION_ORDERING_ABOVE_SIBLINGS, +} Clay_ExitTransitionSiblingOrdering; + +// Controls settings related to transitions +typedef struct Clay_TransitionElementConfig { + bool (*handler)(Clay_TransitionCallbackArguments arguments); + float duration; + Clay_TransitionProperty properties; + Clay_TransitionInteractionHandlingType interactionHandling; + struct { + Clay_TransitionData (*setInitialState)(Clay_TransitionData targetState, Clay_TransitionProperty properties); + Clay_TransitionEnterTriggerType trigger; + } enter; + struct { + Clay_TransitionData (*setFinalState)(Clay_TransitionData initialState, Clay_TransitionProperty properties); + Clay_TransitionExitTriggerType trigger; + Clay_ExitTransitionSiblingOrdering siblingOrdering; + } exit; +} Clay_TransitionElementConfig; + +CLAY__WRAPPER_STRUCT(Clay_TransitionElementConfig); + +// Render Command Data ----------------------------- + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_TEXT +typedef struct Clay_TextRenderData { + // A string slice containing the text to be rendered. + // Note: this is not guaranteed to be null terminated. + Clay_StringSlice stringContents; + // Conventionally represented as 0-255 for each channel, but interpretation is up to the renderer. + Clay_Color textColor; + // An integer representing the font to use to render this text, transparently passed through from the text declaration. + uint16_t fontId; + uint16_t fontSize; + // Specifies the extra whitespace gap in pixels between each character. + uint16_t letterSpacing; + // The height of the bounding box for this line of text. + uint16_t lineHeight; +} Clay_TextRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_RECTANGLE +typedef struct Clay_RectangleRenderData { + // The solid background color to fill this rectangle with. Conventionally represented as 0-255 for each channel, but interpretation is up to the renderer. + Clay_Color backgroundColor; + // Controls the "radius", or corner rounding of elements, including rectangles, borders and images. + // The rounding is determined by drawing a circle inset into the element corner by (radius, radius) pixels. + Clay_CornerRadius cornerRadius; +} Clay_RectangleRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_IMAGE +typedef struct Clay_ImageRenderData { + // The tint color for this image. Note that the default value is 0,0,0,0 and should likely be interpreted + // as "untinted". + // Conventionally represented as 0-255 for each channel, but interpretation is up to the renderer. + Clay_Color backgroundColor; + // Controls the "radius", or corner rounding of this image. + // The rounding is determined by drawing a circle inset into the element corner by (radius, radius) pixels. + Clay_CornerRadius cornerRadius; + // A pointer transparently passed through from the original element definition, typically used to represent image data. + void* imageData; +} Clay_ImageRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_CUSTOM +typedef struct Clay_CustomRenderData { + // Passed through from .backgroundColor in the original element declaration. + // Conventionally represented as 0-255 for each channel, but interpretation is up to the renderer. + Clay_Color backgroundColor; + // Controls the "radius", or corner rounding of this custom element. + // The rounding is determined by drawing a circle inset into the element corner by (radius, radius) pixels. + Clay_CornerRadius cornerRadius; + // A pointer transparently passed through from the original element definition. + void* customData; +} Clay_CustomRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_SCISSOR_START || commandType == CLAY_RENDER_COMMAND_TYPE_SCISSOR_END +typedef struct Clay_ClipRenderData { + bool horizontal; + bool vertical; +} Clay_ClipRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_START || commandType == CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_END +typedef struct Clay_OverlayColorRenderData { + Clay_Color color; +} Clay_OverlayColorRenderData; + +// Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_BORDER +typedef struct Clay_BorderRenderData { + // Controls a shared color for all this element's borders. + // Conventionally represented as 0-255 for each channel, but interpretation is up to the renderer. + Clay_Color color; + // Specifies the "radius", or corner rounding of this border element. + // The rounding is determined by drawing a circle inset into the element corner by (radius, radius) pixels. + Clay_CornerRadius cornerRadius; + // Controls individual border side widths. + Clay_BorderWidth width; +} Clay_BorderRenderData; + +// A struct union containing data specific to this command's .commandType +typedef union Clay_RenderData { + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_RECTANGLE + Clay_RectangleRenderData rectangle; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_TEXT + Clay_TextRenderData text; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_IMAGE + Clay_ImageRenderData image; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_CUSTOM + Clay_CustomRenderData custom; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_BORDER + Clay_BorderRenderData border; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_SCISSOR_START|END + Clay_ClipRenderData clip; + // Render command data when commandType == CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_START|END + Clay_OverlayColorRenderData overlayColor; +} Clay_RenderData; + +// Miscellaneous Structs & Enums --------------------------------- + +// Data representing the current internal state of a scrolling element. +typedef struct Clay_ScrollContainerData { + // Note: This is a pointer to the real internal scroll position, mutating it may cause a change in final layout. + // Intended for use with external functionality that modifies scroll position, such as scroll bars or auto scrolling. + Clay_Vector2 *scrollPosition; + // The bounding box of the scroll element. + Clay_Dimensions scrollContainerDimensions; + // The outer dimensions of the inner scroll container content, including the padding of the parent scroll container. + Clay_Dimensions contentDimensions; + // The config that was originally passed to the clip element. + Clay_ClipElementConfig config; + // Indicates whether an actual scroll container matched the provided ID or if the default struct was returned. + bool found; +} Clay_ScrollContainerData; + +// Bounding box and other data for a specific UI element. +typedef struct Clay_ElementData { + // The rectangle that encloses this UI element, with the position relative to the root of the layout. + Clay_BoundingBox boundingBox; + // Indicates whether an actual Element matched the provided ID or if the default struct was returned. + bool found; +} Clay_ElementData; + +// Used by renderers to determine specific handling for each render command. +typedef CLAY_PACKED_ENUM { + // This command type should be skipped. + CLAY_RENDER_COMMAND_TYPE_NONE, + // The renderer should draw a solid color rectangle. + CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + // The renderer should draw a colored border inset into the bounding box. + CLAY_RENDER_COMMAND_TYPE_BORDER, + // The renderer should draw text. + CLAY_RENDER_COMMAND_TYPE_TEXT, + // The renderer should draw an image. + CLAY_RENDER_COMMAND_TYPE_IMAGE, + // The renderer should begin clipping all future draw commands, only rendering content that falls within the provided boundingBox. + CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + // The renderer should finish any previously active clipping, and begin rendering elements in full again. + CLAY_RENDER_COMMAND_TYPE_SCISSOR_END, + // The renderer should begin performing a "color overlay" on all subsequent render commands until disabled again. + CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_START, + // The renderer should disable any previously active "color overlay" and render elements with their standard colors again. + CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_END, + // The renderer should provide a custom implementation for handling this render command based on its .customData + CLAY_RENDER_COMMAND_TYPE_CUSTOM, +} Clay_RenderCommandType; + +typedef struct Clay_RenderCommand { + // A rectangular box that fully encloses this UI element, with the position relative to the root of the layout. + Clay_BoundingBox boundingBox; + // A struct union containing data specific to this command's commandType. + Clay_RenderData renderData; + // A pointer transparently passed through from the original element declaration. + void *userData; + // The id of this element, transparently passed through from the original element declaration. + uint32_t id; + // The z order required for drawing this command correctly. + // Note: the render command array is already sorted in ascending order, and will produce correct results if drawn in naive order. + // This field is intended for use in batching renderers for improved performance. + int16_t zIndex; + // Specifies how to handle rendering of this command. + // CLAY_RENDER_COMMAND_TYPE_RECTANGLE - The renderer should draw a solid color rectangle. + // CLAY_RENDER_COMMAND_TYPE_BORDER - The renderer should draw a colored border inset into the bounding box. + // CLAY_RENDER_COMMAND_TYPE_TEXT - The renderer should draw text. + // CLAY_RENDER_COMMAND_TYPE_IMAGE - The renderer should draw an image. + // CLAY_RENDER_COMMAND_TYPE_SCISSOR_START - The renderer should begin clipping all future draw commands, only rendering content that falls within the provided boundingBox. + // CLAY_RENDER_COMMAND_TYPE_SCISSOR_END - The renderer should finish any previously active clipping, and begin rendering elements in full again. + // CLAY_RENDER_COMMAND_TYPE_CUSTOM - The renderer should provide a custom implementation for handling this render command based on its .customData + Clay_RenderCommandType commandType; +} Clay_RenderCommand; + +// A sized array of render commands. +typedef struct Clay_RenderCommandArray { + // The underlying max capacity of the array, not necessarily all initialized. + int32_t capacity; + // The number of initialized elements in this array. Used for loops and iteration. + int32_t length; + // A pointer to the first element in the internal array. + Clay_RenderCommand* internalArray; +} Clay_RenderCommandArray; + +// Represents the current state of interaction with clay this frame. +typedef CLAY_PACKED_ENUM { + // A left mouse click, or touch occurred this frame. + CLAY_POINTER_DATA_PRESSED_THIS_FRAME, + // The left mouse button click or touch happened at some point in the past, and is still currently held down this frame. + CLAY_POINTER_DATA_PRESSED, + // The left mouse button click or touch was released this frame. + CLAY_POINTER_DATA_RELEASED_THIS_FRAME, + // The left mouse button click or touch is not currently down / was released at some point in the past. + CLAY_POINTER_DATA_RELEASED, +} Clay_PointerDataInteractionState; + +// Information on the current state of pointer interactions this frame. +typedef struct Clay_PointerData { + // The position of the mouse / touch / pointer relative to the root of the layout. + Clay_Vector2 position; + // Represents the current state of interaction with clay this frame. + // CLAY_POINTER_DATA_PRESSED_THIS_FRAME - A left mouse click, or touch occurred this frame. + // CLAY_POINTER_DATA_PRESSED - The left mouse button click or touch happened at some point in the past, and is still currently held down this frame. + // CLAY_POINTER_DATA_RELEASED_THIS_FRAME - The left mouse button click or touch was released this frame. + // CLAY_POINTER_DATA_RELEASED - The left mouse button click or touch is not currently down / was released at some point in the past. + Clay_PointerDataInteractionState state; +} Clay_PointerData; + +typedef struct Clay_ElementDeclaration { + // Controls various settings that affect the size and position of an element, as well as the sizes and positions of any child elements. + Clay_LayoutConfig layout; + // Controls the background color of the resulting element. + // By convention specified as 0-255, but interpretation is up to the renderer. + // If no other config is specified, .backgroundColor will generate a RECTANGLE render command, otherwise it will be passed as a property to IMAGE or CUSTOM render commands. + Clay_Color backgroundColor; + // Perform an image editing style "Color Overlay" on this element and all its children, equivalent to + // glsl mix(elementColor, overlayColor.rgb, overlayColor.a) + Clay_Color overlayColor; + // Controls the "radius", or corner rounding of elements, including rectangles, borders and images. + Clay_CornerRadius cornerRadius; + // Controls settings related to aspect ratio scaling. + Clay_AspectRatioElementConfig aspectRatio; + // Controls settings related to image elements. + Clay_ImageElementConfig image; + // Controls whether and how an element "floats", which means it layers over the top of other elements in z order, and doesn't affect the position and size of siblings or parent elements. + // Note: in order to activate floating, .floating.attachTo must be set to something other than the default value. + Clay_FloatingElementConfig floating; + // Used to create CUSTOM render commands, usually to render element types not supported by Clay. + Clay_CustomElementConfig custom; + // Controls whether an element should clip its contents, as well as providing child x,y offset configuration for scrolling. + Clay_ClipElementConfig clip; + // Controls settings related to element borders, and will generate BORDER render commands. + Clay_BorderElementConfig border; + Clay_TransitionElementConfig transition; + // A pointer that will be transparently passed through to resulting render commands. + void *userData; +} Clay_ElementDeclaration; + +CLAY__WRAPPER_STRUCT(Clay_ElementDeclaration); + +// Represents the type of error clay encountered while computing layout. +typedef CLAY_PACKED_ENUM { + // A text measurement function wasn't provided using Clay_SetMeasureTextFunction(), or the provided function was null. + CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED, + // Clay attempted to allocate its internal data structures but ran out of space. + // The arena passed to Clay_Initialize was created with a capacity smaller than that required by Clay_MinMemorySize(). + CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED, + // Clay ran out of capacity in its internal array for storing elements. This limit can be increased with Clay_SetMaxElementCount(). + CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED, + // Clay ran out of capacity in its internal array for storing elements. This limit can be increased with Clay_SetMaxMeasureTextCacheWordCount(). + CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED, + // Two elements were declared with exactly the same ID within one layout. + CLAY_ERROR_TYPE_DUPLICATE_ID, + // A floating element was declared using CLAY_ATTACH_TO_ELEMENT_ID and either an invalid .parentId was provided or no element with the provided .parentId was found. + CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND, + // An element was declared that using CLAY_SIZING_PERCENT but the percentage value was over 1. Percentage values are expected to be in the 0-1 range. + CLAY_ERROR_TYPE_PERCENTAGE_OVER_1, + // Clay encountered an internal error. It would be wonderful if you could report this so we can fix it! + CLAY_ERROR_TYPE_INTERNAL_ERROR, + // Clay__OpenElement was called more times than Clay__CloseElement, so there were still remaining open elements when the layout ended. + CLAY_ERROR_TYPE_UNBALANCED_OPEN_CLOSE, + CLAY_ERROR_TYPE_HASH_MAP_CAPACITY_EXCEEDED +} Clay_ErrorType; + +// Data to identify the error that clay has encountered. +typedef struct Clay_ErrorData { + // Represents the type of error clay encountered while computing layout. + // CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED - A text measurement function wasn't provided using Clay_SetMeasureTextFunction(), or the provided function was null. + // CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED - Clay attempted to allocate its internal data structures but ran out of space. The arena passed to Clay_Initialize was created with a capacity smaller than that required by Clay_MinMemorySize(). + // CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED - Clay ran out of capacity in its internal array for storing elements. This limit can be increased with Clay_SetMaxElementCount(). + // CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED - Clay ran out of capacity in its internal array for storing elements. This limit can be increased with Clay_SetMaxMeasureTextCacheWordCount(). + // CLAY_ERROR_TYPE_DUPLICATE_ID - Two elements were declared with exactly the same ID within one layout. + // CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND - A floating element was declared using CLAY_ATTACH_TO_ELEMENT_ID and either an invalid .parentId was provided or no element with the provided .parentId was found. + // CLAY_ERROR_TYPE_PERCENTAGE_OVER_1 - An element was declared that using CLAY_SIZING_PERCENT but the percentage value was over 1. Percentage values are expected to be in the 0-1 range. + // CLAY_ERROR_TYPE_INTERNAL_ERROR - Clay encountered an internal error. It would be wonderful if you could report this so we can fix it! + // CLAY_ERROR_TYPE_UNBALANCED_OPEN_CLOSE - Clay__OpenElement was called more times than Clay__CloseElement, so there were still remaining open elements when the layout ended. + // CLAY_ERROR_TYPE_HASH_MAP_CAPACITY_EXCEEDED - Clay ran out of capacity in its internal hash map for storing element IDs -> elements. This limit can be increased with Clay_SetMaxElementCount(). + Clay_ErrorType errorType; + // A string containing human-readable error text that explains the error in more detail. + Clay_String errorText; + // A transparent pointer passed through from when the error handler was first provided. + void *userData; +} Clay_ErrorData; + +// A wrapper struct around Clay's error handler function. +typedef struct { + // A user provided function to call when Clay encounters an error during layout. + void (*errorHandlerFunction)(Clay_ErrorData errorText); + // A pointer that will be transparently passed through to the error handler when it is called. + void *userData; +} Clay_ErrorHandler; + +// Function Forward Declarations --------------------------------- + +// Public API functions ------------------------------------------ + +// Returns the size, in bytes, of the minimum amount of memory Clay requires to operate at its current settings. +CLAY_DLL_EXPORT uint32_t Clay_MinMemorySize(void); +// Creates an arena for clay to use for its internal allocations, given a certain capacity in bytes and a pointer to an allocation of at least that size. +// Intended to be used with Clay_MinMemorySize in the following way: +// uint32_t minMemoryRequired = Clay_MinMemorySize(); +// Clay_Arena clayMemory = Clay_CreateArenaWithCapacityAndMemory(minMemoryRequired, malloc(minMemoryRequired)); +CLAY_DLL_EXPORT Clay_Arena Clay_CreateArenaWithCapacityAndMemory(size_t capacity, void *memory); +// Sets the state of the "pointer" (i.e. the mouse or touch) in Clay's internal data. Used for detecting and responding to mouse events in the debug view, +// as well as for Clay_Hovered() and scroll element handling. +CLAY_DLL_EXPORT void Clay_SetPointerState(Clay_Vector2 position, bool pointerDown); +// Returns the state of the "pointer" (i.e. the mouse or touch) which was set via Clay_SetPointerState(). +CLAY_DLL_EXPORT Clay_PointerData Clay_GetPointerState(void); +// Initialize Clay's internal arena and setup required data before layout can begin. Only needs to be called once. +// - arena can be created using Clay_CreateArenaWithCapacityAndMemory() +// - layoutDimensions are the initial bounding dimensions of the layout (i.e. the screen width and height for a full screen layout) +// - errorHandler is used by Clay to inform you if something has gone wrong in configuration or layout. +CLAY_DLL_EXPORT Clay_Context* Clay_Initialize(Clay_Arena arena, Clay_Dimensions layoutDimensions, Clay_ErrorHandler errorHandler); +// Returns the Context that clay is currently using. Used when using multiple instances of clay simultaneously. +CLAY_DLL_EXPORT Clay_Context* Clay_GetCurrentContext(void); +// Sets the context that clay will use to compute the layout. +// Used to restore a context saved from Clay_GetCurrentContext when using multiple instances of clay simultaneously. +CLAY_DLL_EXPORT void Clay_SetCurrentContext(Clay_Context* context); +// Updates the state of Clay's internal scroll data, updating scroll content positions if scrollDelta is non zero, and progressing momentum scrolling. +// - enableDragScrolling when set to true will enable mobile device like "touch drag" scroll of scroll containers, including momentum scrolling after the touch has ended. +// - scrollDelta is the amount to scroll this frame on each axis in pixels. +// - deltaTime is the time in seconds since the last "frame" (scroll update) +CLAY_DLL_EXPORT void Clay_UpdateScrollContainers(bool enableDragScrolling, Clay_Vector2 scrollDelta, float deltaTime); +// Returns the internally stored scroll offset for the currently open element. +// Generally intended for use with clip elements to create scrolling containers. +CLAY_DLL_EXPORT Clay_Vector2 Clay_GetScrollOffset(void); +// Updates the layout dimensions in response to the window or outer container being resized. +CLAY_DLL_EXPORT void Clay_SetLayoutDimensions(Clay_Dimensions dimensions); +// Returns the current dimensions set by Clay_SetLayoutDimensions. +CLAY_DLL_EXPORT Clay_Dimensions Clay_GetLayoutDimensions(void); +// Called before starting any layout declarations. +CLAY_DLL_EXPORT void Clay_BeginLayout(void); +// Called when all layout declarations are finished. +// Computes the layout and generates and returns the array of render commands to draw. +CLAY_DLL_EXPORT Clay_RenderCommandArray Clay_EndLayout(float deltaTime); +// Gets the ID of the currently open element, useful for retrieving IDs generated by CLAY_AUTO_ID() +CLAY_DLL_EXPORT uint32_t Clay_GetOpenElementId(void); +// Calculates a hash ID from the given idString. +// Generally only used for dynamic strings when CLAY_ID("stringLiteral") can't be used. +CLAY_DLL_EXPORT Clay_ElementId Clay_GetElementId(Clay_String idString); +// Calculates a hash ID from the given idString and index. +// - index is used to avoid constructing dynamic ID strings in loops. +// Generally only used for dynamic strings when CLAY_IDI("stringLiteral", index) can't be used. +CLAY_DLL_EXPORT Clay_ElementId Clay_GetElementIdWithIndex(Clay_String idString, uint32_t index); +// Returns layout data such as the final calculated bounding box for an element with a given ID. +// The returned Clay_ElementData contains a `found` bool that will be true if an element with the provided ID was found. +// This ID can be calculated either with CLAY_ID() for string literal IDs, or Clay_GetElementId for dynamic strings. +CLAY_DLL_EXPORT Clay_ElementData Clay_GetElementData(Clay_ElementId id); +// Returns true if the pointer position provided by Clay_SetPointerState is within the current element's bounding box. +// Works during element declaration, e.g. CLAY({ .backgroundColor = Clay_Hovered() ? BLUE : RED }); +CLAY_DLL_EXPORT bool Clay_Hovered(void); +// Bind a callback that will be called when the pointer position provided by Clay_SetPointerState is within the current element's bounding box. +// - onHoverFunction is a function pointer to a user defined function. +// - userData is a pointer that will be transparently passed through when the onHoverFunction is called. +CLAY_DLL_EXPORT void Clay_OnHover(void (*onHoverFunction)(Clay_ElementId elementId, Clay_PointerData pointerData, void *userData), void *userData); +// An imperative function that returns true if the pointer position provided by Clay_SetPointerState is within the element with the provided ID's bounding box. +// This ID can be calculated either with CLAY_ID() for string literal IDs, or Clay_GetElementId for dynamic strings. +CLAY_DLL_EXPORT bool Clay_PointerOver(Clay_ElementId elementId); +// Returns the array of element IDs that the pointer is currently over. +CLAY_DLL_EXPORT Clay_ElementIdArray Clay_GetPointerOverIds(void); +// Returns data representing the state of the scrolling element with the provided ID. +// The returned Clay_ScrollContainerData contains a `found` bool that will be true if a scroll element was found with the provided ID. +// An imperative function that returns true if the pointer position provided by Clay_SetPointerState is within the element with the provided ID's bounding box. +// This ID can be calculated either with CLAY_ID() for string literal IDs, or Clay_GetElementId for dynamic strings. +CLAY_DLL_EXPORT Clay_ScrollContainerData Clay_GetScrollContainerData(Clay_ElementId id); +// Binds a callback function that Clay will call to determine the dimensions of a given string slice. +// - measureTextFunction is a user provided function that adheres to the interface Clay_Dimensions (Clay_StringSlice text, Clay_TextElementConfig *config, void *userData); +// - userData is a pointer that will be transparently passed through when the measureTextFunction is called. +CLAY_DLL_EXPORT void Clay_SetMeasureTextFunction(Clay_Dimensions (*measureTextFunction)(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData), void *userData); +// Experimental - Used in cases where Clay needs to integrate with a system that manages its own scrolling containers externally. +// Please reach out if you plan to use this function, as it may be subject to change. +CLAY_DLL_EXPORT void Clay_SetQueryScrollOffsetFunction(Clay_Vector2 (*queryScrollOffsetFunction)(uint32_t elementId, void *userData), void *userData); +// A bounds-checked "get" function for the Clay_RenderCommandArray returned from Clay_EndLayout(). +CLAY_DLL_EXPORT Clay_RenderCommand * Clay_RenderCommandArray_Get(Clay_RenderCommandArray* array, int32_t index); +// Enables and disables Clay's internal debug tools. +// This state is retained and does not need to be set each frame. +CLAY_DLL_EXPORT void Clay_SetDebugModeEnabled(bool enabled); +// Returns true if Clay's internal debug tools are currently enabled. +CLAY_DLL_EXPORT bool Clay_IsDebugModeEnabled(void); +// Enables and disables visibility culling. By default, Clay will not generate render commands for elements whose bounding box is entirely outside the screen. +CLAY_DLL_EXPORT void Clay_SetCullingEnabled(bool enabled); +// Returns the maximum number of UI elements supported by Clay's current configuration. +CLAY_DLL_EXPORT int32_t Clay_GetMaxElementCount(void); +// Modifies the maximum number of UI elements supported by Clay's current configuration. +// This may require reallocating additional memory, and re-calling Clay_Initialize(); +CLAY_DLL_EXPORT void Clay_SetMaxElementCount(int32_t maxElementCount); +// Returns the maximum number of measured "words" (whitespace seperated runs of characters) that Clay can store in its internal text measurement cache. +CLAY_DLL_EXPORT int32_t Clay_GetMaxMeasureTextCacheWordCount(void); +// Modifies the maximum number of measured "words" (whitespace seperated runs of characters) that Clay can store in its internal text measurement cache. +// This may require reallocating additional memory, and re-calling Clay_Initialize(); +CLAY_DLL_EXPORT void Clay_SetMaxMeasureTextCacheWordCount(int32_t maxMeasureTextCacheWordCount); +// Resets Clay's internal text measurement cache. Useful if font mappings have changed or fonts have been reloaded. +CLAY_DLL_EXPORT void Clay_ResetMeasureTextCache(void); +// A built in transition function that uses the "Ease Out" curve +CLAY_DLL_EXPORT bool Clay_EaseOut(Clay_TransitionCallbackArguments arguments); + +// Internal API functions required by macros ---------------------- + +CLAY_DLL_EXPORT void Clay__OpenElement(void); +CLAY_DLL_EXPORT void Clay__OpenElementWithId(Clay_ElementId elementId); +CLAY_DLL_EXPORT void Clay__ConfigureOpenElement(const Clay_ElementDeclaration config); +CLAY_DLL_EXPORT void Clay__ConfigureOpenElementPtr(const Clay_ElementDeclaration *config); +CLAY_DLL_EXPORT void Clay__CloseElement(void); +CLAY_DLL_EXPORT Clay_ElementId Clay__HashString(Clay_String key, uint32_t seed); +CLAY_DLL_EXPORT Clay_ElementId Clay__HashStringWithOffset(Clay_String key, uint32_t offset, uint32_t seed); +CLAY_DLL_EXPORT void Clay__OpenTextElement(Clay_String text, Clay_TextElementConfig textConfig); + +extern Clay_Color Clay__debugViewHighlightColor; +extern uint32_t Clay__debugViewWidth; + +#ifdef __cplusplus +} +#endif + +#endif // CLAY_HEADER + +// ----------------------------------------- +// IMPLEMENTATION -------------------------- +// ----------------------------------------- +#ifdef CLAY_IMPLEMENTATION +#undef CLAY_IMPLEMENTATION + +#ifndef CLAY__NULL +#define CLAY__NULL 0 +#endif + +#ifndef CLAY__MAXFLOAT +#define CLAY__MAXFLOAT 3.40282346638528859812e+38F +#endif + +Clay_LayoutConfig CLAY_LAYOUT_DEFAULT = CLAY__DEFAULT_STRUCT; + +Clay_Color Clay__Color_DEFAULT = CLAY__DEFAULT_STRUCT; +Clay_CornerRadius Clay__CornerRadius_DEFAULT = CLAY__DEFAULT_STRUCT; +Clay_BorderWidth Clay__BorderWidth_DEFAULT = CLAY__DEFAULT_STRUCT; + +// The below functions define array bounds checking and convenience functions for a provided type. +#define CLAY__ARRAY_DEFINE_FUNCTIONS(typeName, arrayName) \ + \ +typedef struct \ +{ \ + int32_t length; \ + typeName *internalArray; \ +} arrayName##Slice; \ + \ +typeName typeName##_DEFAULT = CLAY__DEFAULT_STRUCT; \ + \ +arrayName arrayName##_Allocate_Arena(int32_t capacity, Clay_Arena *arena) { \ + return CLAY__INIT(arrayName){.capacity = capacity, .length = 0, \ + .internalArray = (typeName *)Clay__Array_Allocate_Arena(capacity, sizeof(typeName), arena)}; \ +} \ + \ +typeName *arrayName##_Get(arrayName *array, int32_t index) { \ + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &typeName##_DEFAULT; \ +} \ + \ +typeName arrayName##_GetValue(arrayName *array, int32_t index) { \ + return Clay__Array_RangeCheck(index, array->length) ? array->internalArray[index] : typeName##_DEFAULT; \ +} \ + \ +typeName *arrayName##_GetCheckCapacity(arrayName *array, int32_t index) { \ + return Clay__Array_RangeCheck(index, array->capacity) ? &array->internalArray[index] : &typeName##_DEFAULT; \ +} \ + \ +typeName *arrayName##_Add(arrayName *array, typeName item) { \ + if (Clay__Array_AddCapacityCheck(array->length, array->capacity)) { \ + array->internalArray[array->length++] = item; \ + return &array->internalArray[array->length - 1]; \ + } \ + return &typeName##_DEFAULT; \ +} \ + \ +typeName *arrayName##Slice_Get(arrayName##Slice *slice, int32_t index) { \ + return Clay__Array_RangeCheck(index, slice->length) ? &slice->internalArray[index] : &typeName##_DEFAULT; \ +} \ + \ +typeName arrayName##_RemoveSwapback(arrayName *array, int32_t index) { \ + if (Clay__Array_RangeCheck(index, array->length)) { \ + array->length--; \ + typeName removed = array->internalArray[index]; \ + array->internalArray[index] = array->internalArray[array->length]; \ + return removed; \ + } \ + return typeName##_DEFAULT; \ +} \ + \ +typeName* arrayName##_Set(arrayName *array, int32_t index, typeName value) { \ + if (Clay__Array_RangeCheck(index, array->capacity)) { \ + array->internalArray[index] = value; \ + array->length = index < array->length ? array->length : index + 1; \ + return &array->internalArray[index];\ + } \ + return NULL;\ +} \ + \ +typeName* arrayName##_Set_DontTouchLength(arrayName *array, int32_t index, typeName value) { \ + if (Clay__Array_RangeCheck(index, array->capacity)) { \ + array->internalArray[index] = value; \ + return &array->internalArray[index];\ + } \ + return NULL;\ +} \ + +#define CLAY__ARRAY_DEFINE(typeName, arrayName) \ +typedef struct \ +{ \ + int32_t capacity; \ + int32_t length; \ + typeName *internalArray; \ +} arrayName; \ + \ +CLAY__ARRAY_DEFINE_FUNCTIONS(typeName, arrayName) \ + +Clay_Context *Clay__currentContext; +int32_t Clay__defaultMaxElementCount = 8192; +int32_t Clay__defaultMaxMeasureTextWordCacheCount = 16384; + +void Clay__ErrorHandlerFunctionDefault(Clay_ErrorData errorText) { + (void) errorText; +} + +Clay_String CLAY__SPACECHAR = { .length = 1, .chars = " " }; +Clay_String CLAY__STRING_DEFAULT = { .length = 0, .chars = NULL }; + +typedef struct { + bool maxElementsExceeded; + bool maxRenderCommandsExceeded; + bool maxTextMeasureCacheExceeded; + bool textMeasurementFunctionNotSet; + bool hashMapCapacityExceeded; +} Clay_BooleanWarnings; + +typedef struct { + Clay_String baseMessage; + Clay_String dynamicMessage; +} Clay__Warning; + +Clay__Warning CLAY__WARNING_DEFAULT = CLAY__DEFAULT_STRUCT; + +typedef struct { + int32_t capacity; + int32_t length; + Clay__Warning *internalArray; +} Clay__WarningArray; + +Clay__WarningArray Clay__WarningArray_Allocate_Arena(int32_t capacity, Clay_Arena *arena); +Clay__Warning *Clay__WarningArray_Add(Clay__WarningArray *array, Clay__Warning item); +void* Clay__Array_Allocate_Arena(int32_t capacity, uint32_t itemSize, Clay_Arena *arena); +bool Clay__Array_RangeCheck(int32_t index, int32_t length); +bool Clay__Array_AddCapacityCheck(int32_t length, int32_t capacity); + +CLAY__ARRAY_DEFINE(bool, Clay__boolArray) +CLAY__ARRAY_DEFINE(int32_t, Clay__int32_tArray) +CLAY__ARRAY_DEFINE(char, Clay__charArray) +CLAY__ARRAY_DEFINE_FUNCTIONS(Clay_ElementId, Clay_ElementIdArray) +CLAY__ARRAY_DEFINE(Clay_String, Clay__StringArray) +CLAY__ARRAY_DEFINE_FUNCTIONS(Clay_RenderCommand, Clay_RenderCommandArray) + +typedef struct { + Clay_Dimensions dimensions; + Clay_String line; +} Clay__WrappedTextLine; + +CLAY__ARRAY_DEFINE(Clay__WrappedTextLine, Clay__WrappedTextLineArray) + +typedef struct { + Clay_String text; + Clay_Dimensions preferredDimensions; + Clay__WrappedTextLineArraySlice wrappedLines; +} Clay__TextElementData; + +typedef struct { + int32_t *elements; + uint16_t length; +} Clay__LayoutElementChildren; + +typedef struct Clay_LayoutElement { + Clay__LayoutElementChildren children; + Clay_Dimensions dimensions; + Clay_Dimensions minDimensions; + union { + Clay_ElementDeclaration config; + struct { + Clay_TextElementConfig textConfig; + Clay__TextElementData textElementData; + }; + }; + uint32_t id; + uint16_t floatingChildrenCount; + bool isTextElement; + // True if the element is currently in an exit transition, and is "synthetic" + // i.e. data was retained from previous frames + bool exiting; +} Clay_LayoutElement; + +CLAY__ARRAY_DEFINE(Clay_LayoutElement, Clay_LayoutElementArray) + +typedef struct { + Clay_LayoutElement *layoutElement; + Clay_BoundingBox boundingBox; + Clay_Dimensions contentSize; + Clay_Vector2 scrollOrigin; + Clay_Vector2 pointerOrigin; + Clay_Vector2 scrollMomentum; + Clay_Vector2 scrollPosition; + Clay_Vector2 previousDelta; + float momentumTime; + uint32_t elementId; + bool openThisFrame; + bool pointerScrollActive; +} Clay__ScrollContainerDataInternal; + +CLAY__ARRAY_DEFINE(Clay__ScrollContainerDataInternal, Clay__ScrollContainerDataInternalArray) + +// Data representing the current internal state of a transition element. +typedef struct Clay__TransitionDataInternal { + Clay_TransitionData initialState; + Clay_TransitionData currentState; + Clay_TransitionData targetState; + Clay_LayoutElement* elementThisFrame; + Clay_Vector2 oldParentRelativePosition; + uint32_t elementId; + uint32_t parentId; + uint32_t siblingIndex; + float elapsedTime; + Clay_TransitionState state; + bool transitionOut; + bool reparented; + Clay_TransitionProperty activeProperties; +} Clay__TransitionDataInternal; + +CLAY__ARRAY_DEFINE(Clay__TransitionDataInternal, Clay__TransitionDataInternalArray) + +typedef struct { // todo get this struct into a single cache line + Clay_BoundingBox boundingBox; + Clay_ElementId elementId; + Clay_LayoutElement* layoutElement; + void (*onHoverFunction)(Clay_ElementId elementId, Clay_PointerData pointerInfo, void *userData); + void *hoverFunctionUserData; + int32_t nextIndex; + uint32_t generation; + bool appearedThisFrame; + struct { + bool collision; + bool collapsed; + } debugData; +} Clay_LayoutElementHashMapItem; + +CLAY__ARRAY_DEFINE(Clay_LayoutElementHashMapItem, Clay__LayoutElementHashMapItemArray) + +typedef struct { + int32_t startOffset; + int32_t length; + float width; + int32_t next; +} Clay__MeasuredWord; + +CLAY__ARRAY_DEFINE(Clay__MeasuredWord, Clay__MeasuredWordArray) + +typedef struct { + Clay_Dimensions unwrappedDimensions; + int32_t measuredWordsStartIndex; + float minWidth; + bool containsNewlines; + // Hash map data + uint32_t id; + int32_t nextIndex; + uint32_t generation; +} Clay__MeasureTextCacheItem; + +CLAY__ARRAY_DEFINE(Clay__MeasureTextCacheItem, Clay__MeasureTextCacheItemArray) + +typedef struct { + Clay_LayoutElement *layoutElement; + Clay_Vector2 position; + Clay_Vector2 nextChildOffset; + bool parentMovedThisFramed; // Used to relativise transitions +} Clay__LayoutElementTreeNode; + +CLAY__ARRAY_DEFINE(Clay__LayoutElementTreeNode, Clay__LayoutElementTreeNodeArray) + +typedef struct { + int32_t layoutElementIndex; + uint32_t parentId; // This can be zero in the case of the root layout tree + uint32_t clipElementId; // This can be zero if there is no clip element + int16_t zIndex; + Clay_Vector2 pointerOffset; // Only used when scroll containers are managed externally +} Clay__LayoutElementTreeRoot; + +CLAY__ARRAY_DEFINE(Clay__LayoutElementTreeRoot, Clay__LayoutElementTreeRootArray) + +struct Clay_Context { + int32_t maxElementCount; + int32_t maxMeasureTextCacheWordCount; + int32_t exitingElementsLength; + int32_t exitingElementsChildrenLength; + bool warningsEnabled; + bool rootResizedLastFrame; + Clay_ErrorHandler errorHandler; + Clay_BooleanWarnings booleanWarnings; + Clay__WarningArray warnings; + + Clay_PointerData pointerInfo; + Clay_Dimensions layoutDimensions; + Clay_ElementId dynamicElementIndexBaseHash; + uint32_t dynamicElementIndex; + bool debugModeEnabled; + bool disableCulling; + bool externalScrollHandlingEnabled; + uint32_t debugSelectedElementId; + uint32_t generation; + uintptr_t arenaResetOffset; + void *measureTextUserData; + void *queryScrollOffsetUserData; + Clay_Arena internalArena; + // Layout Elements / Render Commands + Clay_LayoutElementArray layoutElements; + Clay_RenderCommandArray renderCommands; + Clay__int32_tArray openLayoutElementStack; + Clay__int32_tArray layoutElementChildren; + Clay__int32_tArray layoutElementChildrenBuffer; + Clay__int32_tArray reusableElementIndexBuffer; + Clay__int32_tArray layoutElementClipElementIds; + // Misc Data Structures + Clay__StringArray layoutElementIdStrings; + Clay__WrappedTextLineArray wrappedTextLines; + Clay__LayoutElementTreeNodeArray layoutElementTreeNodeArray1; + Clay__LayoutElementTreeRootArray layoutElementTreeRoots; + Clay__LayoutElementHashMapItemArray layoutElementsHashMapInternal; + Clay__int32_tArray layoutElementsHashMap; + Clay__int32_tArray layoutElementsHashMapFreeList; + Clay__MeasureTextCacheItemArray measureTextHashMapInternal; + Clay__int32_tArray measureTextHashMapInternalFreeList; + Clay__int32_tArray measureTextHashMap; + Clay__MeasuredWordArray measuredWords; + Clay__int32_tArray measuredWordsFreeList; + Clay__int32_tArray openClipElementStack; + Clay_ElementIdArray pointerOverIds; + Clay__ScrollContainerDataInternalArray scrollContainerDatas; + Clay__TransitionDataInternalArray transitionDatas; + Clay__boolArray treeNodeVisited; + Clay__charArray dynamicStringData; +}; + +Clay_Context* Clay__Context_Allocate_Arena(Clay_Arena *arena) { + size_t totalSizeBytes = sizeof(Clay_Context); + if (totalSizeBytes > arena->capacity) + { + return NULL; + } + arena->nextAllocation += totalSizeBytes; + return (Clay_Context*)(arena->memory); +} + +Clay_String Clay__WriteStringToCharBuffer(Clay__charArray *buffer, Clay_String string) { + for (int32_t i = 0; i < string.length; i++) { + buffer->internalArray[buffer->length + i] = string.chars[i]; + } + buffer->length += string.length; + return CLAY__INIT(Clay_String) { .length = string.length, .chars = (const char *)(buffer->internalArray + buffer->length - string.length) }; +} + +#ifdef CLAY_WASM + __attribute__((import_module("clay"), import_name("measureTextFunction"))) Clay_Dimensions Clay__MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData); + __attribute__((import_module("clay"), import_name("queryScrollOffsetFunction"))) Clay_Vector2 Clay__QueryScrollOffset(uint32_t elementId, void *userData); +#else + Clay_Dimensions (*Clay__MeasureText)(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData); + Clay_Vector2 (*Clay__QueryScrollOffset)(uint32_t elementId, void *userData); +#endif + +Clay_LayoutElement* Clay__GetOpenLayoutElement(void) { + Clay_Context* context = Clay_GetCurrentContext(); + return Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 1)); +} + +Clay_LayoutElement* Clay__GetParentElement(void) { + Clay_Context* context = Clay_GetCurrentContext(); + return Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 2)); +} + +uint32_t Clay__GetParentElementId(void) { + return Clay__GetParentElement()->id; +} + +bool Clay__BorderHasAnyWidth(Clay_BorderElementConfig* borderConfig) { + return borderConfig->width.betweenChildren > 0 || borderConfig->width.left > 0 || borderConfig->width.right > 0 || borderConfig->width.top > 0 || borderConfig->width.bottom > 0; +} + +Clay_ElementId Clay__HashNumber(const uint32_t offset, const uint32_t seed) { + uint32_t hash = seed; + hash += (offset + 48); + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return CLAY__INIT(Clay_ElementId) { .id = hash + 1, .offset = offset, .baseId = seed, .stringId = CLAY__STRING_DEFAULT }; // Reserve the hash result of zero as "null id" +} + +Clay_ElementId Clay__HashString(Clay_String key, const uint32_t seed) { + uint32_t hash = seed; + + for (int32_t i = 0; i < key.length; i++) { + hash += key.chars[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return CLAY__INIT(Clay_ElementId) { .id = hash + 1, .offset = 0, .baseId = hash + 1, .stringId = key }; // Reserve the hash result of zero as "null id" +} + +Clay_ElementId Clay__HashStringWithOffset(Clay_String key, const uint32_t offset, const uint32_t seed) { + uint32_t hash = 0; + uint32_t base = seed; + + for (int32_t i = 0; i < key.length; i++) { + base += key.chars[i]; + base += (base << 10); + base ^= (base >> 6); + } + hash = base; + hash += offset; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += (hash << 3); + base += (base << 3); + hash ^= (hash >> 11); + base ^= (base >> 11); + hash += (hash << 15); + base += (base << 15); + return CLAY__INIT(Clay_ElementId) { .id = hash + 1, .offset = offset, .baseId = base + 1, .stringId = key }; // Reserve the hash result of zero as "null id" +} + +#if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)) +static inline __m128i Clay__SIMDRotateLeft(__m128i x, int r) { + return _mm_or_si128(_mm_slli_epi64(x, r), _mm_srli_epi64(x, 64 - r)); +} + +static inline void Clay__SIMDARXMix(__m128i* a, __m128i* b) { + *a = _mm_add_epi64(*a, *b); + *b = _mm_xor_si128(Clay__SIMDRotateLeft(*b, 17), *a); +} + +uint64_t Clay__HashData(const uint8_t* data, size_t length) { + // Pinched these constants from the BLAKE implementation + __m128i v0 = _mm_set1_epi64x(0x6a09e667f3bcc908ULL); + __m128i v1 = _mm_set1_epi64x(0xbb67ae8584caa73bULL); + __m128i v2 = _mm_set1_epi64x(0x3c6ef372fe94f82bULL); + __m128i v3 = _mm_set1_epi64x(0xa54ff53a5f1d36f1ULL); + + uint8_t overflowBuffer[16] = { 0 }; // Temporary buffer for small inputs + + while (length > 0) { + __m128i msg; + if (length >= 16) { + msg = _mm_loadu_si128((const __m128i*)data); + data += 16; + length -= 16; + } + else { + for (size_t i = 0; i < length; i++) { + overflowBuffer[i] = data[i]; + } + msg = _mm_loadu_si128((const __m128i*)overflowBuffer); + length = 0; + } + + v0 = _mm_xor_si128(v0, msg); + Clay__SIMDARXMix(&v0, &v1); + Clay__SIMDARXMix(&v2, &v3); + + v0 = _mm_add_epi64(v0, v2); + v1 = _mm_add_epi64(v1, v3); + } + + Clay__SIMDARXMix(&v0, &v1); + Clay__SIMDARXMix(&v2, &v3); + v0 = _mm_add_epi64(v0, v2); + v1 = _mm_add_epi64(v1, v3); + v0 = _mm_add_epi64(v0, v1); + + uint64_t result[2]; + _mm_storeu_si128((__m128i*)result, v0); + + return result[0] ^ result[1]; +} +#elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__) +static inline void Clay__SIMDARXMix(uint64x2_t* a, uint64x2_t* b) { + *a = vaddq_u64(*a, *b); + *b = veorq_u64(vorrq_u64(vshlq_n_u64(*b, 17), vshrq_n_u64(*b, 64 - 17)), *a); +} + +uint64_t Clay__HashData(const uint8_t* data, size_t length) { + // Pinched these constants from the BLAKE implementation + uint64x2_t v0 = vdupq_n_u64(0x6a09e667f3bcc908ULL); + uint64x2_t v1 = vdupq_n_u64(0xbb67ae8584caa73bULL); + uint64x2_t v2 = vdupq_n_u64(0x3c6ef372fe94f82bULL); + uint64x2_t v3 = vdupq_n_u64(0xa54ff53a5f1d36f1ULL); + + uint8_t overflowBuffer[8] = { 0 }; + + while (length > 0) { + uint64x2_t msg; + if (length > 16) { + msg = vld1q_u64((const uint64_t*)data); + data += 16; + length -= 16; + } + else if (length > 8) { + msg = vcombine_u64(vld1_u64((const uint64_t*)data), vdup_n_u64(0)); + data += 8; + length -= 8; + } + else { + for (size_t i = 0; i < length; i++) { + overflowBuffer[i] = data[i]; + } + uint8x8_t lower = vld1_u8(overflowBuffer); + msg = vreinterpretq_u64_u8(vcombine_u8(lower, vdup_n_u8(0))); + length = 0; + } + v0 = veorq_u64(v0, msg); + Clay__SIMDARXMix(&v0, &v1); + Clay__SIMDARXMix(&v2, &v3); + + v0 = vaddq_u64(v0, v2); + v1 = vaddq_u64(v1, v3); + } + + Clay__SIMDARXMix(&v0, &v1); + Clay__SIMDARXMix(&v2, &v3); + v0 = vaddq_u64(v0, v2); + v1 = vaddq_u64(v1, v3); + v0 = vaddq_u64(v0, v1); + + uint64_t result[2]; + vst1q_u64(result, v0); + + return result[0] ^ result[1]; +} +#else +uint64_t Clay__HashData(const uint8_t* data, size_t length) { + uint64_t hash = 0; + + for (size_t i = 0; i < length; i++) { + hash += data[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + return hash; +} +#endif + +uint32_t Clay__HashStringContentsWithConfig(Clay_String *text, Clay_TextElementConfig *config) { + uint32_t hash = 0; + if (text->isStaticallyAllocated) { + hash += (uintptr_t)text->chars; + hash += (hash << 10); + hash ^= (hash >> 6); + hash += text->length; + hash += (hash << 10); + hash ^= (hash >> 6); + } else { + hash = Clay__HashData((const uint8_t *)text->chars, text->length) % UINT32_MAX; + } + + hash += config->fontId; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += config->fontSize; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += config->letterSpacing; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return hash + 1; // Reserve the hash result of zero as "null id" +} + +Clay__MeasuredWord *Clay__AddMeasuredWord(Clay__MeasuredWord word, Clay__MeasuredWord *previousWord) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->measuredWordsFreeList.length > 0) { + uint32_t newItemIndex = Clay__int32_tArray_GetValue(&context->measuredWordsFreeList, (int)context->measuredWordsFreeList.length - 1); + context->measuredWordsFreeList.length--; + Clay__MeasuredWordArray_Set(&context->measuredWords, (int)newItemIndex, word); + previousWord->next = (int32_t)newItemIndex; + return Clay__MeasuredWordArray_Get(&context->measuredWords, (int)newItemIndex); + } else { + previousWord->next = (int32_t)context->measuredWords.length; + return Clay__MeasuredWordArray_Add(&context->measuredWords, word); + } +} + +Clay__MeasureTextCacheItem *Clay__MeasureTextCached(Clay_String *text, Clay_TextElementConfig *config) { + Clay_Context* context = Clay_GetCurrentContext(); + #ifndef CLAY_WASM + if (!Clay__MeasureText) { + if (!context->booleanWarnings.textMeasurementFunctionNotSet) { + context->booleanWarnings.textMeasurementFunctionNotSet = true; + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED, + .errorText = CLAY_STRING("Clay's internal MeasureText function is null. You may have forgotten to call Clay_SetMeasureTextFunction(), or passed a NULL function pointer by mistake."), + .userData = context->errorHandler.userData }); + } + return &Clay__MeasureTextCacheItem_DEFAULT; + } + #endif + uint32_t id = Clay__HashStringContentsWithConfig(text, config); + uint32_t hashBucket = id % (context->maxMeasureTextCacheWordCount / 32); + int32_t elementIndexPrevious = 0; + int32_t elementIndex = context->measureTextHashMap.internalArray[hashBucket]; + while (elementIndex != 0) { + Clay__MeasureTextCacheItem *hashEntry = Clay__MeasureTextCacheItemArray_Get(&context->measureTextHashMapInternal, elementIndex); + if (hashEntry->id == id) { + hashEntry->generation = context->generation; + return hashEntry; + } + // This element hasn't been seen in a few frames, delete the hash map item + if (context->generation - hashEntry->generation > 2) { + // Add all the measured words that were included in this measurement to the freelist + int32_t nextWordIndex = hashEntry->measuredWordsStartIndex; + while (nextWordIndex != -1) { + Clay__MeasuredWord *measuredWord = Clay__MeasuredWordArray_Get(&context->measuredWords, nextWordIndex); + Clay__int32_tArray_Add(&context->measuredWordsFreeList, nextWordIndex); + nextWordIndex = measuredWord->next; + } + + int32_t nextIndex = hashEntry->nextIndex; + Clay__MeasureTextCacheItemArray_Set(&context->measureTextHashMapInternal, elementIndex, CLAY__INIT(Clay__MeasureTextCacheItem) { .measuredWordsStartIndex = -1 }); + Clay__int32_tArray_Add(&context->measureTextHashMapInternalFreeList, elementIndex); + if (elementIndexPrevious == 0) { + context->measureTextHashMap.internalArray[hashBucket] = nextIndex; + } else { + Clay__MeasureTextCacheItem *previousHashEntry = Clay__MeasureTextCacheItemArray_Get(&context->measureTextHashMapInternal, elementIndexPrevious); + previousHashEntry->nextIndex = nextIndex; + } + elementIndex = nextIndex; + } else { + elementIndexPrevious = elementIndex; + elementIndex = hashEntry->nextIndex; + } + } + + int32_t newItemIndex = 0; + Clay__MeasureTextCacheItem newCacheItem = { .measuredWordsStartIndex = -1, .id = id, .generation = context->generation }; + Clay__MeasureTextCacheItem *measured = NULL; + if (context->measureTextHashMapInternalFreeList.length > 0) { + newItemIndex = Clay__int32_tArray_GetValue(&context->measureTextHashMapInternalFreeList, context->measureTextHashMapInternalFreeList.length - 1); + context->measureTextHashMapInternalFreeList.length--; + Clay__MeasureTextCacheItemArray_Set(&context->measureTextHashMapInternal, newItemIndex, newCacheItem); + measured = Clay__MeasureTextCacheItemArray_Get(&context->measureTextHashMapInternal, newItemIndex); + } else { + if (context->measureTextHashMapInternal.length == context->measureTextHashMapInternal.capacity - 1) { + if (!context->booleanWarnings.maxTextMeasureCacheExceeded) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay ran out of capacity while attempting to measure text elements. Try using Clay_SetMaxElementCount() with a higher value."), + .userData = context->errorHandler.userData }); + context->booleanWarnings.maxTextMeasureCacheExceeded = true; + } + return &Clay__MeasureTextCacheItem_DEFAULT; + } + measured = Clay__MeasureTextCacheItemArray_Add(&context->measureTextHashMapInternal, newCacheItem); + newItemIndex = context->measureTextHashMapInternal.length - 1; + } + + int32_t start = 0; + int32_t end = 0; + float lineWidth = 0; + float measuredWidth = 0; + float measuredHeight = 0; + float spaceWidth = Clay__MeasureText(CLAY__INIT(Clay_StringSlice) { .length = 1, .chars = CLAY__SPACECHAR.chars, .baseChars = CLAY__SPACECHAR.chars }, config, context->measureTextUserData).width; + Clay__MeasuredWord tempWord = { .next = -1 }; + Clay__MeasuredWord *previousWord = &tempWord; + while (end < text->length) { + if (context->measuredWords.length == context->measuredWords.capacity - 1) { + if (!context->booleanWarnings.maxTextMeasureCacheExceeded) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay has run out of space in it's internal text measurement cache. Try using Clay_SetMaxMeasureTextCacheWordCount() (default 16384, with 1 unit storing 1 measured word)."), + .userData = context->errorHandler.userData }); + context->booleanWarnings.maxTextMeasureCacheExceeded = true; + } + return &Clay__MeasureTextCacheItem_DEFAULT; + } + char current = text->chars[end]; + if (current == ' ' || current == '\n') { + int32_t length = end - start; + Clay_Dimensions dimensions = CLAY__DEFAULT_STRUCT; + if (length > 0) { + dimensions = Clay__MeasureText(CLAY__INIT(Clay_StringSlice) {.length = length, .chars = &text->chars[start], .baseChars = text->chars}, config, context->measureTextUserData); + } + measured->minWidth = CLAY__MAX(dimensions.width, measured->minWidth); + measuredHeight = CLAY__MAX(measuredHeight, dimensions.height); + if (current == ' ') { + dimensions.width += spaceWidth; + previousWord = Clay__AddMeasuredWord(CLAY__INIT(Clay__MeasuredWord) { .startOffset = start, .length = length + 1, .width = dimensions.width, .next = -1 }, previousWord); + lineWidth += dimensions.width; + } + if (current == '\n') { + if (length > 0) { + previousWord = Clay__AddMeasuredWord(CLAY__INIT(Clay__MeasuredWord) { .startOffset = start, .length = length, .width = dimensions.width, .next = -1 }, previousWord); + } + previousWord = Clay__AddMeasuredWord(CLAY__INIT(Clay__MeasuredWord) { .startOffset = end + 1, .length = 0, .width = 0, .next = -1 }, previousWord); + lineWidth += dimensions.width; + measuredWidth = CLAY__MAX(lineWidth, measuredWidth); + measured->containsNewlines = true; + lineWidth = 0; + } + start = end + 1; + } + end++; + } + if (end - start > 0) { + Clay_Dimensions dimensions = Clay__MeasureText(CLAY__INIT(Clay_StringSlice) { .length = end - start, .chars = &text->chars[start], .baseChars = text->chars }, config, context->measureTextUserData); + Clay__AddMeasuredWord(CLAY__INIT(Clay__MeasuredWord) { .startOffset = start, .length = end - start, .width = dimensions.width, .next = -1 }, previousWord); + lineWidth += dimensions.width; + measuredHeight = CLAY__MAX(measuredHeight, dimensions.height); + measured->minWidth = CLAY__MAX(dimensions.width, measured->minWidth); + } + measuredWidth = CLAY__MAX(lineWidth, measuredWidth) - config->letterSpacing; + + measured->measuredWordsStartIndex = tempWord.next; + measured->unwrappedDimensions.width = measuredWidth; + measured->unwrappedDimensions.height = measuredHeight; + + if (elementIndexPrevious != 0) { + Clay__MeasureTextCacheItemArray_Get(&context->measureTextHashMapInternal, elementIndexPrevious)->nextIndex = newItemIndex; + } else { + context->measureTextHashMap.internalArray[hashBucket] = newItemIndex; + } + return measured; +} + +bool Clay__PointIsInsideRect(Clay_Vector2 point, Clay_BoundingBox rect) { + return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height; +} + +Clay_LayoutElementHashMapItem* Clay__AddHashMapItem(Clay_ElementId elementId, Clay_LayoutElement* layoutElement) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->layoutElementsHashMapInternal.length == context->layoutElementsHashMapInternal.capacity - 1) { + if (!context->booleanWarnings.hashMapCapacityExceeded) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_HASH_MAP_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay has run out of space in it's internal element ID hashmap. Try using Clay_SetMaxElementCount() with a higher value."), + .userData = context->errorHandler.userData }); + context->booleanWarnings.hashMapCapacityExceeded = true; + } + return NULL; + } + Clay_LayoutElementHashMapItem item = { .elementId = elementId, .layoutElement = layoutElement, .nextIndex = -1, .generation = context->generation + 1, .appearedThisFrame = true }; + uint32_t hashBucket = elementId.id % context->layoutElementsHashMap.capacity; + int32_t hashItemPrevious = -1; + int32_t hashItemIndex = context->layoutElementsHashMap.internalArray[hashBucket]; + while (hashItemIndex != -1) { // Just replace collision, not a big deal - leave it up to the end user + Clay_LayoutElementHashMapItem *hashItem = Clay__LayoutElementHashMapItemArray_Get(&context->layoutElementsHashMapInternal, hashItemIndex); + if (hashItem->elementId.id == elementId.id) { // Collision - resolve based on generation + item.nextIndex = hashItem->nextIndex; + if (hashItem->generation <= context->generation) { // First collision - assume this is the "same" element + hashItem->appearedThisFrame = hashItem->generation < context->generation; + hashItem->elementId = elementId; // Make sure to copy this across. If the stringId reference has changed, we should update the hash item to use the new one. + hashItem->generation = context->generation + 1; + hashItem->layoutElement = layoutElement; + hashItem->debugData.collision = false; + hashItem->onHoverFunction = NULL; + hashItem->hoverFunctionUserData = 0; + } else { // Multiple collisions this frame - two elements have the same ID + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_DUPLICATE_ID, + .errorText = CLAY_STRING("An element with this ID was already previously declared during this layout."), + .userData = context->errorHandler.userData }); + if (context->debugModeEnabled) { + hashItem->debugData.collision = true; + } + } + return hashItem; + } + hashItemPrevious = hashItemIndex; + hashItemIndex = hashItem->nextIndex; + } + + int32_t indexToUse = 0; + if (context->layoutElementsHashMapFreeList.length > 0) { + indexToUse = Clay__int32_tArray_GetValue(&context->layoutElementsHashMapFreeList, context->layoutElementsHashMapFreeList.length - 1); + context->layoutElementsHashMapFreeList.length--; + } else { + indexToUse = context->layoutElementsHashMapInternal.length; + } + Clay_LayoutElementHashMapItem *hashItem = Clay__LayoutElementHashMapItemArray_Set(&context->layoutElementsHashMapInternal, indexToUse, item); + if (hashItemPrevious != -1) { + Clay__LayoutElementHashMapItemArray_Get(&context->layoutElementsHashMapInternal, hashItemPrevious)->nextIndex = (int32_t)indexToUse; + } else { + context->layoutElementsHashMap.internalArray[hashBucket] = (int32_t)indexToUse; + } + return hashItem; +} + +Clay_LayoutElementHashMapItem *Clay__GetHashMapItem(uint32_t id) { + Clay_Context* context = Clay_GetCurrentContext(); + uint32_t hashBucket = id % context->layoutElementsHashMap.capacity; + int32_t elementIndex = context->layoutElementsHashMap.internalArray[hashBucket]; + while (elementIndex != -1) { + Clay_LayoutElementHashMapItem *hashEntry = Clay__LayoutElementHashMapItemArray_Get(&context->layoutElementsHashMapInternal, elementIndex); + if (hashEntry->elementId.id == id) { + return hashEntry; + } + elementIndex = hashEntry->nextIndex; + } + return &Clay_LayoutElementHashMapItem_DEFAULT; +} + +void Clay__UpdateAspectRatioBox(Clay_LayoutElement *layoutElement) { + if (layoutElement->config.aspectRatio.aspectRatio != 0) { + if (layoutElement->dimensions.width == 0 && layoutElement->dimensions.height != 0) { + layoutElement->dimensions.width = layoutElement->dimensions.height * layoutElement->config.aspectRatio.aspectRatio; + } else if (layoutElement->dimensions.width != 0 && layoutElement->dimensions.height == 0) { + layoutElement->dimensions.height = layoutElement->dimensions.width * (1 / layoutElement->config.aspectRatio.aspectRatio); + } + } +} + +void Clay__CloseElement(void) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->booleanWarnings.maxElementsExceeded) { + return; + } + Clay_LayoutElement *openLayoutElement = Clay__GetOpenLayoutElement(); + Clay_LayoutConfig *layoutConfig = &openLayoutElement->config.layout; + bool elementHasClipHorizontal = openLayoutElement->config.clip.horizontal; + bool elementHasClipVertical = openLayoutElement->config.clip.vertical; + if (elementHasClipHorizontal || elementHasClipVertical || openLayoutElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE) { + context->openClipElementStack.length--; + } + + float leftRightPadding = (float)(layoutConfig->padding.left + layoutConfig->padding.right); + float topBottomPadding = (float)(layoutConfig->padding.top + layoutConfig->padding.bottom); + + // Attach children to the current open element + openLayoutElement->children.elements = &context->layoutElementChildren.internalArray[context->layoutElementChildren.length]; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + openLayoutElement->dimensions.width = leftRightPadding; + openLayoutElement->minDimensions.width = leftRightPadding; + for (int32_t i = 0; i < openLayoutElement->children.length; i++) { + int32_t childIndex = Clay__int32_tArray_GetValue(&context->layoutElementChildrenBuffer, (int)context->layoutElementChildrenBuffer.length - openLayoutElement->children.length + i); + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, childIndex); + openLayoutElement->dimensions.width += child->dimensions.width; + openLayoutElement->dimensions.height = CLAY__MAX(openLayoutElement->dimensions.height, child->dimensions.height + topBottomPadding); + // Minimum size of child elements doesn't matter to clip containers as they can shrink and hide their contents + if (!elementHasClipHorizontal) { + openLayoutElement->minDimensions.width += child->minDimensions.width; + } + if (!elementHasClipVertical) { + openLayoutElement->minDimensions.height = CLAY__MAX(openLayoutElement->minDimensions.height, child->minDimensions.height + topBottomPadding); + } + Clay__int32_tArray_Add(&context->layoutElementChildren, childIndex); + } + float childGap = (float)(CLAY__MAX(openLayoutElement->children.length - 1, 0) * layoutConfig->childGap); + openLayoutElement->dimensions.width += childGap; + if (!elementHasClipHorizontal) { + openLayoutElement->minDimensions.width += childGap; + } + } + else if (layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM) { + openLayoutElement->dimensions.height = topBottomPadding; + openLayoutElement->minDimensions.height = topBottomPadding; + for (int32_t i = 0; i < openLayoutElement->children.length; i++) { + int32_t childIndex = Clay__int32_tArray_GetValue(&context->layoutElementChildrenBuffer, (int)context->layoutElementChildrenBuffer.length - openLayoutElement->children.length + i); + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, childIndex); + openLayoutElement->dimensions.height += child->dimensions.height; + openLayoutElement->dimensions.width = CLAY__MAX(openLayoutElement->dimensions.width, child->dimensions.width + leftRightPadding); + // Minimum size of child elements doesn't matter to clip containers as they can shrink and hide their contents + if (!elementHasClipVertical) { + openLayoutElement->minDimensions.height += child->minDimensions.height; + } + if (!elementHasClipHorizontal) { + openLayoutElement->minDimensions.width = CLAY__MAX(openLayoutElement->minDimensions.width, child->minDimensions.width + leftRightPadding); + } + Clay__int32_tArray_Add(&context->layoutElementChildren, childIndex); + } + float childGap = (float)(CLAY__MAX(openLayoutElement->children.length - 1, 0) * layoutConfig->childGap); + openLayoutElement->dimensions.height += childGap; + if (!elementHasClipVertical) { + openLayoutElement->minDimensions.height += childGap; + } + } + + context->layoutElementChildrenBuffer.length -= openLayoutElement->children.length; + + // Clamp element min and max width to the values configured in the layout + if (layoutConfig->sizing.width.type != CLAY__SIZING_TYPE_PERCENT) { + if (layoutConfig->sizing.width.size.minMax.max <= 0) { // Set the max size if the user didn't specify, makes calculations easier + layoutConfig->sizing.width.size.minMax.max = CLAY__MAXFLOAT; + } + openLayoutElement->dimensions.width = CLAY__MIN(CLAY__MAX(openLayoutElement->dimensions.width, layoutConfig->sizing.width.size.minMax.min), layoutConfig->sizing.width.size.minMax.max); + openLayoutElement->minDimensions.width = CLAY__MIN(CLAY__MAX(openLayoutElement->minDimensions.width, layoutConfig->sizing.width.size.minMax.min), layoutConfig->sizing.width.size.minMax.max); + } else { + openLayoutElement->dimensions.width = 0; + } + + // Clamp element min and max height to the values configured in the layout + if (layoutConfig->sizing.height.type != CLAY__SIZING_TYPE_PERCENT) { + if (layoutConfig->sizing.height.size.minMax.max <= 0) { // Set the max size if the user didn't specify, makes calculations easier + layoutConfig->sizing.height.size.minMax.max = CLAY__MAXFLOAT; + } + openLayoutElement->dimensions.height = CLAY__MIN(CLAY__MAX(openLayoutElement->dimensions.height, layoutConfig->sizing.height.size.minMax.min), layoutConfig->sizing.height.size.minMax.max); + openLayoutElement->minDimensions.height = CLAY__MIN(CLAY__MAX(openLayoutElement->minDimensions.height, layoutConfig->sizing.height.size.minMax.min), layoutConfig->sizing.height.size.minMax.max); + } else { + openLayoutElement->dimensions.height = 0; + } + + Clay__UpdateAspectRatioBox(openLayoutElement); + + bool elementIsFloating = openLayoutElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE; + + // Close the currently open element + int32_t closingElementIndex = Clay__int32_tArray_RemoveSwapback(&context->openLayoutElementStack, (int)context->openLayoutElementStack.length - 1); + + // Get the currently open parent + openLayoutElement = Clay__GetOpenLayoutElement(); + + if (context->openLayoutElementStack.length > 1) { + if(elementIsFloating) { + openLayoutElement->floatingChildrenCount++; + return; + } + openLayoutElement->children.length++; + Clay__int32_tArray_Add(&context->layoutElementChildrenBuffer, closingElementIndex); + } +} + +bool Clay__MemCmp(const char *s1, const char *s2, int32_t length); +#if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)) + bool Clay__MemCmp(const char *s1, const char *s2, int32_t length) { + while (length >= 16) { + __m128i v1 = _mm_loadu_si128((const __m128i *)s1); + __m128i v2 = _mm_loadu_si128((const __m128i *)s2); + + if (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) != 0xFFFF) { // If any byte differs + return false; + } + + s1 += 16; + s2 += 16; + length -= 16; + } + + // Handle remaining bytes + while (length--) { + if (*s1 != *s2) { + return false; + } + s1++; + s2++; + } + + return true; + } +#elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__) + bool Clay__MemCmp(const char *s1, const char *s2, int32_t length) { + while (length >= 16) { + uint8x16_t v1 = vld1q_u8((const uint8_t *)s1); + uint8x16_t v2 = vld1q_u8((const uint8_t *)s2); + + // Compare vectors + if (vminvq_u32(vreinterpretq_u32_u8(vceqq_u8(v1, v2))) != 0xFFFFFFFF) { // If there's a difference + return false; + } + + s1 += 16; + s2 += 16; + length -= 16; + } + + // Handle remaining bytes + while (length--) { + if (*s1 != *s2) { + return false; + } + s1++; + s2++; + } + + return true; + } +#else + bool Clay__MemCmp(const char *s1, const char *s2, int32_t length) { + for (int32_t i = 0; i < length; i++) { + if (s1[i] != s2[i]) { + return false; + } + } + return true; + } +#endif + +void Clay__OpenElement(void) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->layoutElements.length == context->layoutElements.capacity - 1 || context->booleanWarnings.maxElementsExceeded) { + context->booleanWarnings.maxElementsExceeded = true; + return; + } + Clay_LayoutElement layoutElement = CLAY__DEFAULT_STRUCT; + Clay_LayoutElement* openLayoutElement = Clay_LayoutElementArray_Add(&context->layoutElements, layoutElement); + Clay__int32_tArray_Add(&context->openLayoutElementStack, context->layoutElements.length - 1); + // Generate an ID + Clay_LayoutElement *parentElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 2)); + uint32_t offset = parentElement->children.length + parentElement->floatingChildrenCount; + Clay_ElementId elementId = Clay__HashNumber(offset, parentElement->id); + openLayoutElement->id = elementId.id; + Clay__AddHashMapItem(elementId, openLayoutElement); + Clay__StringArray_Add(&context->layoutElementIdStrings, elementId.stringId); + if (context->openClipElementStack.length > 0) { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, Clay__int32_tArray_GetValue(&context->openClipElementStack, (int)context->openClipElementStack.length - 1)); + } else { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, 0); + } +} + +void Clay__OpenElementWithId(Clay_ElementId elementId) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->layoutElements.length == context->layoutElements.capacity - 1 || context->booleanWarnings.maxElementsExceeded) { + context->booleanWarnings.maxElementsExceeded = true; + return; + } + Clay_LayoutElement layoutElement = CLAY__DEFAULT_STRUCT; + layoutElement.id = elementId.id; + Clay_LayoutElement * openLayoutElement = Clay_LayoutElementArray_Add(&context->layoutElements, layoutElement); + Clay__int32_tArray_Add(&context->openLayoutElementStack, context->layoutElements.length - 1); + Clay__AddHashMapItem(elementId, openLayoutElement); + Clay__StringArray_Add(&context->layoutElementIdStrings, elementId.stringId); + if (context->openClipElementStack.length > 0) { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, Clay__int32_tArray_GetValue(&context->openClipElementStack, (int)context->openClipElementStack.length - 1)); + } else { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, 0); + } +} + +void Clay__OpenTextElement(Clay_String text, Clay_TextElementConfig textConfig) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->layoutElements.length == context->layoutElements.capacity - 1 || context->booleanWarnings.maxElementsExceeded) { + context->booleanWarnings.maxElementsExceeded = true; + return; + } + Clay_LayoutElement *parentElement = Clay__GetOpenLayoutElement(); + + Clay_LayoutElement layoutElement = { .textConfig = textConfig, .isTextElement = true }; + Clay_LayoutElement *textElement = Clay_LayoutElementArray_Add(&context->layoutElements, layoutElement); + if (context->openClipElementStack.length > 0) { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, Clay__int32_tArray_GetValue(&context->openClipElementStack, (int)context->openClipElementStack.length - 1)); + } else { + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, context->layoutElements.length - 1, 0); + } + + Clay__int32_tArray_Add(&context->layoutElementChildrenBuffer, context->layoutElements.length - 1); + Clay__MeasureTextCacheItem *textMeasured = Clay__MeasureTextCached(&text, &textConfig); + Clay_ElementId elementId = Clay__HashNumber(parentElement->children.length + parentElement->floatingChildrenCount, parentElement->id); + textElement->id = elementId.id; + Clay__AddHashMapItem(elementId, textElement); + Clay__StringArray_Add(&context->layoutElementIdStrings, elementId.stringId); + Clay_Dimensions textDimensions = { .width = textMeasured->unwrappedDimensions.width, .height = textConfig.lineHeight > 0 ? (float)textConfig.lineHeight : textMeasured->unwrappedDimensions.height }; + textElement->dimensions = textDimensions; + textElement->minDimensions = CLAY__INIT(Clay_Dimensions) { .width = textMeasured->minWidth, .height = textDimensions.height }; + textElement->textElementData = CLAY__INIT(Clay__TextElementData) { .text = text, .preferredDimensions = textMeasured->unwrappedDimensions }; + parentElement->children.length++; +} + +void Clay__ConfigureOpenElementPtr(const Clay_ElementDeclaration *declaration) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay_LayoutElement *openLayoutElement = Clay__GetOpenLayoutElement(); + openLayoutElement->config = *declaration; + if ((declaration->layout.sizing.width.type == CLAY__SIZING_TYPE_PERCENT && declaration->layout.sizing.width.size.percent > 1) || (declaration->layout.sizing.height.type == CLAY__SIZING_TYPE_PERCENT && declaration->layout.sizing.height.size.percent > 1)) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_PERCENTAGE_OVER_1, + .errorText = CLAY_STRING("An element was configured with CLAY_SIZING_PERCENT, but the provided percentage value was over 1.0. Clay expects a value between 0 and 1, i.e. 20% is 0.2."), + .userData = context->errorHandler.userData }); + } + + if (declaration->floating.attachTo != CLAY_ATTACH_TO_NONE) { + Clay_FloatingElementConfig* floatingConfig = &openLayoutElement->config.floating; + // This looks dodgy but because of the auto generated root element the depth of the tree will always be at least 2 here + Clay_LayoutElement *hierarchicalParent = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 2)); + if (hierarchicalParent) { + uint32_t clipElementId = 0; + if (declaration->floating.attachTo == CLAY_ATTACH_TO_PARENT) { + // Attach to the element's direct hierarchical parent + floatingConfig->parentId = hierarchicalParent->id; + if (context->openClipElementStack.length > 0) { + clipElementId = Clay__int32_tArray_GetValue(&context->openClipElementStack, (int)context->openClipElementStack.length - 1); + } + } else if (declaration->floating.attachTo == CLAY_ATTACH_TO_ELEMENT_WITH_ID) { + Clay_LayoutElementHashMapItem *parentItem = Clay__GetHashMapItem(floatingConfig->parentId); + if (parentItem == &Clay_LayoutElementHashMapItem_DEFAULT) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND, + .errorText = CLAY_STRING("A floating element was declared with a parentId, but no element with that ID was found."), + .userData = context->errorHandler.userData }); + } else { + clipElementId = Clay__int32_tArray_GetValue(&context->layoutElementClipElementIds, (int32_t)(parentItem->layoutElement - context->layoutElements.internalArray)); + } + } else if (declaration->floating.attachTo == CLAY_ATTACH_TO_ROOT) { + floatingConfig->parentId = Clay__HashString(CLAY_STRING("Clay__RootContainer"), 0).id; + } + if (declaration->floating.clipTo == CLAY_CLIP_TO_NONE) { + clipElementId = 0; + } + int32_t currentElementIndex = Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 1); + Clay__int32_tArray_Set(&context->layoutElementClipElementIds, currentElementIndex, clipElementId); + Clay__int32_tArray_Add(&context->openClipElementStack, clipElementId); + Clay__LayoutElementTreeRootArray_Add(&context->layoutElementTreeRoots, CLAY__INIT(Clay__LayoutElementTreeRoot) { + .layoutElementIndex = Clay__int32_tArray_GetValue(&context->openLayoutElementStack, context->openLayoutElementStack.length - 1), + .parentId = floatingConfig->parentId, + .clipElementId = clipElementId, + .zIndex = floatingConfig->zIndex, + }); + } + } + + if (declaration->clip.horizontal || declaration->clip.vertical) { + Clay__int32_tArray_Add(&context->openClipElementStack, (int)openLayoutElement->id); + // Retrieve or create cached data to track scroll position across frames + Clay__ScrollContainerDataInternal *scrollOffset = CLAY__NULL; + for (int32_t i = 0; i < context->scrollContainerDatas.length; i++) { + Clay__ScrollContainerDataInternal *mapping = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (openLayoutElement->id == mapping->elementId) { + scrollOffset = mapping; + scrollOffset->layoutElement = openLayoutElement; + scrollOffset->openThisFrame = true; + } + } + if (!scrollOffset) { + scrollOffset = Clay__ScrollContainerDataInternalArray_Add(&context->scrollContainerDatas, CLAY__INIT(Clay__ScrollContainerDataInternal){.layoutElement = openLayoutElement, .scrollOrigin = {-1,-1}, .elementId = openLayoutElement->id, .openThisFrame = true}); + } + if (context->externalScrollHandlingEnabled) { + scrollOffset->scrollPosition = Clay__QueryScrollOffset(scrollOffset->elementId, context->queryScrollOffsetUserData); + } + } + // Setup data to track transitions across frames + if (declaration->transition.handler) { + Clay__TransitionDataInternal *transitionData = CLAY__NULL; + Clay_LayoutElement* parentElement = Clay__GetParentElement(); + for (int32_t i = 0; i < context->transitionDatas.length; i++) { + Clay__TransitionDataInternal *existingData = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, i); + if (openLayoutElement->id == existingData->elementId) { + if (existingData->state == CLAY_TRANSITION_STATE_EXITING) { + existingData->state = CLAY_TRANSITION_STATE_IDLE; + Clay_LayoutElementHashMapItem* hashMapItem = Clay__GetHashMapItem(openLayoutElement->id); + hashMapItem->appearedThisFrame = false; + } + transitionData = existingData; + transitionData->elementThisFrame = openLayoutElement; + if (transitionData->parentId != parentElement->id) { + transitionData->reparented = true; + } + transitionData->parentId = parentElement->id; + transitionData->siblingIndex = parentElement->children.length; + transitionData->transitionOut = !!declaration->transition.exit.setFinalState; + } + } + if (!transitionData) { + transitionData = Clay__TransitionDataInternalArray_Add(&context->transitionDatas, CLAY__INIT(Clay__TransitionDataInternal){ + .elementThisFrame = openLayoutElement, + .elementId = openLayoutElement->id, + .parentId = parentElement->id, + .siblingIndex = parentElement->children.length, + .transitionOut = !!declaration->transition.exit.setFinalState + }); + } + } +} + +void Clay__ConfigureOpenElement(const Clay_ElementDeclaration declaration) { + Clay__ConfigureOpenElementPtr(&declaration); +} + +void Clay__InitializeEphemeralMemory(Clay_Context* context) { + int32_t maxElementCount = context->maxElementCount; + // Ephemeral Memory - reset every frame + Clay_Arena *arena = &context->internalArena; + arena->nextAllocation = context->arenaResetOffset; + + context->layoutElementChildrenBuffer = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->layoutElements = Clay_LayoutElementArray_Allocate_Arena(maxElementCount, arena); + context->warnings = Clay__WarningArray_Allocate_Arena(100, arena); + + context->layoutElementIdStrings = Clay__StringArray_Allocate_Arena(maxElementCount, arena); + context->wrappedTextLines = Clay__WrappedTextLineArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementTreeNodeArray1 = Clay__LayoutElementTreeNodeArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementTreeRoots = Clay__LayoutElementTreeRootArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementChildren = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->openLayoutElementStack = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->renderCommands = Clay_RenderCommandArray_Allocate_Arena(maxElementCount, arena); + context->treeNodeVisited = Clay__boolArray_Allocate_Arena(maxElementCount, arena); + context->treeNodeVisited.length = context->treeNodeVisited.capacity; // This array is accessed directly rather than behaving as a list + context->openClipElementStack = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->reusableElementIndexBuffer = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementClipElementIds = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->dynamicStringData = Clay__charArray_Allocate_Arena(maxElementCount, arena); +} + +void Clay__InitializePersistentMemory(Clay_Context* context) { + // Persistent memory - initialized once and not reset + int32_t maxElementCount = context->maxElementCount; + int32_t maxMeasureTextCacheWordCount = context->maxMeasureTextCacheWordCount; + Clay_Arena *arena = &context->internalArena; + + context->scrollContainerDatas = Clay__ScrollContainerDataInternalArray_Allocate_Arena(100, arena); + context->transitionDatas = Clay__TransitionDataInternalArray_Allocate_Arena(200, arena); + context->layoutElementsHashMapInternal = Clay__LayoutElementHashMapItemArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementsHashMap = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->layoutElementsHashMapFreeList = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->measureTextHashMapInternal = Clay__MeasureTextCacheItemArray_Allocate_Arena(maxElementCount, arena); + context->measureTextHashMapInternalFreeList = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->measuredWordsFreeList = Clay__int32_tArray_Allocate_Arena(maxMeasureTextCacheWordCount, arena); + context->measureTextHashMap = Clay__int32_tArray_Allocate_Arena(maxElementCount, arena); + context->measuredWords = Clay__MeasuredWordArray_Allocate_Arena(maxMeasureTextCacheWordCount, arena); + context->pointerOverIds = Clay_ElementIdArray_Allocate_Arena(maxElementCount, arena); + context->arenaResetOffset = arena->nextAllocation; +} + +const float CLAY__EPSILON = 0.01; + +bool Clay__FloatEqual(float left, float right) { + float subtracted = left - right; + return subtracted < CLAY__EPSILON && subtracted > -CLAY__EPSILON; +} + +Clay_SizingAxis Clay__GetElementSizing(Clay_LayoutElement* element, bool xAxis) { + if (element->isTextElement) { + return CLAY__INIT(Clay_SizingAxis) {}; + } else { + return xAxis ? element->config.layout.sizing.width : element->config.layout.sizing.height; + } +} + +// Writes out the location of text elements to layout elements buffer 1 +void Clay__SizeContainersAlongAxis(bool xAxis, float deltaTime, Clay__int32_tArray* textElementsOut, Clay__int32_tArray* aspectRatioElementsOut) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__int32_tArray bfsBuffer = context->layoutElementChildrenBuffer; + Clay__int32_tArray resizableContainerBuffer = context->openLayoutElementStack; + for (int32_t rootIndex = 0; rootIndex < context->layoutElementTreeRoots.length; ++rootIndex) { + bfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, rootIndex); + Clay_LayoutElement *rootElement = Clay_LayoutElementArray_Get(&context->layoutElements, (int)root->layoutElementIndex); + Clay__int32_tArray_Add(&bfsBuffer, (int32_t)root->layoutElementIndex); + + // Size floating containers to their parents + if (rootElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE) { + Clay_FloatingElementConfig *floatingElementConfig = &rootElement->config.floating; + Clay_LayoutElementHashMapItem *parentItem = Clay__GetHashMapItem(floatingElementConfig->parentId); + if (parentItem && parentItem != &Clay_LayoutElementHashMapItem_DEFAULT) { + Clay_LayoutElement *parentLayoutElement = parentItem->layoutElement; + switch (rootElement->config.layout.sizing.width.type) { + case CLAY__SIZING_TYPE_GROW: { + rootElement->dimensions.width = parentLayoutElement->dimensions.width; + break; + } + case CLAY__SIZING_TYPE_PERCENT: { + rootElement->dimensions.width = parentLayoutElement->dimensions.width * rootElement->config.layout.sizing.width.size.percent; + break; + } + default: break; + } + switch (rootElement->config.layout.sizing.height.type) { + case CLAY__SIZING_TYPE_GROW: { + rootElement->dimensions.height = parentLayoutElement->dimensions.height; + break; + } + case CLAY__SIZING_TYPE_PERCENT: { + rootElement->dimensions.height = parentLayoutElement->dimensions.height * rootElement->config.layout.sizing.height.size.percent; + break; + } + default: break; + } + } + } + + if (rootElement->config.layout.sizing.width.type != CLAY__SIZING_TYPE_PERCENT) { + rootElement->dimensions.width = CLAY__MIN(CLAY__MAX(rootElement->dimensions.width, rootElement->config.layout.sizing.width.size.minMax.min), rootElement->config.layout.sizing.width.size.minMax.max); + } + if (rootElement->config.layout.sizing.height.type != CLAY__SIZING_TYPE_PERCENT) { + rootElement->dimensions.height = CLAY__MIN(CLAY__MAX(rootElement->dimensions.height, rootElement->config.layout.sizing.height.size.minMax.min), rootElement->config.layout.sizing.height.size.minMax.max); + } + + + for (int32_t i = 0; i < bfsBuffer.length; ++i) { + int32_t parentIndex = Clay__int32_tArray_GetValue(&bfsBuffer, i); + Clay_LayoutElement *parent = Clay_LayoutElementArray_Get(&context->layoutElements, parentIndex); + Clay_LayoutConfig *parentLayoutConfig = &parent->config.layout; + int32_t growContainerCount = 0; + float parentSize = xAxis ? parent->dimensions.width : parent->dimensions.height; + float parentPadding = (float)(xAxis ? (parentLayoutConfig->padding.left + parentLayoutConfig->padding.right) : (parentLayoutConfig->padding.top + parentLayoutConfig->padding.bottom)); + float innerContentSize = 0, totalPaddingAndChildGaps = parentPadding; + bool sizingAlongAxis = (xAxis && parentLayoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) || (!xAxis && parentLayoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM); + resizableContainerBuffer.length = 0; + float parentChildGap = parentLayoutConfig->childGap; + bool isFirstChild = true; + + for (int32_t childOffset = 0; childOffset < parent->children.length; childOffset++) { + int32_t childElementIndex = parent->children.elements[childOffset]; + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, childElementIndex); + Clay_SizingAxis childSizing = Clay__GetElementSizing(childElement, xAxis); + float childSize = xAxis ? childElement->dimensions.width : childElement->dimensions.height; + + if (textElementsOut && childElement->isTextElement) { + Clay__int32_tArray_Add(textElementsOut, childElementIndex); + } else if (childElement->children.length > 0) { + Clay__int32_tArray_Add(&bfsBuffer, childElementIndex); + } + + if (!childElement->isTextElement && aspectRatioElementsOut && childElement->config.aspectRatio.aspectRatio != 0) { + Clay__int32_tArray_Add(aspectRatioElementsOut, childElementIndex); + } + + // Note: setting isFirstChild = false is skipped here + if (childElement->exiting) { + continue; + } + + if (childSizing.type != CLAY__SIZING_TYPE_PERCENT + && childSizing.type != CLAY__SIZING_TYPE_FIXED + && (!childElement->isTextElement || childElement->textConfig.wrapMode == CLAY_TEXT_WRAP_WORDS) +// && (xAxis || !Clay__ElementHasConfig(childElement, CLAY__ELEMENT_CONFIG_TYPE_ASPECT)) + ) { + Clay__int32_tArray_Add(&resizableContainerBuffer, childElementIndex); + } + + if (sizingAlongAxis) { + innerContentSize += (childSizing.type == CLAY__SIZING_TYPE_PERCENT ? 0 : childSize); + if (childSizing.type == CLAY__SIZING_TYPE_GROW) { + growContainerCount++; + } + if (!isFirstChild) { + innerContentSize += parentChildGap; // For children after index 0, the childAxisOffset is the gap from the previous child + totalPaddingAndChildGaps += parentChildGap; + } + } else { + innerContentSize = CLAY__MAX(childSize, innerContentSize); + } + isFirstChild = false; + } + + // Expand percentage containers to size + for (int32_t childOffset = 0; childOffset < parent->children.length; childOffset++) { + int32_t childElementIndex = parent->children.elements[childOffset]; + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, childElementIndex); + Clay_SizingAxis childSizing = Clay__GetElementSizing(childElement, xAxis); + float *childSize = xAxis ? &childElement->dimensions.width : &childElement->dimensions.height; + if (childSizing.type == CLAY__SIZING_TYPE_PERCENT) { + *childSize = (parentSize - totalPaddingAndChildGaps) * childSizing.size.percent; + if (sizingAlongAxis) { + innerContentSize += *childSize; + } + Clay__UpdateAspectRatioBox(childElement); + } + } + + if (sizingAlongAxis) { + float sizeToDistribute = parentSize - parentPadding - innerContentSize; + // The content is too large, compress the children as much as possible + if (sizeToDistribute < 0) { + // If the parent clips content in this axis direction, don't compress children, just leave them alone + if (((xAxis && parent->config.clip.horizontal) || (!xAxis && parent->config.clip.vertical))) { + continue; + } + // Scrolling containers preferentially compress before others + while (sizeToDistribute < -CLAY__EPSILON && resizableContainerBuffer.length > 0) { + float largest = 0; + float secondLargest = 0; + float widthToAdd = sizeToDistribute; + for (int childIndex = 0; childIndex < resizableContainerBuffer.length; childIndex++) { + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childIndex)); + float childSize = xAxis ? child->dimensions.width : child->dimensions.height; + if (Clay__FloatEqual(childSize, largest)) { continue; } + if (childSize > largest) { + secondLargest = largest; + largest = childSize; + } + if (childSize < largest) { + secondLargest = CLAY__MAX(secondLargest, childSize); + widthToAdd = secondLargest - largest; + } + } + + widthToAdd = CLAY__MAX(widthToAdd, sizeToDistribute / resizableContainerBuffer.length); + + for (int childIndex = 0; childIndex < resizableContainerBuffer.length; childIndex++) { + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childIndex)); + float *childSize = xAxis ? &child->dimensions.width : &child->dimensions.height; + float minSize = xAxis ? child->minDimensions.width : child->minDimensions.height; + float previousWidth = *childSize; + if (Clay__FloatEqual(*childSize, largest)) { + *childSize += widthToAdd; + if (*childSize <= minSize) { + *childSize = minSize; + Clay__int32_tArray_RemoveSwapback(&resizableContainerBuffer, childIndex--); + } + sizeToDistribute -= (*childSize - previousWidth); + } + } + } + // The content is too small, allow SIZING_GROW containers to expand + } else if (sizeToDistribute > 0 && growContainerCount > 0) { + for (int childIndex = 0; childIndex < resizableContainerBuffer.length; childIndex++) { + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childIndex)); + Clay__SizingType childSizing = Clay__GetElementSizing(child, xAxis).type; + if (childSizing != CLAY__SIZING_TYPE_GROW) { + Clay__int32_tArray_RemoveSwapback(&resizableContainerBuffer, childIndex--); + } + } + while (sizeToDistribute > CLAY__EPSILON && resizableContainerBuffer.length > 0) { + float smallest = CLAY__MAXFLOAT; + float secondSmallest = CLAY__MAXFLOAT; + float widthToAdd = sizeToDistribute; + for (int childIndex = 0; childIndex < resizableContainerBuffer.length; childIndex++) { + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childIndex)); + float childSize = xAxis ? child->dimensions.width : child->dimensions.height; + if (Clay__FloatEqual(childSize, smallest)) { continue; } + if (childSize < smallest) { + secondSmallest = smallest; + smallest = childSize; + } + if (childSize > smallest) { + secondSmallest = CLAY__MIN(secondSmallest, childSize); + widthToAdd = secondSmallest - smallest; + } + } + + widthToAdd = CLAY__MIN(widthToAdd, sizeToDistribute / resizableContainerBuffer.length); + + for (int childIndex = 0; childIndex < resizableContainerBuffer.length; childIndex++) { + Clay_LayoutElement *child = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childIndex)); + float *childSize = xAxis ? &child->dimensions.width : &child->dimensions.height; + Clay_SizingAxis childSizing = Clay__GetElementSizing(child, xAxis); + float maxSize = childSizing.size.minMax.max; + float previousWidth = *childSize; + if (Clay__FloatEqual(*childSize, smallest)) { + *childSize += widthToAdd; + if (*childSize >= maxSize) { + *childSize = maxSize; + Clay__int32_tArray_RemoveSwapback(&resizableContainerBuffer, childIndex--); + } + sizeToDistribute -= (*childSize - previousWidth); + } + } + } + } + // Sizing along the non layout axis ("off axis") + } else { + for (int32_t childOffset = 0; childOffset < resizableContainerBuffer.length; childOffset++) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&resizableContainerBuffer, childOffset)); + Clay_SizingAxis childSizing = Clay__GetElementSizing(childElement, xAxis); + float minSize = xAxis ? childElement->minDimensions.width : childElement->minDimensions.height; + float *childSize = xAxis ? &childElement->dimensions.width : &childElement->dimensions.height; + + float maxSize = parentSize - parentPadding; + // If we're laying out the children of a scroll panel, grow containers expand to the size of the inner content, not the outer container + if (((xAxis && parent->config.clip.horizontal) || (!xAxis && parent->config.clip.vertical))) { + maxSize = CLAY__MAX(maxSize, innerContentSize); + } + if (childSizing.type == CLAY__SIZING_TYPE_GROW) { + *childSize = CLAY__MIN(maxSize, childSizing.size.minMax.max); + } + *childSize = CLAY__MAX(minSize, CLAY__MIN(*childSize, maxSize)); + } + } + } + } +} + +Clay_String Clay__IntToString(int32_t integer) { + if (integer == 0) { + return CLAY__INIT(Clay_String) { .length = 1, .chars = "0" }; + } + Clay_Context* context = Clay_GetCurrentContext(); + char *chars = (char *)(context->dynamicStringData.internalArray + context->dynamicStringData.length); + int32_t length = 0; + int32_t sign = integer; + + if (integer < 0) { + integer = -integer; + } + while (integer > 0) { + chars[length++] = (char)(integer % 10 + '0'); + integer /= 10; + } + + if (sign < 0) { + chars[length++] = '-'; + } + + // Reverse the string to get the correct order + for (int32_t j = 0, k = length - 1; j < k; j++, k--) { + char temp = chars[j]; + chars[j] = chars[k]; + chars[k] = temp; + } + context->dynamicStringData.length += length; + return CLAY__INIT(Clay_String) { .length = length, .chars = chars }; +} + +void Clay__AddRenderCommand(Clay_RenderCommand renderCommand) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->renderCommands.length < context->renderCommands.capacity - 1) { + Clay_RenderCommandArray_Add(&context->renderCommands, renderCommand); + } else { + if (!context->booleanWarnings.maxRenderCommandsExceeded) { + context->booleanWarnings.maxRenderCommandsExceeded = true; + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay ran out of capacity while attempting to create render commands. This is usually caused by a large amount of wrapping text elements while close to the max element capacity. Try using Clay_SetMaxElementCount() with a higher value."), + .userData = context->errorHandler.userData }); + } + } +} + +bool Clay__ElementIsOffscreen(Clay_BoundingBox *boundingBox) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->disableCulling) { + return false; + } + + return (boundingBox->x > (float)context->layoutDimensions.width) || + (boundingBox->y > (float)context->layoutDimensions.height) || + (boundingBox->x + boundingBox->width < 0) || + (boundingBox->y + boundingBox->height < 0); +} + +void Clay__CalculateFinalLayout(float deltaTime, bool useStoredBoundingBoxes, bool generateRenderCommands) { + Clay_Context* context = Clay_GetCurrentContext(); + + // Calculate sizing along the X axis + Clay__int32_tArray textElements = context->openClipElementStack; + textElements.length = 0; + Clay__int32_tArray aspectRatioElements = context->reusableElementIndexBuffer; + aspectRatioElements.length = 0; + Clay__SizeContainersAlongAxis(true, deltaTime, &textElements, &aspectRatioElements); + + // Wrap text + for (int32_t textElementIndex = 0; textElementIndex < textElements.length; ++textElementIndex) { + Clay_LayoutElement *element = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&textElements, textElementIndex)); + Clay__TextElementData *textElementData = &element->textElementData; + textElementData->wrappedLines = CLAY__INIT(Clay__WrappedTextLineArraySlice) { .length = 0, .internalArray = &context->wrappedTextLines.internalArray[context->wrappedTextLines.length] }; + Clay_LayoutElement *containerElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&textElements, textElementIndex)); + Clay__MeasureTextCacheItem *measureTextCacheItem = Clay__MeasureTextCached(&textElementData->text, &containerElement->textConfig); + float lineWidth = 0; + float lineHeight = containerElement->textConfig.lineHeight > 0 ? (float)containerElement->textConfig.lineHeight : textElementData->preferredDimensions.height; + int32_t lineLengthChars = 0; + int32_t lineStartOffset = 0; + if (!measureTextCacheItem->containsNewlines && textElementData->preferredDimensions.width <= containerElement->dimensions.width) { + Clay__WrappedTextLineArray_Add(&context->wrappedTextLines, CLAY__INIT(Clay__WrappedTextLine) { containerElement->dimensions, textElementData->text }); + textElementData->wrappedLines.length++; + continue; + } + float spaceWidth = Clay__MeasureText(CLAY__INIT(Clay_StringSlice) { .length = 1, .chars = CLAY__SPACECHAR.chars, .baseChars = CLAY__SPACECHAR.chars }, &containerElement->textConfig, context->measureTextUserData).width; + int32_t wordIndex = measureTextCacheItem->measuredWordsStartIndex; + while (wordIndex != -1) { + if (context->wrappedTextLines.length > context->wrappedTextLines.capacity - 1) { + break; + } + Clay__MeasuredWord *measuredWord = Clay__MeasuredWordArray_Get(&context->measuredWords, wordIndex); + // Only word on the line is too large, just render it anyway + if (lineLengthChars == 0 && lineWidth + measuredWord->width > containerElement->dimensions.width) { + Clay__WrappedTextLineArray_Add(&context->wrappedTextLines, CLAY__INIT(Clay__WrappedTextLine) { { measuredWord->width, lineHeight }, { .length = measuredWord->length, .chars = &textElementData->text.chars[measuredWord->startOffset] } }); + textElementData->wrappedLines.length++; + wordIndex = measuredWord->next; + lineStartOffset = measuredWord->startOffset + measuredWord->length; + } + // measuredWord->length == 0 means a newline character + else if (measuredWord->length == 0 || lineWidth + measuredWord->width > containerElement->dimensions.width) { + // Wrapped text lines list has overflowed, just render out the line + bool finalCharIsSpace = textElementData->text.chars[CLAY__MAX(lineStartOffset + lineLengthChars - 1, 0)] == ' '; + Clay__WrappedTextLineArray_Add(&context->wrappedTextLines, CLAY__INIT(Clay__WrappedTextLine) { { lineWidth + (finalCharIsSpace ? -spaceWidth : 0), lineHeight }, { .length = lineLengthChars + (finalCharIsSpace ? -1 : 0), .chars = &textElementData->text.chars[lineStartOffset] } }); + textElementData->wrappedLines.length++; + if (lineLengthChars == 0 || measuredWord->length == 0) { + wordIndex = measuredWord->next; + } + lineWidth = 0; + lineLengthChars = 0; + lineStartOffset = measuredWord->startOffset; + } else { + lineWidth += measuredWord->width + containerElement->textConfig.letterSpacing; + lineLengthChars += measuredWord->length; + wordIndex = measuredWord->next; + } + } + if (lineLengthChars > 0) { + Clay__WrappedTextLineArray_Add(&context->wrappedTextLines, CLAY__INIT(Clay__WrappedTextLine) { { lineWidth - containerElement->textConfig.letterSpacing, lineHeight }, {.length = lineLengthChars, .chars = &textElementData->text.chars[lineStartOffset] } }); + textElementData->wrappedLines.length++; + } + containerElement->dimensions.height = lineHeight * (float)textElementData->wrappedLines.length; + } + + // Scale vertical heights according to aspect ratio + for (int32_t i = 0; i < aspectRatioElements.length; ++i) { + Clay_LayoutElement* aspectElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&aspectRatioElements, i)); + aspectElement->dimensions.height = (1 / aspectElement->config.aspectRatio.aspectRatio) * aspectElement->dimensions.width; + aspectElement->config.layout.sizing.height.size.minMax.max = aspectElement->dimensions.height; + } + + // Propagate effect of text wrapping, aspect scaling etc. on height of parents + Clay__LayoutElementTreeNodeArray dfsBuffer = context->layoutElementTreeNodeArray1; + dfsBuffer.length = 0; + for (int32_t i = 0; i < context->layoutElementTreeRoots.length; ++i) { + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, i); + context->treeNodeVisited.internalArray[dfsBuffer.length] = false; + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, CLAY__INIT(Clay__LayoutElementTreeNode) { .layoutElement = Clay_LayoutElementArray_Get(&context->layoutElements, (int)root->layoutElementIndex) }); + } + while (dfsBuffer.length > 0) { + Clay__LayoutElementTreeNode *currentElementTreeNode = Clay__LayoutElementTreeNodeArray_Get(&dfsBuffer, (int)dfsBuffer.length - 1); + Clay_LayoutElement *currentElement = currentElementTreeNode->layoutElement; + if (!context->treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + // If the element has no children or is the container for a text element, don't bother inspecting it + if (currentElement->isTextElement || currentElement->children.length == 0) { + dfsBuffer.length--; + continue; + } + // Add the children to the DFS buffer (needs to be pushed in reverse so that stack traversal is in correct layout order) + for (int32_t i = 0; i < currentElement->children.length; i++) { + context->treeNodeVisited.internalArray[dfsBuffer.length] = false; + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, CLAY__INIT(Clay__LayoutElementTreeNode) { .layoutElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]) }); + } + continue; + } + dfsBuffer.length--; + + // DFS node has been visited, this is on the way back up to the root + Clay_LayoutConfig *layoutConfig = ¤tElement->config.layout; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + // Resize any parent containers that have grown in height along their non layout axis + for (int32_t j = 0; j < currentElement->children.length; ++j) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[j]); + float childHeightWithPadding = CLAY__MAX(childElement->dimensions.height + layoutConfig->padding.top + layoutConfig->padding.bottom, currentElement->dimensions.height); + currentElement->dimensions.height = CLAY__MIN(CLAY__MAX(childHeightWithPadding, layoutConfig->sizing.height.size.minMax.min), layoutConfig->sizing.height.size.minMax.max); + } + } else if (layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM) { + // Resizing along the layout axis + float contentHeight = (float)(layoutConfig->padding.top + layoutConfig->padding.bottom); + for (int32_t j = 0; j < currentElement->children.length; ++j) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[j]); + contentHeight += childElement->dimensions.height; + } + contentHeight += (float)(CLAY__MAX(currentElement->children.length - 1, 0) * layoutConfig->childGap); + currentElement->dimensions.height = CLAY__MIN(CLAY__MAX(contentHeight, layoutConfig->sizing.height.size.minMax.min), layoutConfig->sizing.height.size.minMax.max); + } + } + + // Calculate sizing along the Y axis + Clay__SizeContainersAlongAxis(false, deltaTime, NULL, NULL); + + // Scale horizontal widths according to aspect ratio + for (int32_t i = 0; i < aspectRatioElements.length; ++i) { + Clay_LayoutElement* aspectElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&aspectRatioElements, i)); + aspectElement->dimensions.width = aspectElement->config.aspectRatio.aspectRatio * aspectElement->dimensions.height; + } + + // Sort tree roots by z-index + int32_t sortMax = context->layoutElementTreeRoots.length - 1; + while (sortMax > 0) { // todo dumb bubble sort + for (int32_t i = 0; i < sortMax; ++i) { + Clay__LayoutElementTreeRoot current = *Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, i); + Clay__LayoutElementTreeRoot next = *Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, i + 1); + if (next.zIndex < current.zIndex) { + Clay__LayoutElementTreeRootArray_Set(&context->layoutElementTreeRoots, i, next); + Clay__LayoutElementTreeRootArray_Set(&context->layoutElementTreeRoots, i + 1, current); + } + } + sortMax--; + } + + // Calculate final positions and generate render commands + context->renderCommands.length = 0; + dfsBuffer.length = 0; + + for (int32_t rootIndex = 0; rootIndex < context->layoutElementTreeRoots.length; ++rootIndex) { + dfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, rootIndex); + Clay_LayoutElement *rootElement = Clay_LayoutElementArray_Get(&context->layoutElements, (int)root->layoutElementIndex); + Clay_Vector2 rootPosition = CLAY__DEFAULT_STRUCT; + Clay_LayoutElementHashMapItem *parentHashMapItem = Clay__GetHashMapItem(root->parentId); + // Position root floating containers + if (rootElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE && parentHashMapItem) { + Clay_FloatingElementConfig *config = &rootElement->config.floating; + Clay_Dimensions rootDimensions = rootElement->dimensions; + Clay_BoundingBox parentBoundingBox = parentHashMapItem->boundingBox; + // Set X position + Clay_Vector2 targetAttachPosition = CLAY__DEFAULT_STRUCT; + switch (config->attachPoints.parent) { + case CLAY_ATTACH_POINT_LEFT_TOP: + case CLAY_ATTACH_POINT_LEFT_CENTER: + case CLAY_ATTACH_POINT_LEFT_BOTTOM: targetAttachPosition.x = parentBoundingBox.x; break; + case CLAY_ATTACH_POINT_CENTER_TOP: + case CLAY_ATTACH_POINT_CENTER_CENTER: + case CLAY_ATTACH_POINT_CENTER_BOTTOM: targetAttachPosition.x = parentBoundingBox.x + (parentBoundingBox.width / 2); break; + case CLAY_ATTACH_POINT_RIGHT_TOP: + case CLAY_ATTACH_POINT_RIGHT_CENTER: + case CLAY_ATTACH_POINT_RIGHT_BOTTOM: targetAttachPosition.x = parentBoundingBox.x + parentBoundingBox.width; break; + } + switch (config->attachPoints.element) { + case CLAY_ATTACH_POINT_LEFT_TOP: + case CLAY_ATTACH_POINT_LEFT_CENTER: + case CLAY_ATTACH_POINT_LEFT_BOTTOM: break; + case CLAY_ATTACH_POINT_CENTER_TOP: + case CLAY_ATTACH_POINT_CENTER_CENTER: + case CLAY_ATTACH_POINT_CENTER_BOTTOM: targetAttachPosition.x -= (rootDimensions.width / 2); break; + case CLAY_ATTACH_POINT_RIGHT_TOP: + case CLAY_ATTACH_POINT_RIGHT_CENTER: + case CLAY_ATTACH_POINT_RIGHT_BOTTOM: targetAttachPosition.x -= rootDimensions.width; break; + } + switch (config->attachPoints.parent) { // I know I could merge the x and y switch statements, but this is easier to read + case CLAY_ATTACH_POINT_LEFT_TOP: + case CLAY_ATTACH_POINT_RIGHT_TOP: + case CLAY_ATTACH_POINT_CENTER_TOP: targetAttachPosition.y = parentBoundingBox.y; break; + case CLAY_ATTACH_POINT_LEFT_CENTER: + case CLAY_ATTACH_POINT_CENTER_CENTER: + case CLAY_ATTACH_POINT_RIGHT_CENTER: targetAttachPosition.y = parentBoundingBox.y + (parentBoundingBox.height / 2); break; + case CLAY_ATTACH_POINT_LEFT_BOTTOM: + case CLAY_ATTACH_POINT_CENTER_BOTTOM: + case CLAY_ATTACH_POINT_RIGHT_BOTTOM: targetAttachPosition.y = parentBoundingBox.y + parentBoundingBox.height; break; + } + switch (config->attachPoints.element) { + case CLAY_ATTACH_POINT_LEFT_TOP: + case CLAY_ATTACH_POINT_RIGHT_TOP: + case CLAY_ATTACH_POINT_CENTER_TOP: break; + case CLAY_ATTACH_POINT_LEFT_CENTER: + case CLAY_ATTACH_POINT_CENTER_CENTER: + case CLAY_ATTACH_POINT_RIGHT_CENTER: targetAttachPosition.y -= (rootDimensions.height / 2); break; + case CLAY_ATTACH_POINT_LEFT_BOTTOM: + case CLAY_ATTACH_POINT_CENTER_BOTTOM: + case CLAY_ATTACH_POINT_RIGHT_BOTTOM: targetAttachPosition.y -= rootDimensions.height; break; + } + targetAttachPosition.x += config->offset.x; + targetAttachPosition.y += config->offset.y; + rootPosition = targetAttachPosition; + } + if (root->clipElementId) { + Clay_LayoutElementHashMapItem *clipHashMapItem = Clay__GetHashMapItem(root->clipElementId); + if (clipHashMapItem && !Clay__ElementIsOffscreen(&clipHashMapItem->boundingBox)) { + // Floating elements that are attached to scrolling contents won't be correctly positioned if external scroll handling is enabled, fix here + if (context->externalScrollHandlingEnabled) { + if (clipHashMapItem->layoutElement->config.clip.horizontal) { + rootPosition.x += clipHashMapItem->layoutElement->config.clip.childOffset.x; + } + if (clipHashMapItem->layoutElement->config.clip.vertical) { + rootPosition.y += clipHashMapItem->layoutElement->config.clip.childOffset.y; + } + } + if (generateRenderCommands) { + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { + .boundingBox = clipHashMapItem->boundingBox, + .userData = 0, + .id = Clay__HashNumber(rootElement->id, rootElement->children.length + 10).id, // TODO need a better strategy for managing derived ids + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + }); + } + } + } + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, CLAY__INIT(Clay__LayoutElementTreeNode) { .layoutElement = rootElement, .position = rootPosition, .nextChildOffset = { .x = (float)rootElement->config.layout.padding.left, .y = (float)rootElement->config.layout.padding.top } }); + + context->treeNodeVisited.internalArray[0] = false; + while (dfsBuffer.length > 0) { + Clay__LayoutElementTreeNode *currentElementTreeNode = Clay__LayoutElementTreeNodeArray_Get(&dfsBuffer, (int)dfsBuffer.length - 1); + Clay_LayoutElement *currentElement = currentElementTreeNode->layoutElement; + Clay_LayoutConfig *layoutConfig = currentElement->isTextElement ? &CLAY_LAYOUT_DEFAULT : ¤tElement->config.layout; + Clay_Vector2 scrollOffset = CLAY__DEFAULT_STRUCT; + + // DFS is returning back upwards + if (context->treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + if (currentElement->isTextElement) { + dfsBuffer.length--; + continue; + } + Clay_LayoutElementHashMapItem *currentElementData = Clay__GetHashMapItem(currentElement->id); + if (generateRenderCommands && !Clay__ElementIsOffscreen(¤tElementData->boundingBox)) { + // DFS is returning upwards backwards + bool closeClipElement = false; + if (currentElement->config.clip.horizontal || currentElement->config.clip.vertical) { + closeClipElement = true; + for (int32_t i = 0; i < context->scrollContainerDatas.length; i++) { + Clay__ScrollContainerDataInternal *mapping = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (mapping->layoutElement == currentElement) { + scrollOffset = currentElement->config.clip.childOffset; + if (context->externalScrollHandlingEnabled) { + scrollOffset = CLAY__INIT(Clay_Vector2) CLAY__DEFAULT_STRUCT; + } + break; + } + } + } + + if (Clay__BorderHasAnyWidth(¤tElement->config.border)) { + Clay_BoundingBox currentElementBoundingBox = currentElementData->boundingBox; + Clay_BorderElementConfig *borderConfig = ¤tElement->config.border; + Clay_RenderCommand renderCommand = { + .boundingBox = currentElementBoundingBox, + .renderData = { .border = { + .color = borderConfig->color, + .cornerRadius = currentElement->config.cornerRadius, + .width = borderConfig->width + }}, + .userData = currentElement->config.userData, + .id = Clay__HashNumber(currentElement->id, currentElement->children.length).id, + .commandType = CLAY_RENDER_COMMAND_TYPE_BORDER, + }; + Clay__AddRenderCommand(renderCommand); + if (borderConfig->width.betweenChildren > 0 && borderConfig->color.a > 0) { + float halfGap = layoutConfig->childGap / 2; + float halfWidth = borderConfig->width.betweenChildren / 2; + Clay_Vector2 borderOffset = { (float)layoutConfig->padding.left - halfGap, (float)layoutConfig->padding.top - halfGap }; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + for (int32_t i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]); + if (i > 0) { + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { + .boundingBox = { currentElementBoundingBox.x + borderOffset.x + scrollOffset.x - halfWidth, currentElementBoundingBox.y + scrollOffset.y, (float)borderConfig->width.betweenChildren, currentElement->dimensions.height }, + .renderData = { .rectangle = { + .backgroundColor = borderConfig->color, + } }, + .userData = currentElement->config.userData, + .id = Clay__HashNumber(currentElement->id, currentElement->children.length + 1 + i).id, + .commandType = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + }); + } + borderOffset.x += (childElement->dimensions.width + (float)layoutConfig->childGap); + } + } else { + for (int32_t i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]); + if (i > 0) { + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { + .boundingBox = { currentElementBoundingBox.x + scrollOffset.x, currentElementBoundingBox.y + borderOffset.y + scrollOffset.y - halfWidth, currentElement->dimensions.width, (float)borderConfig->width.betweenChildren }, + .renderData = { .rectangle = { + .backgroundColor = borderConfig->color, + } }, + .userData = currentElement->config.userData, + .id = Clay__HashNumber(currentElement->id, currentElement->children.length + 1 + i).id, + .commandType = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + }); + } + borderOffset.y += (childElement->dimensions.height + (float)layoutConfig->childGap); + } + } + } + } + if (currentElement->config.overlayColor.a > 0) { + Clay_RenderCommand renderCommand = { + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_END, + }; + Clay__AddRenderCommand(renderCommand); + } + // This exists because the scissor needs to end _after_ borders between elements + if (closeClipElement) { + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { + .id = Clay__HashNumber(currentElement->id, rootElement->children.length + 11).id, + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_END, + }); + } + } + + dfsBuffer.length--; + continue; + } + + // This will only be run a single time for each element in downwards DFS order + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + Clay_BoundingBox currentElementBoundingBox = { currentElementTreeNode->position.x, currentElementTreeNode->position.y, currentElement->dimensions.width, currentElement->dimensions.height }; + Clay__ScrollContainerDataInternal *scrollContainerData = CLAY__NULL; + if (!currentElement->isTextElement) { + if (useStoredBoundingBoxes && currentElement->config.transition.handler) { + bool found = false; + for (int j = 0; j < context->transitionDatas.length; ++j) { + Clay__TransitionDataInternal* transitionData = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, j); + if (transitionData->elementId == currentElement->id) { + found = true; + if (transitionData->state != CLAY_TRANSITION_STATE_IDLE) { + if ((transitionData->activeProperties & CLAY_TRANSITION_PROPERTY_X) != 0) currentElementBoundingBox.x = transitionData->currentState.boundingBox.x; + if ((transitionData->activeProperties & CLAY_TRANSITION_PROPERTY_Y) != 0) currentElementBoundingBox.y = transitionData->currentState.boundingBox.y; + if ((transitionData->activeProperties & CLAY_TRANSITION_PROPERTY_WIDTH) != 0) currentElementBoundingBox.width = transitionData->currentState.boundingBox.width; + if ((transitionData->activeProperties & CLAY_TRANSITION_PROPERTY_HEIGHT) != 0) currentElementBoundingBox.height = transitionData->currentState.boundingBox.height; + } + break; + } + } + // An exiting element that completed its transition this frame - skip tree + if (!found && currentElement->config.transition.exit.setFinalState) { + dfsBuffer.length--; + continue; + } + } + if (currentElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE) { + Clay_FloatingElementConfig *floatingElementConfig = ¤tElement->config.floating; + Clay_Dimensions expand = floatingElementConfig->expand; + currentElementBoundingBox.x -= expand.width; + currentElementBoundingBox.width += expand.width * 2; + currentElementBoundingBox.y -= expand.height; + currentElementBoundingBox.height += expand.height * 2; + } + + // Apply scroll offsets to container + if (currentElement->config.clip.horizontal || currentElement->config.clip.vertical) { + // This linear scan could theoretically be slow under very strange conditions, but I can't imagine a real UI with more than a few 10's of scroll containers + for (int32_t i = 0; i < context->scrollContainerDatas.length; i++) { + Clay__ScrollContainerDataInternal *mapping = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (mapping->layoutElement == currentElement) { + scrollContainerData = mapping; + mapping->boundingBox = currentElementBoundingBox; + scrollOffset = currentElement->config.clip.childOffset; + if (context->externalScrollHandlingEnabled) { + scrollOffset = CLAY__INIT(Clay_Vector2) CLAY__DEFAULT_STRUCT; + } + break; + } + } + } + } + + bool offscreen = Clay__ElementIsOffscreen(¤tElementBoundingBox); + + // Generate render commands for current element + if (generateRenderCommands && !offscreen) { + if (currentElement->isTextElement) { + Clay_TextElementConfig *textElementConfig = ¤tElement->textConfig; + float naturalLineHeight = currentElement->textElementData.preferredDimensions.height; + float finalLineHeight = textElementConfig->lineHeight > 0 ? (float)textElementConfig->lineHeight : naturalLineHeight; + float lineHeightOffset = (finalLineHeight - naturalLineHeight) / 2; + float yPosition = lineHeightOffset; + for (int32_t lineIndex = 0; lineIndex < currentElement->textElementData.wrappedLines.length; ++lineIndex) { + Clay__WrappedTextLine *wrappedLine = Clay__WrappedTextLineArraySlice_Get(¤tElement->textElementData.wrappedLines, lineIndex); + if (wrappedLine->line.length == 0) { + yPosition += finalLineHeight; + continue; + } + float offset = (currentElementBoundingBox.width - wrappedLine->dimensions.width); + if (textElementConfig->textAlignment == CLAY_TEXT_ALIGN_LEFT) { + offset = 0; + } + if (textElementConfig->textAlignment == CLAY_TEXT_ALIGN_CENTER) { + offset /= 2; + } + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { + .boundingBox = { currentElementBoundingBox.x + offset, currentElementBoundingBox.y + yPosition, wrappedLine->dimensions.width, wrappedLine->dimensions.height }, + .renderData = { .text = { + .stringContents = CLAY__INIT(Clay_StringSlice) { .length = wrappedLine->line.length, .chars = wrappedLine->line.chars, .baseChars = currentElement->textElementData.text.chars }, + .textColor = textElementConfig->textColor, + .fontId = textElementConfig->fontId, + .fontSize = textElementConfig->fontSize, + .letterSpacing = textElementConfig->letterSpacing, + .lineHeight = textElementConfig->lineHeight, + }}, + .userData = textElementConfig->userData, + .id = Clay__HashNumber(lineIndex, currentElement->id).id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_TEXT, + }); + yPosition += finalLineHeight; + + if (!context->disableCulling && (currentElementBoundingBox.y + yPosition > context->layoutDimensions.height)) { + break; + } + } + } else { + if (currentElement->config.overlayColor.a > 0) { + Clay_RenderCommand renderCommand = { + .renderData = { + .overlayColor = { .color = currentElement->config.overlayColor } + }, + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_OVERLAY_COLOR_START, + }; + Clay__AddRenderCommand(renderCommand); + } + if (currentElement->config.image.imageData) { + Clay_RenderCommand renderCommand = { + .boundingBox = currentElementBoundingBox, + .renderData = { + .image = { + .backgroundColor = currentElement->config.backgroundColor, + .cornerRadius = currentElement->config.cornerRadius, + .imageData = currentElement->config.image.imageData, + } + }, + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_IMAGE, + }; + Clay__AddRenderCommand(renderCommand); + } + if (currentElement->config.custom.customData) { + Clay_RenderCommand renderCommand = { + .boundingBox = currentElementBoundingBox, + .renderData = { + .custom = { + .backgroundColor = currentElement->config.backgroundColor, + .cornerRadius = currentElement->config.cornerRadius, + .customData = currentElement->config.custom.customData, + } + }, + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_CUSTOM, + }; + Clay__AddRenderCommand(renderCommand); + } + if (currentElement->config.clip.horizontal || currentElement->config.clip.vertical) { + Clay_RenderCommand renderCommand = { + .boundingBox = currentElementBoundingBox, + .renderData = { + .clip = { + .horizontal = currentElement->config.clip.horizontal, + .vertical = currentElement->config.clip.vertical, + } + }, + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + }; + Clay__AddRenderCommand(renderCommand); + } + if (currentElement->config.backgroundColor.a > 0) { + Clay_RenderCommand renderCommand = { + .boundingBox = currentElementBoundingBox, + .renderData = { .rectangle = { + .backgroundColor = currentElement->config.backgroundColor, + .cornerRadius = currentElement->config.cornerRadius, + } }, + .userData = currentElement->config.userData, + .id = currentElement->id, + .zIndex = root->zIndex, + .commandType = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + }; + Clay__AddRenderCommand(renderCommand); + } + } + } + + Clay_LayoutElementHashMapItem *hashMapItem = Clay__GetHashMapItem(currentElement->id); + hashMapItem->boundingBox = currentElementBoundingBox; + + if (currentElement->isTextElement) continue; + + // Setup positions for child elements and add to DFS buffer ---------- + + // On-axis alignment + Clay_Dimensions contentSizeCurrent = {}; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + for (int32_t i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]); + if (childElement->exiting) continue; + contentSizeCurrent.width += childElement->dimensions.width; + contentSizeCurrent.height = CLAY__MAX(contentSizeCurrent.height, childElement->dimensions.height); + } + contentSizeCurrent.width += (float)(CLAY__MAX(currentElement->children.length - 1, 0) * layoutConfig->childGap); + float extraSpace = currentElement->dimensions.width - (float)(layoutConfig->padding.left + layoutConfig->padding.right) - contentSizeCurrent.width; + switch (layoutConfig->childAlignment.x) { + case CLAY_ALIGN_X_LEFT: extraSpace = 0; break; + case CLAY_ALIGN_X_CENTER: extraSpace /= 2; break; + default: break; + } + extraSpace = CLAY__MAX(0, extraSpace); + currentElementTreeNode->nextChildOffset.x += extraSpace; + } else if (layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM) { + for (int32_t i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]); + if (childElement->exiting) continue; + contentSizeCurrent.width = CLAY__MAX(contentSizeCurrent.width, childElement->dimensions.width); + contentSizeCurrent.height += childElement->dimensions.height; + } + contentSizeCurrent.height += (float)(CLAY__MAX(currentElement->children.length - 1, 0) * layoutConfig->childGap); + float extraSpace = currentElement->dimensions.height - (float)(layoutConfig->padding.top + layoutConfig->padding.bottom) - contentSizeCurrent.height; + switch (layoutConfig->childAlignment.y) { + case CLAY_ALIGN_Y_TOP: extraSpace = 0; break; + case CLAY_ALIGN_Y_CENTER: extraSpace /= 2; break; + default: break; + } + extraSpace = CLAY__MAX(0, extraSpace); + currentElementTreeNode->nextChildOffset.y += extraSpace; + } + + if (scrollContainerData) { + scrollContainerData->contentSize = CLAY__INIT(Clay_Dimensions) {contentSizeCurrent.width + (float)(layoutConfig->padding.left + layoutConfig->padding.right), contentSizeCurrent.height + (float)(layoutConfig->padding.top + layoutConfig->padding.bottom) }; + } + + // Add children to the DFS buffer + dfsBuffer.length += currentElement->children.length; + for (int32_t i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = Clay_LayoutElementArray_Get(&context->layoutElements, currentElement->children.elements[i]); + Clay_LayoutElementHashMapItem* childMapItem = Clay__GetHashMapItem(childElement->id); + // Alignment along non layout axis + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + currentElementTreeNode->nextChildOffset.y = currentElement->config.layout.padding.top; + float whiteSpaceAroundChild = currentElement->dimensions.height - (float)(layoutConfig->padding.top + layoutConfig->padding.bottom) - childElement->dimensions.height; + switch (layoutConfig->childAlignment.y) { + case CLAY_ALIGN_Y_TOP: break; + case CLAY_ALIGN_Y_CENTER: currentElementTreeNode->nextChildOffset.y += whiteSpaceAroundChild / 2; break; + case CLAY_ALIGN_Y_BOTTOM: currentElementTreeNode->nextChildOffset.y += whiteSpaceAroundChild; break; + } + } else { + currentElementTreeNode->nextChildOffset.x = currentElement->config.layout.padding.left; + float whiteSpaceAroundChild = currentElement->dimensions.width - (float)(layoutConfig->padding.left + layoutConfig->padding.right) - childElement->dimensions.width; + switch (layoutConfig->childAlignment.x) { + case CLAY_ALIGN_X_LEFT: break; + case CLAY_ALIGN_X_CENTER: currentElementTreeNode->nextChildOffset.x += whiteSpaceAroundChild / 2; break; + case CLAY_ALIGN_X_RIGHT: currentElementTreeNode->nextChildOffset.x += whiteSpaceAroundChild; break; + } + } + + Clay_Vector2 childPosition = { + currentElementBoundingBox.x + currentElementTreeNode->nextChildOffset.x + scrollOffset.x, + currentElementBoundingBox.y + currentElementTreeNode->nextChildOffset.y + scrollOffset.y, + }; + + // DFS buffer elements need to be added in reverse because stack traversal happens backwards + uint32_t newNodeIndex = dfsBuffer.length - 1 - i; + dfsBuffer.internalArray[newNodeIndex] = CLAY__INIT(Clay__LayoutElementTreeNode) { + .layoutElement = childElement, + .position = CLAY__INIT(Clay_Vector2) { childPosition.x, childPosition.y }, + .nextChildOffset = { .x = (float)childElement->config.layout.padding.left, .y = (float)childElement->config.layout.padding.top }, + }; + context->treeNodeVisited.internalArray[newNodeIndex] = false; + + // Update parent offsets + if (!childElement->exiting) { + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + currentElementTreeNode->nextChildOffset.x += childElement->dimensions.width + (float)layoutConfig->childGap; + } else { + currentElementTreeNode->nextChildOffset.y += childElement->dimensions.height + (float)layoutConfig->childGap; + } + } + } + } + + if (root->clipElementId) { + Clay_LayoutElementHashMapItem *clipHashMapItem = Clay__GetHashMapItem(root->clipElementId); + if (clipHashMapItem && !Clay__ElementIsOffscreen(&clipHashMapItem->boundingBox)) { + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand) { .id = Clay__HashNumber(rootElement->id, rootElement->children.length + 11).id, .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_END }); + } + } + } +} + +CLAY_WASM_EXPORT("Clay_GetPointerOverIds") +CLAY_DLL_EXPORT Clay_ElementIdArray Clay_GetPointerOverIds(void) { + return Clay_GetCurrentContext()->pointerOverIds; +} + +#pragma region DebugTools +Clay_Color CLAY__DEBUGVIEW_COLOR_1 = {58, 56, 52, 255}; +Clay_Color CLAY__DEBUGVIEW_COLOR_2 = {62, 60, 58, 255}; +Clay_Color CLAY__DEBUGVIEW_COLOR_3 = {141, 133, 135, 255}; +Clay_Color CLAY__DEBUGVIEW_COLOR_4 = {238, 226, 231, 255}; +Clay_Color CLAY__DEBUGVIEW_COLOR_SELECTED_ROW = {102, 80, 78, 255}; +const int32_t CLAY__DEBUGVIEW_ROW_HEIGHT = 30; +const int32_t CLAY__DEBUGVIEW_OUTER_PADDING = 10; +const int32_t CLAY__DEBUGVIEW_INDENT_WIDTH = 16; +Clay_TextElementConfig Clay__DebugView_TextNameConfig = {.textColor = {238, 226, 231, 255}, .fontSize = 16, .wrapMode = CLAY_TEXT_WRAP_NONE }; +Clay_LayoutConfig Clay__DebugView_ScrollViewItemLayoutConfig = CLAY__DEFAULT_STRUCT; + +typedef struct { + Clay_String label; + Clay_Color color; +} Clay__DebugElementConfigTypeLabelConfig; + +typedef enum { + CLAY__ELEMENT_CONFIG_TYPE_BACKGROUND_COLOR, + CLAY__ELEMENT_CONFIG_TYPE_OVERLAY_COLOR, + CLAY__ELEMENT_CONFIG_TYPE_CORNER_RADIUS, + CLAY__ELEMENT_CONFIG_TYPE_TEXT, + CLAY__ELEMENT_CONFIG_TYPE_ASPECT, + CLAY__ELEMENT_CONFIG_TYPE_IMAGE, + CLAY__ELEMENT_CONFIG_TYPE_FLOATING, + CLAY__ELEMENT_CONFIG_TYPE_CLIP, + CLAY__ELEMENT_CONFIG_TYPE_BORDER, + CLAY__ELEMENT_CONFIG_TYPE_CUSTOM, +} Clay__DebugElementConfigType; + +Clay__DebugElementConfigTypeLabelConfig Clay__DebugGetElementConfigTypeLabel(Clay__DebugElementConfigType type) { + switch (type) { + case CLAY__ELEMENT_CONFIG_TYPE_BACKGROUND_COLOR: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Background"), {243,134,48,255} }; + case CLAY__ELEMENT_CONFIG_TYPE_OVERLAY_COLOR: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Overlay"), { 142,129,206, 255} }; + case CLAY__ELEMENT_CONFIG_TYPE_CORNER_RADIUS: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) {CLAY_STRING("Radius"), {239,148,157, 255 } }; + case CLAY__ELEMENT_CONFIG_TYPE_TEXT: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Text"), {105,210,231,255} }; + case CLAY__ELEMENT_CONFIG_TYPE_ASPECT: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Aspect"), {101,149,194,255} }; + case CLAY__ELEMENT_CONFIG_TYPE_IMAGE: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Image"), {121,189,154,255} }; + case CLAY__ELEMENT_CONFIG_TYPE_FLOATING: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Floating"), {250,105,0,255} }; + case CLAY__ELEMENT_CONFIG_TYPE_CLIP: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) {CLAY_STRING("Scroll"), {242, 196, 90, 255} }; + case CLAY__ELEMENT_CONFIG_TYPE_BORDER: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) {CLAY_STRING("Border"), {108, 91, 123, 255} }; + case CLAY__ELEMENT_CONFIG_TYPE_CUSTOM: return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Custom"), {11,72,107,255} }; + default: break; + } + return CLAY__INIT(Clay__DebugElementConfigTypeLabelConfig) { CLAY_STRING("Error"), {0,0,0,255} }; +} + +void Clay__RenderElementConfigTypeLabel(Clay_String label, Clay_Color color, bool offscreen) { + Clay_Color backgroundColor = color; + backgroundColor.a = 90; + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 } }, .backgroundColor = backgroundColor, .cornerRadius = CLAY_CORNER_RADIUS(4), .border = { .color = color, .width = { 1, 1, 1, 1, 0 } } }) { + CLAY_TEXT(label, CLAY_TEXT_CONFIG({ .textColor = offscreen ? CLAY__DEBUGVIEW_COLOR_3 : CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } +} + +typedef struct { + int32_t rowCount; + int32_t selectedElementRowIndex; +} Clay__RenderDebugLayoutData; + +// Returns row count +Clay__RenderDebugLayoutData Clay__RenderDebugLayoutElementsList(int32_t initialRootsLength, int32_t highlightedRowIndex) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__int32_tArray dfsBuffer = context->reusableElementIndexBuffer; + Clay__DebugView_ScrollViewItemLayoutConfig = CLAY__INIT(Clay_LayoutConfig) { .sizing = { .height = CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT) }, .childGap = 6, .childAlignment = { .y = CLAY_ALIGN_Y_CENTER }}; + Clay__RenderDebugLayoutData layoutData = CLAY__DEFAULT_STRUCT; + + uint32_t highlightedElementId = 0; + + for (int32_t rootIndex = 0; rootIndex < initialRootsLength; ++rootIndex) { + dfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, rootIndex); + Clay__int32_tArray_Add(&dfsBuffer, (int32_t)root->layoutElementIndex); + context->treeNodeVisited.internalArray[0] = false; + if (rootIndex > 0) { + CLAY(CLAY_IDI("Clay__DebugView_EmptyRowOuter", rootIndex), { .layout = { .sizing = {.width = CLAY_SIZING_GROW(0)}, .padding = {CLAY__DEBUGVIEW_INDENT_WIDTH / 2, 0, 0, 0} } }) { + CLAY(CLAY_IDI("Clay__DebugView_EmptyRow", rootIndex), { .layout = { .sizing = { .width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED((float)CLAY__DEBUGVIEW_ROW_HEIGHT) }}, .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = { .top = 1 } } }) {} + } + layoutData.rowCount++; + } + while (dfsBuffer.length > 0) { + int32_t currentElementIndex = Clay__int32_tArray_GetValue(&dfsBuffer, (int)dfsBuffer.length - 1); + Clay_LayoutElement *currentElement = Clay_LayoutElementArray_Get(&context->layoutElements, (int)currentElementIndex); + if (context->treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + if (!currentElement->isTextElement && currentElement->children.length > 0) { + Clay__CloseElement(); + Clay__CloseElement(); + Clay__CloseElement(); + } + dfsBuffer.length--; + continue; + } + + if (currentElement->exiting) { // TODO there is a duplicate ID problem with exiting elements + dfsBuffer.length--; + continue; + } + + if (highlightedRowIndex == layoutData.rowCount) { + if (context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) { + context->debugSelectedElementId = currentElement->id; + } + highlightedElementId = currentElement->id; + } + + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + Clay_LayoutElementHashMapItem *currentElementData = Clay__GetHashMapItem(currentElement->id); + bool offscreen = Clay__ElementIsOffscreen(¤tElementData->boundingBox); + if (context->debugSelectedElementId == currentElement->id) { + layoutData.selectedElementRowIndex = layoutData.rowCount; + } + CLAY(CLAY_IDI("Clay__DebugView_ElementOuter", currentElement->id), { .layout = Clay__DebugView_ScrollViewItemLayoutConfig }) { + // Collapse icon / button + if (!(currentElement->isTextElement || currentElement->children.length == 0)) { + CLAY(CLAY_IDI("Clay__DebugView_CollapseElement", currentElement->id), { + .layout = { .sizing = {CLAY_SIZING_FIXED(16), CLAY_SIZING_FIXED(16)}, .childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER} }, + .cornerRadius = CLAY_CORNER_RADIUS(4), + .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = {1, 1, 1, 1, 0} }, + }) { + CLAY_TEXT((currentElementData && currentElementData->debugData.collapsed) ? CLAY_STRING("+") : CLAY_STRING("-"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } + } else { // Square dot for empty containers + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_FIXED(16), CLAY_SIZING_FIXED(16)}, .childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER } } }) { + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_FIXED(8), CLAY_SIZING_FIXED(8)} }, .backgroundColor = CLAY__DEBUGVIEW_COLOR_3, .cornerRadius = CLAY_CORNER_RADIUS(2) }) {} + } + } + // Collisions and offscreen info + if (currentElementData) { + if (currentElementData->debugData.collision) { + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 }}, .border = { .color = {177, 147, 8, 255}, .width = {1, 1, 1, 1, 0} } }) { + CLAY_TEXT(CLAY_STRING("Duplicate ID"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_3, .fontSize = 16 })); + } + } + if (offscreen) { + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 } }, .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = { 1, 1, 1, 1, 0} } }) { + CLAY_TEXT(CLAY_STRING("Offscreen"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_3, .fontSize = 16 })); + } + } + } + if (currentElementData->elementId.stringId.length > 0) { + CLAY_AUTO_ID() { + Clay_TextElementConfig textConfig = offscreen ? CLAY__INIT(Clay_TextElementConfig) { .textColor = CLAY__DEBUGVIEW_COLOR_3, .fontSize = 16 } : Clay__DebugView_TextNameConfig; + CLAY_TEXT(currentElementData->elementId.stringId, textConfig); + if (currentElementData->elementId.offset != 0) { + CLAY_TEXT(CLAY_STRING(" ("), textConfig); + CLAY_TEXT(Clay__IntToString(currentElementData->elementId.offset), textConfig); + CLAY_TEXT(CLAY_STRING(")"), textConfig); + } + } + } + if (currentElement->isTextElement) { + Clay__RenderElementConfigTypeLabel(CLAY_STRING("Text"), CLAY__INIT(Clay_Color) { 105,210,231,255 }, offscreen); + } else { + if (currentElement->config.backgroundColor.a > 0) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_BACKGROUND_COLOR); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.overlayColor.a > 0) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_OVERLAY_COLOR); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (!Clay__MemCmp((const char*)¤tElement->config.cornerRadius, (const char*)&Clay__CornerRadius_DEFAULT, sizeof(Clay_CornerRadius))) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_CORNER_RADIUS); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.aspectRatio.aspectRatio != 0) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_ASPECT); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.image.imageData) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_IMAGE); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_FLOATING); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.clip.horizontal || currentElement->config.clip.vertical) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_CLIP); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (Clay__BorderHasAnyWidth(¤tElement->config.border)) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_BORDER); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + if (currentElement->config.custom.customData) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_CUSTOM); + Clay__RenderElementConfigTypeLabel(config.label, config.color, offscreen); + } + } + } + + // Render the text contents below the element as a non-interactive row + if (currentElement->isTextElement) { + layoutData.rowCount++; + Clay__TextElementData *textElementData = ¤tElement->textElementData; + Clay_TextElementConfig rawTextConfig = offscreen ? CLAY__INIT(Clay_TextElementConfig) { .textColor = CLAY__DEBUGVIEW_COLOR_3, .fontSize = 16 } : Clay__DebugView_TextNameConfig; + CLAY_AUTO_ID({ .layout = { .sizing = { .height = CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT)}, .childAlignment = { .y = CLAY_ALIGN_Y_CENTER } } }) { + CLAY_AUTO_ID({ .layout = { .sizing = {.width = CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_INDENT_WIDTH + 16) } } }) {} + CLAY_TEXT(CLAY_STRING("\""), rawTextConfig); + CLAY_TEXT(textElementData->text.length > 40 ? (CLAY__INIT(Clay_String) { .length = 40, .chars = textElementData->text.chars }) : textElementData->text, rawTextConfig); + if (textElementData->text.length > 40) { + CLAY_TEXT(CLAY_STRING("..."), rawTextConfig); + } + CLAY_TEXT(CLAY_STRING("\""), rawTextConfig); + } + } else if (currentElement->children.length > 0) { + Clay__OpenElement(); + Clay__ConfigureOpenElement(CLAY__INIT(Clay_ElementDeclaration) { .layout = { .padding = { .left = 8 } } }); + Clay__OpenElement(); + Clay__ConfigureOpenElement(CLAY__INIT(Clay_ElementDeclaration) { .layout = { .padding = { .left = CLAY__DEBUGVIEW_INDENT_WIDTH }}, .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = { .left = 1 } }}); + Clay__OpenElement(); + Clay__ConfigureOpenElement(CLAY__INIT(Clay_ElementDeclaration) { .layout = { .layoutDirection = CLAY_TOP_TO_BOTTOM } }); + } + + layoutData.rowCount++; + if (!(currentElement->isTextElement || (currentElementData && currentElementData->debugData.collapsed))) { + for (int32_t i = currentElement->children.length - 1; i >= 0; --i) { + Clay__int32_tArray_Add(&dfsBuffer, currentElement->children.elements[i]); + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = false; // TODO needs to be ranged checked + } + } + } + } + + if (context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) { + Clay_ElementId collapseButtonId = Clay__HashString(CLAY_STRING("Clay__DebugView_CollapseElement"), 0); + for (int32_t i = (int)context->pointerOverIds.length - 1; i >= 0; i--) { + Clay_ElementId *elementId = Clay_ElementIdArray_Get(&context->pointerOverIds, i); + if (elementId->baseId == collapseButtonId.baseId) { + Clay_LayoutElementHashMapItem *highlightedItem = Clay__GetHashMapItem(elementId->offset); + highlightedItem->debugData.collapsed = !highlightedItem->debugData.collapsed; + break; + } + } + } + + if (highlightedElementId) { + CLAY(CLAY_ID("Clay__DebugView_ElementHighlight"), { .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)} }, .floating = { .parentId = highlightedElementId, .zIndex = 32767, .pointerCaptureMode = CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH, .attachTo = CLAY_ATTACH_TO_ELEMENT_WITH_ID } }) { + CLAY(CLAY_ID("Clay__DebugView_ElementHighlightRectangle"), { .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)} }, .backgroundColor = Clay__debugViewHighlightColor }) {} + } + } + return layoutData; +} + +void Clay__RenderDebugLayoutSizing(Clay_SizingAxis sizing, Clay_TextElementConfig infoTextConfig) { + Clay_String sizingLabel = CLAY_STRING("GROW"); + if (sizing.type == CLAY__SIZING_TYPE_FIT) { + sizingLabel = CLAY_STRING("FIT"); + } else if (sizing.type == CLAY__SIZING_TYPE_PERCENT) { + sizingLabel = CLAY_STRING("PERCENT"); + } else if (sizing.type == CLAY__SIZING_TYPE_FIXED) { + sizingLabel = CLAY_STRING("FIXED"); + } + CLAY_TEXT(sizingLabel, infoTextConfig); + if (sizing.type == CLAY__SIZING_TYPE_GROW || sizing.type == CLAY__SIZING_TYPE_FIT || sizing.type == CLAY__SIZING_TYPE_FIXED) { + CLAY_TEXT(CLAY_STRING("("), infoTextConfig); + if (sizing.size.minMax.min != 0) { + CLAY_TEXT(CLAY_STRING("min: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(sizing.size.minMax.min), infoTextConfig); + if (sizing.size.minMax.max != CLAY__MAXFLOAT) { + CLAY_TEXT(CLAY_STRING(", "), infoTextConfig); + } + } + if (sizing.size.minMax.max != CLAY__MAXFLOAT) { + CLAY_TEXT(CLAY_STRING("max: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(sizing.size.minMax.max), infoTextConfig); + } + CLAY_TEXT(CLAY_STRING(")"), infoTextConfig); + } else if (sizing.type == CLAY__SIZING_TYPE_PERCENT) { + CLAY_TEXT(CLAY_STRING("("), infoTextConfig); + CLAY_TEXT(Clay__IntToString(sizing.size.percent * 100), infoTextConfig); + CLAY_TEXT(CLAY_STRING("%)"), infoTextConfig); + } +} + +void Clay__DebugViewRenderElementConfigHeader(Clay_String elementId, Clay__DebugElementConfigType type) { + Clay__DebugElementConfigTypeLabelConfig config = Clay__DebugGetElementConfigTypeLabel(type); + Clay_Color backgroundColor = config.color; + backgroundColor.a = 90; + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 } }, .backgroundColor = backgroundColor, .cornerRadius = CLAY_CORNER_RADIUS(4), .border = { .color = config.color, .width = { 1, 1, 1, 1, 0 } } }) { + CLAY_TEXT(config.label, CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } +} + +void Clay__RenderDebugViewColor(Clay_Color color, Clay_TextElementConfig textConfig) { + CLAY_AUTO_ID({ .layout = { .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} } }) { + CLAY_TEXT(CLAY_STRING("{ r: "), textConfig); + CLAY_TEXT(Clay__IntToString(color.r), textConfig); + CLAY_TEXT(CLAY_STRING(", g: "), textConfig); + CLAY_TEXT(Clay__IntToString(color.g), textConfig); + CLAY_TEXT(CLAY_STRING(", b: "), textConfig); + CLAY_TEXT(Clay__IntToString(color.b), textConfig); + CLAY_TEXT(CLAY_STRING(", a: "), textConfig); + CLAY_TEXT(Clay__IntToString(color.a), textConfig); + CLAY_TEXT(CLAY_STRING(" }"), textConfig); + CLAY_AUTO_ID({ .layout = { .sizing = { .width = CLAY_SIZING_FIXED(10) } } }) {} + CLAY_AUTO_ID({ .layout = { .sizing = { CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT - 8), CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT - 8)} }, .backgroundColor = color, .cornerRadius = CLAY_CORNER_RADIUS(4), .border = { .color = CLAY__DEBUGVIEW_COLOR_4, .width = { 1, 1, 1, 1, 0 } } }) {} + } +} + +void Clay__RenderDebugViewCornerRadius(Clay_CornerRadius cornerRadius, Clay_TextElementConfig textConfig) { + CLAY_AUTO_ID({ .layout = { .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} } }) { + CLAY_TEXT(CLAY_STRING("{ topLeft: "), textConfig); + CLAY_TEXT(Clay__IntToString(cornerRadius.topLeft), textConfig); + CLAY_TEXT(CLAY_STRING(", topRight: "), textConfig); + CLAY_TEXT(Clay__IntToString(cornerRadius.topRight), textConfig); + CLAY_TEXT(CLAY_STRING(", bottomLeft: "), textConfig); + CLAY_TEXT(Clay__IntToString(cornerRadius.bottomLeft), textConfig); + CLAY_TEXT(CLAY_STRING(", bottomRight: "), textConfig); + CLAY_TEXT(Clay__IntToString(cornerRadius.bottomRight), textConfig); + CLAY_TEXT(CLAY_STRING(" }"), textConfig); + } +} + +void HandleDebugViewCloseButtonInteraction(Clay_ElementId elementId, Clay_PointerData pointerInfo, void *userData) { + Clay_Context* context = Clay_GetCurrentContext(); + (void) elementId; (void) pointerInfo; (void) userData; + if (pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) { + context->debugModeEnabled = false; + } +} + +void Clay__RenderDebugView(void) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay_ElementId closeButtonId = Clay__HashString(CLAY_STRING("Clay__DebugViewTopHeaderCloseButtonOuter"), 0); + if (context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) { + for (int32_t i = 0; i < context->pointerOverIds.length; ++i) { + Clay_ElementId *elementId = Clay_ElementIdArray_Get(&context->pointerOverIds, i); + if (elementId->id == closeButtonId.id) { + context->debugModeEnabled = false; + return; + } + } + } + + uint32_t initialRootsLength = context->layoutElementTreeRoots.length; + uint32_t initialElementsLength = context->layoutElements.length; + Clay_TextElementConfig infoTextConfig = CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16, .wrapMode = CLAY_TEXT_WRAP_NONE }); + Clay_TextElementConfig infoTitleConfig = CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_3, .fontSize = 16, .wrapMode = CLAY_TEXT_WRAP_NONE }); + Clay_ElementId scrollId = Clay__HashString(CLAY_STRING("Clay__DebugViewOuterScrollPane"), 0); + float scrollYOffset = 0; + bool pointerInDebugView = context->pointerInfo.position.y < context->layoutDimensions.height - 300; + for (int32_t i = 0; i < context->scrollContainerDatas.length; ++i) { + Clay__ScrollContainerDataInternal *scrollContainerData = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (scrollContainerData->elementId == scrollId.id) { + if (!context->externalScrollHandlingEnabled) { + scrollYOffset = scrollContainerData->scrollPosition.y; + } else { + pointerInDebugView = context->pointerInfo.position.y + scrollContainerData->scrollPosition.y < context->layoutDimensions.height - 300; + } + break; + } + } + int32_t highlightedRow = pointerInDebugView + ? (int32_t)((context->pointerInfo.position.y - scrollYOffset) / (float)CLAY__DEBUGVIEW_ROW_HEIGHT) - 1 + : -1; + if (context->pointerInfo.position.x < context->layoutDimensions.width - (float)Clay__debugViewWidth) { + highlightedRow = -1; + } + Clay__RenderDebugLayoutData layoutData = CLAY__DEFAULT_STRUCT; + CLAY(CLAY_ID("Clay__DebugView"), { + .layout = { .sizing = { CLAY_SIZING_FIXED((float)Clay__debugViewWidth) , CLAY_SIZING_FIXED(context->layoutDimensions.height) }, .layoutDirection = CLAY_TOP_TO_BOTTOM }, + .floating = { .zIndex = 32765, .attachPoints = { .element = CLAY_ATTACH_POINT_LEFT_CENTER, .parent = CLAY_ATTACH_POINT_RIGHT_CENTER }, .attachTo = CLAY_ATTACH_TO_ROOT, .clipTo = CLAY_CLIP_TO_ATTACHED_PARENT }, + .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = { .bottom = 1 } } + }) { + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT)}, .padding = {CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 0, 0 }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} }, .backgroundColor = CLAY__DEBUGVIEW_COLOR_2 }) { + CLAY_TEXT(CLAY_STRING("Clay Debug Tools"), infoTextConfig); + CLAY_AUTO_ID({ .layout = { .sizing = { .width = CLAY_SIZING_GROW(0) } } }) {} + // Close button + CLAY_AUTO_ID({ + .layout = { .sizing = {CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT - 10), CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT - 10)}, .childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER} }, + .backgroundColor = {217,91,67,80}, + .cornerRadius = CLAY_CORNER_RADIUS(4), + .border = { .color = { 217,91,67,255 }, .width = { 1, 1, 1, 1, 0 } }, + }) { + Clay_OnHover(HandleDebugViewCloseButtonInteraction, 0); + CLAY_TEXT(CLAY_STRING("x"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } + } + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(1)} }, .backgroundColor = CLAY__DEBUGVIEW_COLOR_3 } ) {} + CLAY(scrollId, { .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)} }, .clip = { .horizontal = true, .vertical = true, .childOffset = Clay_GetScrollOffset() } }) { + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)}, .layoutDirection = CLAY_TOP_TO_BOTTOM }, .backgroundColor = ((initialElementsLength + initialRootsLength) & 1) == 0 ? CLAY__DEBUGVIEW_COLOR_2 : CLAY__DEBUGVIEW_COLOR_1 }) { + Clay_ElementId panelContentsId = Clay__HashString(CLAY_STRING("Clay__DebugViewPaneOuter"), 0); + // Element list + CLAY(panelContentsId, { .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)} }, .floating = { .zIndex = 32766, .pointerCaptureMode = CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH, .attachTo = CLAY_ATTACH_TO_PARENT, .clipTo = CLAY_CLIP_TO_ATTACHED_PARENT } }) { + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_GROW(0)}, .padding = { CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 0, 0 }, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + layoutData = Clay__RenderDebugLayoutElementsList((int32_t)initialRootsLength, highlightedRow); + } + } + float contentWidth = Clay__GetHashMapItem(panelContentsId.id)->layoutElement->dimensions.width; + CLAY_AUTO_ID({ .layout = { .sizing = {.width = CLAY_SIZING_FIXED(contentWidth) }, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) {} + for (int32_t i = 0; i < layoutData.rowCount; i++) { + Clay_Color rowColor = (i & 1) == 0 ? CLAY__DEBUGVIEW_COLOR_2 : CLAY__DEBUGVIEW_COLOR_1; + if (i == layoutData.selectedElementRowIndex) { + rowColor = CLAY__DEBUGVIEW_COLOR_SELECTED_ROW; + } + if (i == highlightedRow) { + rowColor.r *= 1.25f; + rowColor.g *= 1.25f; + rowColor.b *= 1.25f; + } + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT)}, .layoutDirection = CLAY_TOP_TO_BOTTOM }, .backgroundColor = rowColor } ) {} + } + } + } + CLAY_AUTO_ID({ .layout = { .sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(1)} }, .backgroundColor = CLAY__DEBUGVIEW_COLOR_3 }) {} + Clay_LayoutElementHashMapItem *selectedItem = Clay__GetHashMapItem(context->debugSelectedElementId); + if (selectedItem->layoutElement) { + CLAY_AUTO_ID({ + .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(300)}, .layoutDirection = CLAY_TOP_TO_BOTTOM }, + .backgroundColor = CLAY__DEBUGVIEW_COLOR_2 , + .clip = { .vertical = true, .childOffset = Clay_GetScrollOffset() }, + .border = { .color = CLAY__DEBUGVIEW_COLOR_3, .width = { .betweenChildren = 1 } } + }) { + CLAY_AUTO_ID({ .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT + 8)}, .padding = {CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 0, 0 }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} } }) { + CLAY_TEXT(CLAY_STRING("Element Configuration"), infoTextConfig); + CLAY_AUTO_ID({ .layout = { .sizing = { .width = CLAY_SIZING_GROW(0) } } }) {} + if (selectedItem->elementId.stringId.length != 0) { + CLAY_TEXT(selectedItem->elementId.stringId, infoTitleConfig); + if (selectedItem->elementId.offset != 0) { + CLAY_TEXT(CLAY_STRING(" ("), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(selectedItem->elementId.offset), infoTitleConfig); + CLAY_TEXT(CLAY_STRING(")"), infoTitleConfig); + } + } + } + Clay_Padding attributeConfigPadding = {CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 8, 8}; + // Clay_LayoutConfig debug info + CLAY_AUTO_ID({ .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 } }, .backgroundColor = { 200, 200, 200, 120 }, .cornerRadius = CLAY_CORNER_RADIUS(4), .border = { .color = { 200, 200, 200, 255 }, .width = { 1, 1, 1, 1, 0 } } }) { + CLAY_TEXT(CLAY_STRING("Layout"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } + // .boundingBox + CLAY_TEXT(CLAY_STRING("Bounding Box"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ x: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(selectedItem->boundingBox.x), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", y: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(selectedItem->boundingBox.y), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", width: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(selectedItem->boundingBox.width), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", height: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(selectedItem->boundingBox.height), infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + if (!selectedItem->layoutElement->isTextElement) { + // .layoutDirection + CLAY_TEXT(CLAY_STRING("Layout Direction"), infoTitleConfig); + Clay_LayoutConfig *layoutConfig = &selectedItem->layoutElement->config.layout; + CLAY_TEXT(layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM ? CLAY_STRING("TOP_TO_BOTTOM") : CLAY_STRING("LEFT_TO_RIGHT"), infoTextConfig); + // .sizing + CLAY_TEXT(CLAY_STRING("Sizing"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("width: "), infoTextConfig); + Clay__RenderDebugLayoutSizing(layoutConfig->sizing.width, infoTextConfig); + } + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("height: "), infoTextConfig); + Clay__RenderDebugLayoutSizing(layoutConfig->sizing.height, infoTextConfig); + } + // .padding + CLAY_TEXT(CLAY_STRING("Padding"), infoTitleConfig); + CLAY(CLAY_ID("Clay__DebugViewElementInfoPadding"), { }) { + CLAY_TEXT(CLAY_STRING("{ left: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(layoutConfig->padding.left), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", right: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(layoutConfig->padding.right), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", top: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(layoutConfig->padding.top), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", bottom: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(layoutConfig->padding.bottom), infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + // .childGap + CLAY_TEXT(CLAY_STRING("Child Gap"), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(layoutConfig->childGap), infoTextConfig); + // .childAlignment + CLAY_TEXT(CLAY_STRING("Child Alignment"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ x: "), infoTextConfig); + Clay_String alignX = CLAY_STRING("LEFT"); + if (layoutConfig->childAlignment.x == CLAY_ALIGN_X_CENTER) { + alignX = CLAY_STRING("CENTER"); + } else if (layoutConfig->childAlignment.x == CLAY_ALIGN_X_RIGHT) { + alignX = CLAY_STRING("RIGHT"); + } + CLAY_TEXT(alignX, infoTextConfig); + CLAY_TEXT(CLAY_STRING(", y: "), infoTextConfig); + Clay_String alignY = CLAY_STRING("TOP"); + if (layoutConfig->childAlignment.y == CLAY_ALIGN_Y_CENTER) { + alignY = CLAY_STRING("CENTER"); + } else if (layoutConfig->childAlignment.y == CLAY_ALIGN_Y_BOTTOM) { + alignY = CLAY_STRING("BOTTOM"); + } + CLAY_TEXT(alignY, infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + } + } + if (selectedItem->layoutElement->isTextElement) { + Clay_TextElementConfig *textConfig = &selectedItem->layoutElement->textConfig; + CLAY_AUTO_ID({ .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_TEXT); + // .fontSize + CLAY_TEXT(CLAY_STRING("Font Size"), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(textConfig->fontSize), infoTextConfig); + // .fontId + CLAY_TEXT(CLAY_STRING("Font ID"), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(textConfig->fontId), infoTextConfig); + // .lineHeight + CLAY_TEXT(CLAY_STRING("Line Height"), infoTitleConfig); + CLAY_TEXT(textConfig->lineHeight == 0 ? CLAY_STRING("auto") : Clay__IntToString(textConfig->lineHeight), infoTextConfig); + // .letterSpacing + CLAY_TEXT(CLAY_STRING("Letter Spacing"), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(textConfig->letterSpacing), infoTextConfig); + // .wrapMode + CLAY_TEXT(CLAY_STRING("Wrap Mode"), infoTitleConfig); + Clay_String wrapMode = CLAY_STRING("WORDS"); + if (textConfig->wrapMode == CLAY_TEXT_WRAP_NONE) { + wrapMode = CLAY_STRING("NONE"); + } else if (textConfig->wrapMode == CLAY_TEXT_WRAP_NEWLINES) { + wrapMode = CLAY_STRING("NEWLINES"); + } + CLAY_TEXT(wrapMode, infoTextConfig); + // .textAlignment + CLAY_TEXT(CLAY_STRING("Text Alignment"), infoTitleConfig); + Clay_String textAlignment = CLAY_STRING("LEFT"); + if (textConfig->textAlignment == CLAY_TEXT_ALIGN_CENTER) { + textAlignment = CLAY_STRING("CENTER"); + } else if (textConfig->textAlignment == CLAY_TEXT_ALIGN_RIGHT) { + textAlignment = CLAY_STRING("RIGHT"); + } + CLAY_TEXT(textAlignment, infoTextConfig); + // .textColor + CLAY_TEXT(CLAY_STRING("Text Color"), infoTitleConfig); + Clay__RenderDebugViewColor(textConfig->textColor, infoTextConfig); + } + } else { + CLAY(CLAY_ID("Clay__DebugViewElementInfoSharedBody"), { .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugElementConfigTypeLabelConfig labelConfig = Clay__DebugGetElementConfigTypeLabel(CLAY__ELEMENT_CONFIG_TYPE_BACKGROUND_COLOR); + Clay_Color backgroundColor = labelConfig.color; + backgroundColor.a = 90; + CLAY_AUTO_ID({ .layout = { .padding = { 8, 8, 2, 2 } }, .backgroundColor = backgroundColor, .cornerRadius = CLAY_CORNER_RADIUS(4), .border = { .color = labelConfig.color, .width = { 1, 1, 1, 1, 0 } } }) { + CLAY_TEXT(CLAY_STRING("Color & Radius"), CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16 })); + } + // .backgroundColor + if (selectedItem->layoutElement->config.backgroundColor.a > 0) { + CLAY_TEXT(CLAY_STRING("Background Color"), infoTitleConfig); + Clay__RenderDebugViewColor(selectedItem->layoutElement->config.backgroundColor, infoTextConfig); + } + // .cornerRadius + if (!Clay__MemCmp((const char*)&selectedItem->layoutElement->config.cornerRadius, (const char*)&Clay__CornerRadius_DEFAULT, sizeof(Clay_CornerRadius))) { + CLAY_TEXT(CLAY_STRING("Corner Radius"), infoTitleConfig); + Clay__RenderDebugViewCornerRadius(selectedItem->layoutElement->config.cornerRadius, infoTextConfig); + } + // .overlayColor + if (selectedItem->layoutElement->config.overlayColor.a > 0) { + CLAY_TEXT(CLAY_STRING("Overlay Color"), infoTitleConfig); + Clay__RenderDebugViewColor(selectedItem->layoutElement->config.overlayColor, infoTextConfig); + } + } + if (selectedItem->layoutElement->config.aspectRatio.aspectRatio > 0) { + Clay_AspectRatioElementConfig *aspectRatioConfig = &selectedItem->layoutElement->config.aspectRatio; + CLAY(CLAY_ID("Clay__DebugViewElementInfoAspectRatioBody"), { .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_ASPECT); + CLAY_TEXT(CLAY_STRING("Aspect Ratio"), infoTitleConfig); + // Aspect Ratio + CLAY(CLAY_ID("Clay__DebugViewElementInfoAspectRatio"), { }) { + CLAY_TEXT(Clay__IntToString(aspectRatioConfig->aspectRatio), infoTextConfig); + CLAY_TEXT(CLAY_STRING("."), infoTextConfig); + float frac = aspectRatioConfig->aspectRatio - (int)(aspectRatioConfig->aspectRatio); + frac *= 100; + if ((int)frac < 10) { + CLAY_TEXT(CLAY_STRING("0"), infoTextConfig); + } + CLAY_TEXT(Clay__IntToString(frac), infoTextConfig); + } + } + } + if (selectedItem->layoutElement->config.image.imageData) { + Clay_ImageElementConfig *imageConfig = &selectedItem->layoutElement->config.image; + Clay_AspectRatioElementConfig aspectConfig = { 1 }; + if (selectedItem->layoutElement->config.aspectRatio.aspectRatio > 0) { + aspectConfig = selectedItem->layoutElement->config.aspectRatio; + } + CLAY(CLAY_ID("Clay__DebugViewElementInfoImageBody"), { .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_IMAGE); + // Image Preview + CLAY_TEXT(CLAY_STRING("Preview"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .sizing = { .width = CLAY_SIZING_GROW(64, 128), .height = CLAY_SIZING_GROW(64, 128) }}, .aspectRatio = aspectConfig, .image = *imageConfig }) {} + } + } + if (selectedItem->layoutElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE) { + Clay_FloatingElementConfig* floatingConfig = &selectedItem->layoutElement->config.floating; + CLAY_AUTO_ID({ .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_FLOATING); + // .offset + CLAY_TEXT(CLAY_STRING("Offset"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ x: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(floatingConfig->offset.x), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", y: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(floatingConfig->offset.y), infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + // .expand + CLAY_TEXT(CLAY_STRING("Expand"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ width: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(floatingConfig->expand.width), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", height: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(floatingConfig->expand.height), infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + // .zIndex + CLAY_TEXT(CLAY_STRING("z-index"), infoTitleConfig); + CLAY_TEXT(Clay__IntToString(floatingConfig->zIndex), infoTextConfig); + // .parentId + CLAY_TEXT(CLAY_STRING("Parent"), infoTitleConfig); + Clay_LayoutElementHashMapItem *hashItem = Clay__GetHashMapItem(floatingConfig->parentId); + CLAY_TEXT(hashItem->elementId.stringId, infoTextConfig); + // .attachPoints + CLAY_TEXT(CLAY_STRING("Attach Points"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ element: "), infoTextConfig); + Clay_String attachPointElement = CLAY_STRING("LEFT_TOP"); + if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_LEFT_CENTER) { + attachPointElement = CLAY_STRING("LEFT_CENTER"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_LEFT_BOTTOM) { + attachPointElement = CLAY_STRING("LEFT_BOTTOM"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_CENTER_TOP) { + attachPointElement = CLAY_STRING("CENTER_TOP"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_CENTER_CENTER) { + attachPointElement = CLAY_STRING("CENTER_CENTER"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_CENTER_BOTTOM) { + attachPointElement = CLAY_STRING("CENTER_BOTTOM"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_RIGHT_TOP) { + attachPointElement = CLAY_STRING("RIGHT_TOP"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_RIGHT_CENTER) { + attachPointElement = CLAY_STRING("RIGHT_CENTER"); + } else if (floatingConfig->attachPoints.element == CLAY_ATTACH_POINT_RIGHT_BOTTOM) { + attachPointElement = CLAY_STRING("RIGHT_BOTTOM"); + } + CLAY_TEXT(attachPointElement, infoTextConfig); + Clay_String attachPointParent = CLAY_STRING("LEFT_TOP"); + if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_LEFT_CENTER) { + attachPointParent = CLAY_STRING("LEFT_CENTER"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_LEFT_BOTTOM) { + attachPointParent = CLAY_STRING("LEFT_BOTTOM"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_CENTER_TOP) { + attachPointParent = CLAY_STRING("CENTER_TOP"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_CENTER_CENTER) { + attachPointParent = CLAY_STRING("CENTER_CENTER"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_CENTER_BOTTOM) { + attachPointParent = CLAY_STRING("CENTER_BOTTOM"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_RIGHT_TOP) { + attachPointParent = CLAY_STRING("RIGHT_TOP"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_RIGHT_CENTER) { + attachPointParent = CLAY_STRING("RIGHT_CENTER"); + } else if (floatingConfig->attachPoints.parent == CLAY_ATTACH_POINT_RIGHT_BOTTOM) { + attachPointParent = CLAY_STRING("RIGHT_BOTTOM"); + } + CLAY_TEXT(CLAY_STRING(", parent: "), infoTextConfig); + CLAY_TEXT(attachPointParent, infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + // .pointerCaptureMode + CLAY_TEXT(CLAY_STRING("Pointer Capture Mode"), infoTitleConfig); + Clay_String pointerCaptureMode = CLAY_STRING("NONE"); + if (floatingConfig->pointerCaptureMode == CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH) { + pointerCaptureMode = CLAY_STRING("PASSTHROUGH"); + } + CLAY_TEXT(pointerCaptureMode, infoTextConfig); + // .attachTo + CLAY_TEXT(CLAY_STRING("Attach To"), infoTitleConfig); + Clay_String attachTo = CLAY_STRING("NONE"); + if (floatingConfig->attachTo == CLAY_ATTACH_TO_PARENT) { + attachTo = CLAY_STRING("PARENT"); + } else if (floatingConfig->attachTo == CLAY_ATTACH_TO_ELEMENT_WITH_ID) { + attachTo = CLAY_STRING("ELEMENT_WITH_ID"); + } else if (floatingConfig->attachTo == CLAY_ATTACH_TO_ROOT) { + attachTo = CLAY_STRING("ROOT"); + } + CLAY_TEXT(attachTo, infoTextConfig); + // .clipTo + CLAY_TEXT(CLAY_STRING("Clip To"), infoTitleConfig); + Clay_String clipTo = CLAY_STRING("ATTACHED_PARENT"); + if (floatingConfig->clipTo == CLAY_CLIP_TO_NONE) { + clipTo = CLAY_STRING("NONE"); + } + CLAY_TEXT(clipTo, infoTextConfig); + } + } + Clay_ClipElementConfig *clipConfig = &selectedItem->layoutElement->config.clip; + if (clipConfig->horizontal || clipConfig->vertical) { + CLAY_AUTO_ID({ .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_CLIP); + // .vertical + CLAY_TEXT(CLAY_STRING("Vertical"), infoTitleConfig); + CLAY_TEXT(clipConfig->vertical ? CLAY_STRING("true") : CLAY_STRING("false") , infoTextConfig); + // .horizontal + CLAY_TEXT(CLAY_STRING("Horizontal"), infoTitleConfig); + CLAY_TEXT(clipConfig->horizontal ? CLAY_STRING("true") : CLAY_STRING("false") , infoTextConfig); + } + } + Clay_BorderElementConfig *borderConfig = &selectedItem->layoutElement->config.border; + if (Clay__BorderHasAnyWidth(borderConfig)) { + CLAY(CLAY_ID("Clay__DebugViewElementInfoBorderBody"), { .layout = { .padding = attributeConfigPadding, .childGap = 8, .layoutDirection = CLAY_TOP_TO_BOTTOM } }) { + Clay__DebugViewRenderElementConfigHeader(selectedItem->elementId.stringId, CLAY__ELEMENT_CONFIG_TYPE_BORDER); + CLAY_TEXT(CLAY_STRING("Border Widths"), infoTitleConfig); + CLAY_AUTO_ID({ .layout = { .layoutDirection = CLAY_LEFT_TO_RIGHT } }) { + CLAY_TEXT(CLAY_STRING("{ left: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(borderConfig->width.left), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", right: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(borderConfig->width.right), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", top: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(borderConfig->width.top), infoTextConfig); + CLAY_TEXT(CLAY_STRING(", bottom: "), infoTextConfig); + CLAY_TEXT(Clay__IntToString(borderConfig->width.bottom), infoTextConfig); + CLAY_TEXT(CLAY_STRING(" }"), infoTextConfig); + } + // .textColor + CLAY_TEXT(CLAY_STRING("Border Color"), infoTitleConfig); + Clay__RenderDebugViewColor(borderConfig->color, infoTextConfig); + } + } + } + } + } else { + CLAY(CLAY_ID("Clay__DebugViewWarningsScrollPane"), { .layout = { .sizing = {CLAY_SIZING_GROW(0), CLAY_SIZING_FIXED(300)}, .childGap = 6, .layoutDirection = CLAY_TOP_TO_BOTTOM }, .backgroundColor = CLAY__DEBUGVIEW_COLOR_2, .clip = { .horizontal = true, .vertical = true, .childOffset = Clay_GetScrollOffset() } }) { + Clay_TextElementConfig warningConfig = CLAY_TEXT_CONFIG({ .textColor = CLAY__DEBUGVIEW_COLOR_4, .fontSize = 16, .wrapMode = CLAY_TEXT_WRAP_NONE }); + CLAY(CLAY_ID("Clay__DebugViewWarningItemHeader"), { .layout = { .sizing = {.height = CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT)}, .padding = {CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 0, 0 }, .childGap = 8, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} } }) { + CLAY_TEXT(CLAY_STRING("Warnings"), warningConfig); + } + CLAY(CLAY_ID("Clay__DebugViewWarningsTopBorder"), { .layout = { .sizing = { .width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(1)} }, .backgroundColor = {200, 200, 200, 255} }) {} + int32_t previousWarningsLength = context->warnings.length; + for (int32_t i = 0; i < previousWarningsLength; i++) { + Clay__Warning warning = context->warnings.internalArray[i]; + CLAY(CLAY_IDI("Clay__DebugViewWarningItem", i), { .layout = { .sizing = {.height = CLAY_SIZING_FIXED(CLAY__DEBUGVIEW_ROW_HEIGHT)}, .padding = {CLAY__DEBUGVIEW_OUTER_PADDING, CLAY__DEBUGVIEW_OUTER_PADDING, 0, 0 }, .childGap = 8, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER} } }) { + CLAY_TEXT(warning.baseMessage, warningConfig); + if (warning.dynamicMessage.length > 0) { + CLAY_TEXT(warning.dynamicMessage, warningConfig); + } + } + } + } + } + } +} +#pragma endregion + +uint32_t Clay__debugViewWidth = 400; +Clay_Color Clay__debugViewHighlightColor = { 168, 66, 28, 100 }; + +Clay__WarningArray Clay__WarningArray_Allocate_Arena(int32_t capacity, Clay_Arena *arena) { + size_t totalSizeBytes = capacity * sizeof(Clay_String); + Clay__WarningArray array = {.capacity = capacity, .length = 0}; + uintptr_t nextAllocOffset = arena->nextAllocation + (64 - (arena->nextAllocation % 64)); + if (nextAllocOffset + totalSizeBytes <= arena->capacity) { + array.internalArray = (Clay__Warning*)((uintptr_t)arena->memory + (uintptr_t)nextAllocOffset); + arena->nextAllocation = nextAllocOffset + totalSizeBytes; + } + else { + Clay__currentContext->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay attempted to allocate memory in its arena, but ran out of capacity. Try increasing the capacity of the arena passed to Clay_Initialize()"), + .userData = Clay__currentContext->errorHandler.userData }); + } + return array; +} + +Clay__Warning *Clay__WarningArray_Add(Clay__WarningArray *array, Clay__Warning item) +{ + if (array->length < array->capacity) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__WARNING_DEFAULT; +} + +void* Clay__Array_Allocate_Arena(int32_t capacity, uint32_t itemSize, Clay_Arena *arena) +{ + size_t totalSizeBytes = capacity * itemSize; + uintptr_t nextAllocOffset = arena->nextAllocation + ((64 - (arena->nextAllocation % 64)) & 63); + if (nextAllocOffset + totalSizeBytes <= arena->capacity) { + arena->nextAllocation = nextAllocOffset + totalSizeBytes; + return (void*)((uintptr_t)arena->memory + (uintptr_t)nextAllocOffset); + } + else { + Clay__currentContext->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED, + .errorText = CLAY_STRING("Clay attempted to allocate memory in its arena, but ran out of capacity. Try increasing the capacity of the arena passed to Clay_Initialize()"), + .userData = Clay__currentContext->errorHandler.userData }); + } + return CLAY__NULL; +} + +bool Clay__Array_RangeCheck(int32_t index, int32_t length) +{ + if (index < length && index >= 0) { + return true; + } + Clay_Context* context = Clay_GetCurrentContext(); + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_INTERNAL_ERROR, + .errorText = CLAY_STRING("Clay attempted to make an out of bounds array access. This is an internal error and is likely a bug."), + .userData = context->errorHandler.userData }); + return false; +} + +bool Clay__Array_AddCapacityCheck(int32_t length, int32_t capacity) +{ + if (length < capacity) { + return true; + } + Clay_Context* context = Clay_GetCurrentContext(); + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_INTERNAL_ERROR, + .errorText = CLAY_STRING("Clay attempted to make an out of bounds array access. This is an internal error and is likely a bug."), + .userData = context->errorHandler.userData }); + return false; +} + +// PUBLIC API FROM HERE --------------------------------------- + +CLAY_WASM_EXPORT("Clay_MinMemorySize") +uint32_t Clay_MinMemorySize(void) { + Clay_Context fakeContext = { + .maxElementCount = Clay__defaultMaxElementCount, + .maxMeasureTextCacheWordCount = Clay__defaultMaxMeasureTextWordCacheCount, + .internalArena = { + .capacity = SIZE_MAX, + .memory = NULL, + } + }; + Clay_Context* currentContext = Clay_GetCurrentContext(); + if (currentContext) { + fakeContext.maxElementCount = currentContext->maxElementCount; + fakeContext.maxMeasureTextCacheWordCount = currentContext->maxMeasureTextCacheWordCount; + } + // Reserve space in the arena for the context, important for calculating min memory size correctly + Clay__Context_Allocate_Arena(&fakeContext.internalArena); + Clay__InitializePersistentMemory(&fakeContext); + Clay__InitializeEphemeralMemory(&fakeContext); + return (uint32_t)fakeContext.internalArena.nextAllocation + 128; +} + +CLAY_WASM_EXPORT("Clay_CreateArenaWithCapacityAndMemory") +Clay_Arena Clay_CreateArenaWithCapacityAndMemory(size_t capacity, void *memory) { + Clay_Arena arena = { + .capacity = capacity, + .memory = (char *)memory + }; + return arena; +} + +#ifndef CLAY_WASM +void Clay_SetMeasureTextFunction(Clay_Dimensions (*measureTextFunction)(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData), void *userData) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__MeasureText = measureTextFunction; + context->measureTextUserData = userData; +} +void Clay_SetQueryScrollOffsetFunction(Clay_Vector2 (*queryScrollOffsetFunction)(uint32_t elementId, void *userData), void *userData) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__QueryScrollOffset = queryScrollOffsetFunction; + context->queryScrollOffsetUserData = userData; +} +#endif + +CLAY_WASM_EXPORT("Clay_SetLayoutDimensions") +void Clay_SetLayoutDimensions(Clay_Dimensions dimensions) { + Clay_Context* context = Clay_GetCurrentContext(); + context->rootResizedLastFrame = !Clay__FloatEqual(context->layoutDimensions.width, dimensions.width) || !Clay__FloatEqual(context->layoutDimensions.height, dimensions.height); + context->layoutDimensions = dimensions; +} + +CLAY_WASM_EXPORT("Clay_SetLayoutDimensions") +Clay_Dimensions Clay_GetLayoutDimensions() { + Clay_Context* context = Clay_GetCurrentContext(); + return context->layoutDimensions; +} + +CLAY_WASM_EXPORT("Clay_SetPointerState") +void Clay_SetPointerState(Clay_Vector2 position, bool isPointerDown) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->booleanWarnings.maxElementsExceeded) { + return; + } + context->pointerInfo.position = position; + context->pointerOverIds.length = 0; + Clay__int32_tArray dfsBuffer = context->layoutElementChildrenBuffer; + for (int32_t rootIndex = context->layoutElementTreeRoots.length - 1; rootIndex >= 0; --rootIndex) { + dfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&context->layoutElementTreeRoots, rootIndex); + Clay__int32_tArray_Add(&dfsBuffer, (int32_t)root->layoutElementIndex); + context->treeNodeVisited.internalArray[0] = false; + bool found = false; + bool skipTree = false; + while (dfsBuffer.length > 0) { + if (context->treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + dfsBuffer.length--; + continue; + } + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + Clay_LayoutElement *currentElement = Clay_LayoutElementArray_Get(&context->layoutElements, Clay__int32_tArray_GetValue(&dfsBuffer, (int)dfsBuffer.length - 1)); + + Clay_LayoutElementHashMapItem *mapItem = Clay__GetHashMapItem(currentElement->id); // TODO think of a way around this, maybe the fact that it's essentially a binary tree limits the cost, but the worst case is not great + int32_t clipElementId = Clay__int32_tArray_GetValue(&context->layoutElementClipElementIds, (int32_t)(currentElement - context->layoutElements.internalArray)); + Clay_LayoutElementHashMapItem *clipItem = Clay__GetHashMapItem(clipElementId); + // This check skips mouse interactions for elements that are currently "exit transitioning" + if (mapItem && mapItem->generation > context->generation) { + // Conditionally skip mouse interactions on non-exit transitions, based on user config + if (!currentElement->isTextElement && currentElement->config.transition.handler) { + for (int I = 0; I < context->transitionDatas.length; ++I) { + Clay__TransitionDataInternal* data = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, I); + if (data->elementId == currentElement->id) { + if (currentElement->config.transition.interactionHandling == CLAY_TRANSITION_DISABLE_INTERACTIONS_WHILE_TRANSITIONING_POSITION) { + if (data->state == CLAY_TRANSITION_STATE_EXITING || data->state == CLAY_TRANSITION_STATE_ENTERING || ((data->activeProperties & CLAY_TRANSITION_PROPERTY_POSITION) && data->state == CLAY_TRANSITION_STATE_TRANSITIONING)) { + skipTree = true; + } + } else if (currentElement->config.transition.interactionHandling == CLAY_TRANSITION_ALLOW_INTERACTIONS_WHILE_TRANSITIONING_POSITION) { + if (data->state == CLAY_TRANSITION_STATE_EXITING) { + skipTree = true; + } + } + } + } + } + + if (skipTree) { + dfsBuffer.length--; + continue; + } + + Clay_BoundingBox elementBox = mapItem->boundingBox; + elementBox.x -= root->pointerOffset.x; + elementBox.y -= root->pointerOffset.y; + if ((Clay__PointIsInsideRect(position, elementBox)) && (clipElementId == 0 || (Clay__PointIsInsideRect(position, clipItem->boundingBox)) || context->externalScrollHandlingEnabled)) { + if (!skipTree) { + if (mapItem->onHoverFunction) { + mapItem->onHoverFunction(mapItem->elementId, context->pointerInfo, mapItem->hoverFunctionUserData); + } + Clay_ElementIdArray_Add(&context->pointerOverIds, mapItem->elementId); + } + found = true; + } + + for (int32_t i = currentElement->children.length - 1; i >= 0; --i) { + Clay__int32_tArray_Add(&dfsBuffer, currentElement->children.elements[i]); + context->treeNodeVisited.internalArray[dfsBuffer.length - 1] = false; // TODO needs to be ranged checked + } + } else { + dfsBuffer.length--; + } + } + + Clay_LayoutElement *rootElement = Clay_LayoutElementArray_Get(&context->layoutElements, root->layoutElementIndex); + if (found && rootElement->config.floating.attachTo != CLAY_ATTACH_TO_NONE && rootElement->config.floating.pointerCaptureMode == CLAY_POINTER_CAPTURE_MODE_CAPTURE) { + break; + } + } + + if (isPointerDown) { + if (context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) { + context->pointerInfo.state = CLAY_POINTER_DATA_PRESSED; + } else if (context->pointerInfo.state != CLAY_POINTER_DATA_PRESSED) { + context->pointerInfo.state = CLAY_POINTER_DATA_PRESSED_THIS_FRAME; + } + } else { + if (context->pointerInfo.state == CLAY_POINTER_DATA_RELEASED_THIS_FRAME) { + context->pointerInfo.state = CLAY_POINTER_DATA_RELEASED; + } else if (context->pointerInfo.state != CLAY_POINTER_DATA_RELEASED) { + context->pointerInfo.state = CLAY_POINTER_DATA_RELEASED_THIS_FRAME; + } + } +} + +CLAY_WASM_EXPORT("Clay_GetPointerState") +CLAY_DLL_EXPORT Clay_PointerData Clay_GetPointerState(void) { + return Clay_GetCurrentContext()->pointerInfo; +} + +CLAY_WASM_EXPORT("Clay_Initialize") +Clay_Context* Clay_Initialize(Clay_Arena arena, Clay_Dimensions layoutDimensions, Clay_ErrorHandler errorHandler) { + // Cacheline align memory passed in + uintptr_t baseOffset = 64 - ((uintptr_t)arena.memory % 64); + baseOffset = baseOffset == 64 ? 0 : baseOffset; + arena.memory += baseOffset; + Clay_Context *context = Clay__Context_Allocate_Arena(&arena); + if (context == NULL) return NULL; + // DEFAULTS + Clay_Context *oldContext = Clay_GetCurrentContext(); + *context = CLAY__INIT(Clay_Context) { + .maxElementCount = oldContext ? oldContext->maxElementCount : Clay__defaultMaxElementCount, + .maxMeasureTextCacheWordCount = oldContext ? oldContext->maxMeasureTextCacheWordCount : Clay__defaultMaxMeasureTextWordCacheCount, + .errorHandler = errorHandler.errorHandlerFunction ? errorHandler : CLAY__INIT(Clay_ErrorHandler) { Clay__ErrorHandlerFunctionDefault, 0 }, + .layoutDimensions = layoutDimensions, + .internalArena = arena, + }; + Clay_SetCurrentContext(context); + Clay__InitializePersistentMemory(context); + Clay__InitializeEphemeralMemory(context); + for (int32_t i = 0; i < context->layoutElementsHashMap.capacity; ++i) { + context->layoutElementsHashMap.internalArray[i] = -1; + } + for (int32_t i = 0; i < context->measureTextHashMap.capacity; ++i) { + context->measureTextHashMap.internalArray[i] = 0; + } + context->measureTextHashMapInternal.length = 1; // Reserve the 0 value to mean "no next element" + context->layoutDimensions = layoutDimensions; + return context; +} + +CLAY_WASM_EXPORT("Clay_GetCurrentContext") +Clay_Context* Clay_GetCurrentContext(void) { + return Clay__currentContext; +} + +CLAY_WASM_EXPORT("Clay_SetCurrentContext") +void Clay_SetCurrentContext(Clay_Context* context) { + Clay__currentContext = context; +} + +CLAY_WASM_EXPORT("Clay_GetScrollOffset") +Clay_Vector2 Clay_GetScrollOffset(void) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->booleanWarnings.maxElementsExceeded) { + return CLAY__INIT(Clay_Vector2) CLAY__DEFAULT_STRUCT; + } + Clay_LayoutElement *openLayoutElement = Clay__GetOpenLayoutElement(); + for (int32_t i = 0; i < context->scrollContainerDatas.length; i++) { + Clay__ScrollContainerDataInternal *mapping = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (mapping->elementId == openLayoutElement->id) { + return mapping->scrollPosition; + } + } + return CLAY__INIT(Clay_Vector2) CLAY__DEFAULT_STRUCT; +} + +CLAY_WASM_EXPORT("Clay_UpdateScrollContainers") +void Clay_UpdateScrollContainers(bool enableDragScrolling, Clay_Vector2 scrollDelta, float deltaTime) { + Clay_Context* context = Clay_GetCurrentContext(); + bool isPointerActive = enableDragScrolling && (context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED || context->pointerInfo.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME); + // Don't apply scroll events to ancestors of the inner element + int32_t highestPriorityElementIndex = -1; + Clay__ScrollContainerDataInternal *highestPriorityScrollData = CLAY__NULL; + for (int32_t i = 0; i < context->scrollContainerDatas.length; i++) { + Clay__ScrollContainerDataInternal *scrollData = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (!scrollData->openThisFrame) { + Clay__ScrollContainerDataInternalArray_RemoveSwapback(&context->scrollContainerDatas, i); + continue; + } + scrollData->openThisFrame = false; + Clay_LayoutElementHashMapItem *hashMapItem = Clay__GetHashMapItem(scrollData->elementId); + // Element isn't rendered this frame but scroll offset has been retained + if (!hashMapItem) { + Clay__ScrollContainerDataInternalArray_RemoveSwapback(&context->scrollContainerDatas, i); + continue; + } + + // Touch / click is released + if (!isPointerActive && scrollData->pointerScrollActive) { + float xDiff = scrollData->scrollPosition.x - scrollData->scrollOrigin.x; + if (xDiff < -10 || xDiff > 10) { + scrollData->scrollMomentum.x = (scrollData->scrollPosition.x - scrollData->scrollOrigin.x) / (scrollData->momentumTime * 25); + } + float yDiff = scrollData->scrollPosition.y - scrollData->scrollOrigin.y; + if (yDiff < -10 || yDiff > 10) { + scrollData->scrollMomentum.y = (scrollData->scrollPosition.y - scrollData->scrollOrigin.y) / (scrollData->momentumTime * 25); + } + scrollData->pointerScrollActive = false; + + scrollData->pointerOrigin = CLAY__INIT(Clay_Vector2){0,0}; + scrollData->scrollOrigin = CLAY__INIT(Clay_Vector2){0,0}; + scrollData->momentumTime = 0; + } + + // Apply existing momentum + scrollData->scrollPosition.x += scrollData->scrollMomentum.x; + scrollData->scrollMomentum.x *= 0.95f; + bool scrollOccurred = scrollDelta.x != 0 || scrollDelta.y != 0; + if ((scrollData->scrollMomentum.x > -0.1f && scrollData->scrollMomentum.x < 0.1f) || scrollOccurred) { + scrollData->scrollMomentum.x = 0; + } + scrollData->scrollPosition.x = CLAY__MIN(CLAY__MAX(scrollData->scrollPosition.x, -(CLAY__MAX(scrollData->contentSize.width - scrollData->layoutElement->dimensions.width, 0))), 0); + + scrollData->scrollPosition.y += scrollData->scrollMomentum.y; + scrollData->scrollMomentum.y *= 0.95f; + if ((scrollData->scrollMomentum.y > -0.1f && scrollData->scrollMomentum.y < 0.1f) || scrollOccurred) { + scrollData->scrollMomentum.y = 0; + } + scrollData->scrollPosition.y = CLAY__MIN(CLAY__MAX(scrollData->scrollPosition.y, -(CLAY__MAX(scrollData->contentSize.height - scrollData->layoutElement->dimensions.height, 0))), 0); + + for (int32_t j = 0; j < context->pointerOverIds.length; ++j) { // TODO n & m are small here but this being n*m gives me the creeps + if (scrollData->layoutElement->id == Clay_ElementIdArray_Get(&context->pointerOverIds, j)->id) { + highestPriorityElementIndex = j; + highestPriorityScrollData = scrollData; + } + } + } + + if (highestPriorityElementIndex > -1 && highestPriorityScrollData) { + Clay_LayoutElement *scrollElement = highestPriorityScrollData->layoutElement; + Clay_ClipElementConfig *clipConfig = &scrollElement->config.clip; + bool canScrollVertically = clipConfig->vertical && highestPriorityScrollData->contentSize.height > scrollElement->dimensions.height; + bool canScrollHorizontally = clipConfig->horizontal && highestPriorityScrollData->contentSize.width > scrollElement->dimensions.width; + // Handle wheel scroll + if (canScrollVertically) { + highestPriorityScrollData->scrollPosition.y = highestPriorityScrollData->scrollPosition.y + scrollDelta.y * 10; + } + if (canScrollHorizontally) { + highestPriorityScrollData->scrollPosition.x = highestPriorityScrollData->scrollPosition.x + scrollDelta.x * 10; + } + // Handle click / touch scroll + if (isPointerActive) { + highestPriorityScrollData->scrollMomentum = CLAY__INIT(Clay_Vector2)CLAY__DEFAULT_STRUCT; + if (!highestPriorityScrollData->pointerScrollActive) { + highestPriorityScrollData->pointerOrigin = context->pointerInfo.position; + highestPriorityScrollData->scrollOrigin = highestPriorityScrollData->scrollPosition; + highestPriorityScrollData->pointerScrollActive = true; + } else { + float scrollDeltaX = 0, scrollDeltaY = 0; + if (canScrollHorizontally) { + float oldXScrollPosition = highestPriorityScrollData->scrollPosition.x; + highestPriorityScrollData->scrollPosition.x = highestPriorityScrollData->scrollOrigin.x + (context->pointerInfo.position.x - highestPriorityScrollData->pointerOrigin.x); + highestPriorityScrollData->scrollPosition.x = CLAY__MAX(CLAY__MIN(highestPriorityScrollData->scrollPosition.x, 0), -(highestPriorityScrollData->contentSize.width - highestPriorityScrollData->boundingBox.width)); + scrollDeltaX = highestPriorityScrollData->scrollPosition.x - oldXScrollPosition; + } + if (canScrollVertically) { + float oldYScrollPosition = highestPriorityScrollData->scrollPosition.y; + highestPriorityScrollData->scrollPosition.y = highestPriorityScrollData->scrollOrigin.y + (context->pointerInfo.position.y - highestPriorityScrollData->pointerOrigin.y); + highestPriorityScrollData->scrollPosition.y = CLAY__MAX(CLAY__MIN(highestPriorityScrollData->scrollPosition.y, 0), -(highestPriorityScrollData->contentSize.height - highestPriorityScrollData->boundingBox.height)); + scrollDeltaY = highestPriorityScrollData->scrollPosition.y - oldYScrollPosition; + } + if (scrollDeltaX > -0.1f && scrollDeltaX < 0.1f && scrollDeltaY > -0.1f && scrollDeltaY < 0.1f && highestPriorityScrollData->momentumTime > 0.15f) { + highestPriorityScrollData->momentumTime = 0; + highestPriorityScrollData->pointerOrigin = context->pointerInfo.position; + highestPriorityScrollData->scrollOrigin = highestPriorityScrollData->scrollPosition; + } else { + highestPriorityScrollData->momentumTime += deltaTime; + } + } + } + // Clamp any changes to scroll position to the maximum size of the contents + if (canScrollVertically) { + highestPriorityScrollData->scrollPosition.y = CLAY__MAX(CLAY__MIN(highestPriorityScrollData->scrollPosition.y, 0), -(highestPriorityScrollData->contentSize.height - scrollElement->dimensions.height)); + } + if (canScrollHorizontally) { + highestPriorityScrollData->scrollPosition.x = CLAY__MAX(CLAY__MIN(highestPriorityScrollData->scrollPosition.x, 0), -(highestPriorityScrollData->contentSize.width - scrollElement->dimensions.width)); + } + } +} + +CLAY_WASM_EXPORT("Clay_BeginLayout") +void Clay_BeginLayout(void) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__InitializeEphemeralMemory(context); + context->generation++; + context->dynamicElementIndex = 0; + // Set up the root container that covers the entire window + Clay_Dimensions rootDimensions = {context->layoutDimensions.width, context->layoutDimensions.height}; + if (context->debugModeEnabled) { + rootDimensions.width -= (float)Clay__debugViewWidth; + } + context->booleanWarnings = CLAY__INIT(Clay_BooleanWarnings) CLAY__DEFAULT_STRUCT; + Clay__OpenElementWithId(CLAY_ID("Clay__RootContainer")); + Clay__ConfigureOpenElement(CLAY__INIT(Clay_ElementDeclaration) { + .layout = { .sizing = {CLAY_SIZING_FIXED((rootDimensions.width)), CLAY_SIZING_FIXED(rootDimensions.height)} } + }); + Clay__int32_tArray_Add(&context->openLayoutElementStack, 0); + Clay__LayoutElementTreeRootArray_Add(&context->layoutElementTreeRoots, CLAY__INIT(Clay__LayoutElementTreeRoot) { .layoutElementIndex = 0 }); +} + +void Clay__CloneElementsWithExitTransition() { + Clay_Context* context = Clay_GetCurrentContext(); + int32_t nextIndex = context->layoutElements.capacity - 1; + int32_t nextChildIndex = context->layoutElementChildren.capacity - 1; + + for (int i = 0; i < context->transitionDatas.length; ++i) { + Clay__TransitionDataInternal *data = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, i); + Clay_TransitionElementConfig* config = &data->elementThisFrame->config.transition; + if (data->transitionOut) { + Clay__int32_tArray bfsBuffer = context->openLayoutElementStack; + bfsBuffer.length = 0; + Clay_LayoutElement* newElement = Clay_LayoutElementArray_Set_DontTouchLength(&context->layoutElements, nextIndex, *data->elementThisFrame); + Clay__StringArray_Set_DontTouchLength(&context->layoutElementIdStrings, nextIndex, *Clay__StringArray_GetCheckCapacity(&context->layoutElementIdStrings, data->elementThisFrame - context->layoutElements.internalArray)); + Clay__int32_tArray_Add(&bfsBuffer, nextIndex); + data->elementThisFrame = newElement; + nextIndex--; + + int32_t bufferIndex = 0; + while(bufferIndex < bfsBuffer.length) { + Clay_LayoutElement *layoutElement = Clay_LayoutElementArray_GetCheckCapacity(&context->layoutElements, Clay__int32_tArray_GetValue(&bfsBuffer, bufferIndex)); + bufferIndex++; + for (int j = layoutElement->children.length - 1; j >= 0; --j) { + Clay_LayoutElement* childElement = Clay_LayoutElementArray_GetCheckCapacity(&context->layoutElements, layoutElement->children.elements[j]); + Clay__int32_tArray_Add(&bfsBuffer, nextIndex); + Clay_LayoutElement* newChildElement = Clay_LayoutElementArray_Set_DontTouchLength(&context->layoutElements, nextIndex, *childElement); + Clay__StringArray_Set_DontTouchLength(&context->layoutElementIdStrings, nextIndex, *Clay__StringArray_GetCheckCapacity(&context->layoutElementIdStrings, childElement - context->layoutElements.internalArray)); + Clay__int32_tArray_Set_DontTouchLength(&context->layoutElementChildren, nextChildIndex, nextIndex); + nextIndex--; + nextChildIndex--; + } + layoutElement->children.elements = &context->layoutElementChildren.internalArray[nextChildIndex + 1]; + } + } + } +}; + +void Clay_ApplyTransitionedPropertiesToElement(Clay_LayoutElement* currentElement, Clay_TransitionProperty properties, Clay_TransitionData currentTransitionData, Clay_BoundingBox* boundingBox, bool reparented) { + if (properties & CLAY_TRANSITION_PROPERTY_WIDTH) { + if (!reparented) { + currentElement->dimensions.width = currentTransitionData.boundingBox.width; + currentElement->config.layout.sizing.width = CLAY_SIZING_FIXED(currentTransitionData.boundingBox.width); + } else { + boundingBox->width = currentTransitionData.boundingBox.width; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_HEIGHT) { + if (!reparented) { + currentElement->dimensions.height = currentTransitionData.boundingBox.height; + currentElement->config.layout.sizing.height = CLAY_SIZING_FIXED(currentTransitionData.boundingBox.height); + } else { + boundingBox->height = currentTransitionData.boundingBox.height; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_X) { + boundingBox->x = currentTransitionData.boundingBox.x; + } + if (properties & CLAY_TRANSITION_PROPERTY_Y) { + boundingBox->y = currentTransitionData.boundingBox.y; + } + if (properties & CLAY_TRANSITION_PROPERTY_OVERLAY_COLOR) { + currentElement->config.overlayColor = currentTransitionData.overlayColor; + } + if (properties & CLAY_TRANSITION_PROPERTY_BACKGROUND_COLOR) { + currentElement->config.backgroundColor = currentTransitionData.backgroundColor; + } + if (properties & CLAY_TRANSITION_PROPERTY_BORDER_COLOR) { + currentElement->config.border.color = currentTransitionData.borderColor; + } + if (properties & CLAY_TRANSITION_PROPERTY_BORDER_WIDTH) { + currentElement->config.border.width = currentTransitionData.borderWidth; + } +} + +CLAY_WASM_EXPORT("Clay_EndLayout") +Clay_RenderCommandArray Clay_EndLayout(float deltaTime) { + Clay_Context* context = Clay_GetCurrentContext(); + Clay__CloseElement(); + + if (context->openLayoutElementStack.length > 1) { + context->errorHandler.errorHandlerFunction(CLAY__INIT(Clay_ErrorData) { + .errorType = CLAY_ERROR_TYPE_UNBALANCED_OPEN_CLOSE, + .errorText = CLAY_STRING("There were still open layout elements when EndLayout was called. This results from an unequal number of calls to Clay__OpenElement and Clay__CloseElement."), + .userData = context->errorHandler.userData }); + } + + // Prune non exiting transitions + for (int i = 0; i < context->transitionDatas.length; ++i) { + Clay__TransitionDataInternal *data = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, i); + Clay_LayoutElementHashMapItem *hashMapItem = Clay__GetHashMapItem(data->elementId); + // Transition element exited and doesn't have an exit handler defined + // Or, the user deleted the transition handler from one frame to the next + if (!data->transitionOut && (hashMapItem->generation <= context->generation || !hashMapItem->layoutElement->config.transition.handler)) { + Clay__TransitionDataInternalArray_RemoveSwapback(&context->transitionDatas, i); + i--; + continue; + } + } + + Clay__int32_tArray elementIdsToRemoveTransitions = context->reusableElementIndexBuffer; + elementIdsToRemoveTransitions.length = 0; + + for (int i = 0; i < context->transitionDatas.length; ++i) { + Clay__TransitionDataInternal *data = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, i); + Clay_LayoutElementHashMapItem *hashMapItem = Clay__GetHashMapItem(data->elementId); + // This might seems strange - can't we just look up the element itself, and check the config to see whether it has an exit transition defined? + // That would work fine if the element actually had an exit transition in the first place. If it doesn't have an exit transition defined, the element + // will have simply disappeared completely at this point, and there will be no element through which to access the config. + if (data->transitionOut) { + Clay_TransitionElementConfig* config = &data->elementThisFrame->config.transition; + // Element wasn't found this frame - either delete transition data or transition out + if (hashMapItem->generation <= context->generation) { + Clay_LayoutElementHashMapItem *parentHashMapItem = Clay__GetHashMapItem(data->parentId); + // Don't exit transition if the parent has also exited and SKIP_WHEN_PARENT_EXITS is used + if (config->exit.trigger == CLAY_TRANSITION_EXIT_TRIGGER_WHEN_PARENT_EXITS || !parentHashMapItem || parentHashMapItem->generation > context->generation) { + // This if only runs one single time when the element first starts exiting + if (data->state != CLAY_TRANSITION_STATE_EXITING) { + if (parentHashMapItem->generation <= context->generation) { + data->elementThisFrame->config.floating.attachTo = CLAY_ATTACH_TO_ROOT; + data->elementThisFrame->config.floating.offset = CLAY__INIT(Clay_Vector2) { hashMapItem->boundingBox.x, hashMapItem->boundingBox.y }; + data->elementThisFrame->config.floating.parentId = Clay__HashString(CLAY_STRING("Clay__RootContainer"), 0).id; + } + hashMapItem->appearedThisFrame = false; + data->elementThisFrame->exiting = true; + data->elementThisFrame->config.layout.sizing.width = CLAY_SIZING_FIXED(data->elementThisFrame->dimensions.width); + data->elementThisFrame->config.layout.sizing.height = CLAY_SIZING_FIXED(data->elementThisFrame->dimensions.height); + data->state = CLAY_TRANSITION_STATE_EXITING; + data->activeProperties = config->properties; + data->elapsedTime = 0; + data->targetState = config->exit.setFinalState(data->targetState, config->properties); + } + + // Below this line runs every frame while element is exiting ----------- + + // Clone the entire subtree back into the main UI layout tree + Clay__int32_tArray bfsBuffer = context->openLayoutElementStack; + bfsBuffer.length = 0; + data->elementThisFrame = Clay_LayoutElementArray_Add(&context->layoutElements, *data->elementThisFrame); + int32_t exitingElementIndex = data->elementThisFrame - context->layoutElements.internalArray; + Clay__StringArray_Add(&context->layoutElementIdStrings, *Clay__StringArray_GetCheckCapacity(&context->layoutElementIdStrings, exitingElementIndex)); + Clay__int32_tArray_Add(&context->layoutElementClipElementIds, *Clay__int32_tArray_GetCheckCapacity(&context->layoutElementClipElementIds, exitingElementIndex)); + Clay__int32_tArray_Add(&bfsBuffer, exitingElementIndex); + int32_t bufferIndex = 0; + while (bufferIndex < bfsBuffer.length) { + Clay_LayoutElement *layoutElement = Clay_LayoutElementArray_GetCheckCapacity(&context->layoutElements, Clay__int32_tArray_GetValue(&bfsBuffer, bufferIndex)); + Clay_LayoutElementHashMapItem* bfsMapItem = Clay__GetHashMapItem(layoutElement->id); + // Children of exiting elements may have been moved elsewhere in the layout, this prevents a duplicate ID error if they still exist. + if (bfsMapItem->generation <= context->generation) { + Clay__AddHashMapItem(CLAY__INIT(Clay_ElementId){ layoutElement->id }, layoutElement); + int32_t firstChildSlot = context->layoutElementChildren.length; + uint16_t newChildrenLength = layoutElement->children.length; + for (int j = 0; j < layoutElement->children.length; ++j) { + Clay_LayoutElement* childElement = Clay_LayoutElementArray_GetCheckCapacity(&context->layoutElements, layoutElement->children.elements[j]); + Clay_LayoutElementHashMapItem* childMapItem = Clay__GetHashMapItem(childElement->id); + if (childMapItem->generation <= context->generation) { + // Remove any nested transitions inside exiting trees + if (!childElement->isTextElement && childElement->config.transition.handler) { + Clay__int32_tArray_Add(&elementIdsToRemoveTransitions, childElement->id); + } + int32_t childElementIndex = childElement - context->layoutElements.internalArray; + Clay_LayoutElement* newChildElement = Clay_LayoutElementArray_Add(&context->layoutElements, *childElement); + Clay__StringArray_Add(&context->layoutElementIdStrings, *Clay__StringArray_GetCheckCapacity(&context->layoutElementIdStrings, childElementIndex)); + Clay__int32_tArray_Add(&context->layoutElementClipElementIds, *Clay__int32_tArray_GetCheckCapacity(&context->layoutElementClipElementIds, childElementIndex)); + Clay__int32_tArray_Add(&bfsBuffer, context->layoutElements.length - 1); + if (newChildElement->isTextElement) { + newChildElement->textElementData.wrappedLines.length = 0; + } + Clay__int32_tArray_Add(&context->layoutElementChildren, context->layoutElements.length - 1); + } else { + newChildrenLength--; + } + } + layoutElement->children = CLAY__INIT(Clay__LayoutElementChildren) { + .elements = &context->layoutElementChildren.internalArray[firstChildSlot], + .length = newChildrenLength, + }; + } + bufferIndex++; + } + hashMapItem->layoutElement = data->elementThisFrame; + + // Reattach the inserted subtree to its previous parent if it still exists + // and the exiting element is not floating + Clay_FloatingElementConfig* floatingConfig = &hashMapItem->layoutElement->config.floating; + if (parentHashMapItem->generation > context->generation && floatingConfig->attachTo == CLAY_ATTACH_TO_NONE) { + Clay_LayoutElement *parentElement = parentHashMapItem->layoutElement; + int32_t newChildrenStartIndex = context->layoutElementChildren.length; + bool found = false; + if (config->exit.siblingOrdering == CLAY_EXIT_TRANSITION_ORDERING_UNDERNEATH_SIBLINGS) { + Clay__int32_tArray_Add(&context->layoutElementChildren, exitingElementIndex); + found = true; + } + for (int j = 0; j < parentElement->children.length; ++j) { + if (config->exit.siblingOrdering == CLAY_EXIT_TRANSITION_ORDERING_NATURAL_ORDER && j == data->siblingIndex) { + Clay__int32_tArray_Add(&context->layoutElementChildren, exitingElementIndex); + found = true; + } + Clay__int32_tArray_Add(&context->layoutElementChildren, parentElement->children.elements[j]); + } + if (!found) { + Clay__int32_tArray_Add(&context->layoutElementChildren, exitingElementIndex); + } + parentElement->children.length++; + parentElement->children.elements = &context->layoutElementChildren.internalArray[newChildrenStartIndex]; + // Otherwise, create the tree root for the floating element (needs to be created every frame) + } else { + Clay__LayoutElementTreeRootArray_Add(&context->layoutElementTreeRoots, CLAY__INIT(Clay__LayoutElementTreeRoot) { + .layoutElementIndex = (int32_t)(data->elementThisFrame - context->layoutElements.internalArray), + .parentId = floatingConfig->parentId, + .zIndex = floatingConfig->zIndex, + }); + } + // Parent exited, just delete child without exit transition + } else { + Clay__TransitionDataInternalArray_RemoveSwapback(&context->transitionDatas, i); + i--; + continue; + } + } + } + } + + for (int i = 0; i < elementIdsToRemoveTransitions.length; ++i) { + for (int j = 0; j < context->transitionDatas.length; ++j) { + if (Clay__TransitionDataInternalArray_Get(&context->transitionDatas, j)->elementId == Clay__int32_tArray_GetValue(&elementIdsToRemoveTransitions, i)) { + Clay__TransitionDataInternalArray_RemoveSwapback(&context->transitionDatas, j); + break; + } + } + } + + if (context->booleanWarnings.maxElementsExceeded) { + Clay_String message; + message = CLAY_STRING("Clay Error: Layout elements exceeded Clay__maxElementCount"); + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand ) { + .boundingBox = { context->layoutDimensions.width / 2 - 59 * 4, context->layoutDimensions.height / 2, 0, 0 }, + .renderData = { .text = { .stringContents = CLAY__INIT(Clay_StringSlice) { .length = message.length, .chars = message.chars, .baseChars = message.chars }, .textColor = {255, 0, 0, 255}, .fontSize = 16 } }, + .commandType = CLAY_RENDER_COMMAND_TYPE_TEXT + }); + } else { + if (context->transitionDatas.length > 0) { + Clay__CalculateFinalLayout(deltaTime, false, false); + + for (int i = 0; i < context->transitionDatas.length; ++i) { + Clay__TransitionDataInternal* transitionData = Clay__TransitionDataInternalArray_Get(&context->transitionDatas, i); + Clay_LayoutElement* currentElement = transitionData->elementThisFrame; + Clay_LayoutElementHashMapItem* mapItem = Clay__GetHashMapItem(transitionData->elementId); + Clay_LayoutElementHashMapItem* parentMapItem = Clay__GetHashMapItem(transitionData->parentId); + Clay_TransitionData targetState = transitionData->targetState; + if (transitionData->state != CLAY_TRANSITION_STATE_EXITING) { + targetState = CLAY__INIT(Clay_TransitionData) { + mapItem->boundingBox, + currentElement->config.backgroundColor, + currentElement->config.overlayColor, + currentElement->config.border.color, + currentElement->config.border.width, + }; + } + Clay_TransitionData oldTargetState = transitionData->targetState; + transitionData->targetState = targetState; + if (mapItem->appearedThisFrame) { + if (currentElement->config.transition.enter.setInitialState && !(parentMapItem->appearedThisFrame && currentElement->config.transition.enter.trigger == CLAY_TRANSITION_ENTER_SKIP_ON_FIRST_PARENT_FRAME)) { + transitionData->state = CLAY_TRANSITION_STATE_ENTERING; + transitionData->initialState = currentElement->config.transition.enter.setInitialState(transitionData->targetState, currentElement->config.transition.properties); + transitionData->currentState = transitionData->initialState; + transitionData->activeProperties = currentElement->config.transition.properties; + Clay_ApplyTransitionedPropertiesToElement(currentElement, currentElement->config.transition.properties, transitionData->initialState, &mapItem->boundingBox, transitionData->reparented); + } else { + transitionData->initialState = targetState; + transitionData->currentState = targetState; + transitionData->activeProperties = CLAY_TRANSITION_PROPERTY_NONE; + } + } else { + if (transitionData->state != CLAY_TRANSITION_STATE_EXITING) { + Clay_Vector2 parentScrollOffset = parentMapItem->layoutElement->config.clip.childOffset; + Clay_Vector2 newRelativePosition = { + mapItem->boundingBox.x - parentMapItem->boundingBox.x - parentScrollOffset.x, + mapItem->boundingBox.y - parentMapItem->boundingBox.y - parentScrollOffset.y, + }; + Clay_Vector2 oldRelativePosition = transitionData->oldParentRelativePosition; + transitionData->oldParentRelativePosition = newRelativePosition; + Clay_TransitionProperty properties = currentElement->config.transition.properties; + int32_t newActiveProperties = CLAY_TRANSITION_PROPERTY_NONE; + if (properties & CLAY_TRANSITION_PROPERTY_X) { + // Don't trigger a transition if... + if ( + // The element's absolute position didn't change + !Clay__FloatEqual(oldTargetState.boundingBox.x, targetState.boundingBox.x) + // The element is still in the same parent container, and it's parent-relative position didn't change (parent moved) + && (!(Clay__FloatEqual(oldRelativePosition.x, newRelativePosition.x)) || transitionData->reparented) + // The position changed was triggered by the outer window resizing + && !context->rootResizedLastFrame + ) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_X; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_Y) { + // See extended comments above in PROPERTY_X for explanation + if (!Clay__FloatEqual(oldTargetState.boundingBox.y, targetState.boundingBox.y) && (!(Clay__FloatEqual(oldRelativePosition.y, newRelativePosition.y)) || transitionData->reparented) && !context->rootResizedLastFrame) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_Y; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_WIDTH) { + if (!Clay__FloatEqual(oldTargetState.boundingBox.width, targetState.boundingBox.width) && !context->rootResizedLastFrame) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_WIDTH; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_HEIGHT) { + if (!Clay__FloatEqual(oldTargetState.boundingBox.height, targetState.boundingBox.height) && !context->rootResizedLastFrame) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_HEIGHT; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_BACKGROUND_COLOR) { + if (!Clay__MemCmp((char *) &oldTargetState.backgroundColor, (char *)&targetState.backgroundColor, sizeof(Clay_Color))) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_BACKGROUND_COLOR; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_OVERLAY_COLOR) { + if (!Clay__MemCmp((char *) &oldTargetState.overlayColor, (char *)&targetState.overlayColor, sizeof(Clay_Color))) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_OVERLAY_COLOR; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_BORDER_COLOR) { + if (!Clay__MemCmp((char *) &oldTargetState.borderColor, (char *)&targetState.borderColor, sizeof(Clay_Color))) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_BORDER_COLOR; + } + } + if (properties & CLAY_TRANSITION_PROPERTY_BORDER_WIDTH) { + if (!Clay__MemCmp((char *) &oldTargetState.borderWidth, (char *)&targetState.borderWidth, sizeof(Clay_BorderWidth))) { + newActiveProperties |= CLAY_TRANSITION_PROPERTY_BORDER_WIDTH; + } + } + + if (newActiveProperties != 0) { + transitionData->elapsedTime = 0; + transitionData->initialState = transitionData->currentState; + transitionData->state = CLAY_TRANSITION_STATE_TRANSITIONING; + transitionData->activeProperties = (Clay_TransitionProperty)(transitionData->activeProperties | newActiveProperties); + } + } + + if (transitionData->state == CLAY_TRANSITION_STATE_IDLE) { + transitionData->initialState = targetState; + transitionData->currentState = targetState; + transitionData->targetState = targetState; + transitionData->activeProperties = CLAY_TRANSITION_PROPERTY_NONE; + } else { + bool transitionComplete = true; + transitionComplete = currentElement->config.transition.handler(CLAY__INIT(Clay_TransitionCallbackArguments) { + transitionData->state, + transitionData->initialState, + &transitionData->currentState, + targetState, + transitionData->elapsedTime, + currentElement->config.transition.duration, + transitionData->activeProperties + }); + + Clay_ApplyTransitionedPropertiesToElement(currentElement, transitionData->activeProperties, transitionData->currentState, &mapItem->boundingBox, transitionData->reparented); + transitionData->elapsedTime += deltaTime; + + if (transitionComplete) { + if (transitionData->state == CLAY_TRANSITION_STATE_ENTERING || transitionData->state == CLAY_TRANSITION_STATE_TRANSITIONING) {transitionData->state = CLAY_TRANSITION_STATE_IDLE; + transitionData->elapsedTime = 0; + transitionData->reparented = false; + transitionData->activeProperties = CLAY_TRANSITION_PROPERTY_NONE; + } else if (transitionData->state == CLAY_TRANSITION_STATE_EXITING) { + Clay__TransitionDataInternalArray_RemoveSwapback(&context->transitionDatas, i); + } + } + } + } + } + + if (context->debugModeEnabled) { + context->warningsEnabled = false; + Clay__RenderDebugView(); + context->warningsEnabled = true; + } + + if (context->booleanWarnings.maxElementsExceeded) { + Clay_String message; + message = CLAY_STRING("Clay Error: Debug view caused layout element count to exceed Clay__maxElementCount"); + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand ) { + .boundingBox = { context->layoutDimensions.width / 2 - 59 * 4, context->layoutDimensions.height / 2, 0, 0 }, + .renderData = { .text = { .stringContents = CLAY__INIT(Clay_StringSlice) { .length = message.length, .chars = message.chars, .baseChars = message.chars }, .textColor = {255, 0, 0, 255}, .fontSize = 16 } }, + .commandType = CLAY_RENDER_COMMAND_TYPE_TEXT + }); + } else { + Clay__CalculateFinalLayout(deltaTime, true, true); + Clay__CloneElementsWithExitTransition(); + } + } else { + if (context->debugModeEnabled) { + context->warningsEnabled = false; + Clay__RenderDebugView(); + context->warningsEnabled = true; + } + + if (context->booleanWarnings.maxElementsExceeded) { + Clay_String message; + message = CLAY_STRING("Clay Error: Debug view caused layout element count to exceed Clay__maxElementCount"); + Clay__AddRenderCommand(CLAY__INIT(Clay_RenderCommand ) { + .boundingBox = { context->layoutDimensions.width / 2 - 59 * 4, context->layoutDimensions.height / 2, 0, 0 }, + .renderData = { .text = { .stringContents = CLAY__INIT(Clay_StringSlice) { .length = message.length, .chars = message.chars, .baseChars = message.chars }, .textColor = {255, 0, 0, 255}, .fontSize = 16 } }, + .commandType = CLAY_RENDER_COMMAND_TYPE_TEXT + }); + } else { + Clay__CalculateFinalLayout(deltaTime, false, true); + } + } + } + + for (int i = 0; i < context->layoutElementsHashMap.capacity; ++i) { + int32_t currentElementIndex = context->layoutElementsHashMap.internalArray[i]; + int32_t previousElementIndex = -1; + while (currentElementIndex != -1) { + Clay_LayoutElementHashMapItem* currentItem = Clay__LayoutElementHashMapItemArray_Get(&context->layoutElementsHashMapInternal, currentElementIndex); + int32_t nextIndex = currentItem->nextIndex; + // Needs to be pruned + if (currentItem->generation <= context->generation) { + // Delete the underlying item and add it to the freelist + Clay__LayoutElementHashMapItemArray_Set(&context->layoutElementsHashMapInternal, currentElementIndex, CLAY__INIT(Clay_LayoutElementHashMapItem) { .nextIndex = -1 }); + Clay__int32_tArray_Add(&context->layoutElementsHashMapFreeList, currentElementIndex); + // If it's the very top of the bucket, rewrite the first bucket pointer + if (previousElementIndex == -1) { + Clay__int32_tArray_Set(&context->layoutElementsHashMap, i, nextIndex); + currentElementIndex = nextIndex; + previousElementIndex = -1; + } else { + // Rewrite previous pointer + Clay_LayoutElementHashMapItem* previousItem = Clay__LayoutElementHashMapItemArray_Get(&context->layoutElementsHashMapInternal, previousElementIndex); + previousItem->nextIndex = nextIndex; + currentElementIndex = nextIndex; + } + } else { + previousElementIndex = currentElementIndex; + currentElementIndex = nextIndex; + } + } + } + + return context->renderCommands; +} + +CLAY_WASM_EXPORT("Clay_GetOpenElementId") +uint32_t Clay_GetOpenElementId(void) { + return Clay__GetOpenLayoutElement()->id; +} + +CLAY_WASM_EXPORT("Clay_GetElementId") +Clay_ElementId Clay_GetElementId(Clay_String idString) { + return Clay__HashString(idString, 0); +} + +CLAY_WASM_EXPORT("Clay_GetElementIdWithIndex") +Clay_ElementId Clay_GetElementIdWithIndex(Clay_String idString, uint32_t index) { + return Clay__HashStringWithOffset(idString, index, 0); +} + +bool Clay_Hovered(void) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->booleanWarnings.maxElementsExceeded) { + return false; + } + Clay_LayoutElement *openLayoutElement = Clay__GetOpenLayoutElement(); + for (int32_t i = 0; i < context->pointerOverIds.length; ++i) { + if (Clay_ElementIdArray_Get(&context->pointerOverIds, i)->id == openLayoutElement->id) { + return true; + } + } + return false; +} + +void Clay_OnHover(void (*onHoverFunction)(Clay_ElementId elementId, Clay_PointerData pointerInfo, void *userData), void *userData) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context->booleanWarnings.maxElementsExceeded) { + return; + } + Clay_LayoutElement *openLayoutElement = Clay__GetOpenLayoutElement(); + Clay_LayoutElementHashMapItem *hashMapItem = Clay__GetHashMapItem(openLayoutElement->id); + hashMapItem->onHoverFunction = onHoverFunction; + hashMapItem->hoverFunctionUserData = userData; +} + +CLAY_WASM_EXPORT("Clay_PointerOver") +bool Clay_PointerOver(Clay_ElementId elementId) { // TODO return priority for separating multiple results + Clay_Context* context = Clay_GetCurrentContext(); + for (int32_t i = 0; i < context->pointerOverIds.length; ++i) { + if (Clay_ElementIdArray_Get(&context->pointerOverIds, i)->id == elementId.id) { + return true; + } + } + return false; +} + +CLAY_WASM_EXPORT("Clay_GetScrollContainerData") +Clay_ScrollContainerData Clay_GetScrollContainerData(Clay_ElementId id) { + Clay_Context* context = Clay_GetCurrentContext(); + for (int32_t i = 0; i < context->scrollContainerDatas.length; ++i) { + Clay__ScrollContainerDataInternal *scrollContainerData = Clay__ScrollContainerDataInternalArray_Get(&context->scrollContainerDatas, i); + if (scrollContainerData->elementId == id.id) { + if (!scrollContainerData->layoutElement) { // This can happen on the first frame before a scroll container is declared + return CLAY__INIT(Clay_ScrollContainerData) CLAY__DEFAULT_STRUCT; + } + return CLAY__INIT(Clay_ScrollContainerData) { + .scrollPosition = &scrollContainerData->scrollPosition, + .scrollContainerDimensions = { scrollContainerData->boundingBox.width, scrollContainerData->boundingBox.height }, + .contentDimensions = scrollContainerData->contentSize, + .config = scrollContainerData->layoutElement->config.clip, + .found = true + }; + } + } + return CLAY__INIT(Clay_ScrollContainerData) CLAY__DEFAULT_STRUCT; +} + +CLAY_WASM_EXPORT("Clay_GetElementData") +Clay_ElementData Clay_GetElementData(Clay_ElementId id){ + Clay_LayoutElementHashMapItem * item = Clay__GetHashMapItem(id.id); + if(item == &Clay_LayoutElementHashMapItem_DEFAULT) { + return CLAY__INIT(Clay_ElementData) CLAY__DEFAULT_STRUCT; + } + + return CLAY__INIT(Clay_ElementData){ + .boundingBox = item->boundingBox, + .found = true + }; +} + +CLAY_WASM_EXPORT("Clay_SetDebugModeEnabled") +void Clay_SetDebugModeEnabled(bool enabled) { + Clay_Context* context = Clay_GetCurrentContext(); + context->debugModeEnabled = enabled; +} + +CLAY_WASM_EXPORT("Clay_IsDebugModeEnabled") +bool Clay_IsDebugModeEnabled(void) { + Clay_Context* context = Clay_GetCurrentContext(); + return context->debugModeEnabled; +} + +CLAY_WASM_EXPORT("Clay_SetCullingEnabled") +void Clay_SetCullingEnabled(bool enabled) { + Clay_Context* context = Clay_GetCurrentContext(); + context->disableCulling = !enabled; +} + +CLAY_WASM_EXPORT("Clay_SetExternalScrollHandlingEnabled") +void Clay_SetExternalScrollHandlingEnabled(bool enabled) { + Clay_Context* context = Clay_GetCurrentContext(); + context->externalScrollHandlingEnabled = enabled; +} + +CLAY_WASM_EXPORT("Clay_GetMaxElementCount") +int32_t Clay_GetMaxElementCount(void) { + Clay_Context* context = Clay_GetCurrentContext(); + return context->maxElementCount; +} + +CLAY_WASM_EXPORT("Clay_SetMaxElementCount") +void Clay_SetMaxElementCount(int32_t maxElementCount) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context) { + context->maxElementCount = maxElementCount; + } else { + Clay__defaultMaxElementCount = maxElementCount; // TODO: Fix this + Clay__defaultMaxMeasureTextWordCacheCount = maxElementCount * 2; + } +} + +CLAY_WASM_EXPORT("Clay_GetMaxMeasureTextCacheWordCount") +int32_t Clay_GetMaxMeasureTextCacheWordCount(void) { + Clay_Context* context = Clay_GetCurrentContext(); + return context->maxMeasureTextCacheWordCount; +} + +CLAY_WASM_EXPORT("Clay_SetMaxMeasureTextCacheWordCount") +void Clay_SetMaxMeasureTextCacheWordCount(int32_t maxMeasureTextCacheWordCount) { + Clay_Context* context = Clay_GetCurrentContext(); + if (context) { + Clay__currentContext->maxMeasureTextCacheWordCount = maxMeasureTextCacheWordCount; + } else { + Clay__defaultMaxMeasureTextWordCacheCount = maxMeasureTextCacheWordCount; // TODO: Fix this + } +} + +CLAY_WASM_EXPORT("Clay_ResetMeasureTextCache") +void Clay_ResetMeasureTextCache(void) { + Clay_Context* context = Clay_GetCurrentContext(); + context->measureTextHashMapInternal.length = 0; + context->measureTextHashMapInternalFreeList.length = 0; + context->measureTextHashMap.length = 0; + context->measuredWords.length = 0; + context->measuredWordsFreeList.length = 0; + + for (int32_t i = 0; i < context->measureTextHashMap.capacity; ++i) { + context->measureTextHashMap.internalArray[i] = 0; + } + context->measureTextHashMapInternal.length = 1; // Reserve the 0 value to mean "no next element" +} + +#define CLAY__LERP(from, to, mix) (from + (to - from) * mix) + +CLAY_DLL_EXPORT bool Clay_EaseOut(Clay_TransitionCallbackArguments arguments) { + float ratio = 1; + if (arguments.duration > 0) { + ratio = CLAY__MIN(arguments.elapsedTime / arguments.duration, 1); + } + float inverse = 1.0f - ratio; + float lerpAmount = 1.0f - (inverse * inverse * inverse); + if (arguments.properties & CLAY_TRANSITION_PROPERTY_X) { + arguments.current->boundingBox.x = CLAY__LERP(arguments.initial.boundingBox.x, arguments.target.boundingBox.x, lerpAmount); + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_Y) { + arguments.current->boundingBox.y = CLAY__LERP(arguments.initial.boundingBox.y, arguments.target.boundingBox.y, lerpAmount); + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_WIDTH) { + arguments.current->boundingBox.width = CLAY__LERP(arguments.initial.boundingBox.width, arguments.target.boundingBox.width, lerpAmount); + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_HEIGHT) { + arguments.current->boundingBox.height = CLAY__LERP(arguments.initial.boundingBox.height, arguments.target.boundingBox.height, lerpAmount); + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_BACKGROUND_COLOR) { + arguments.current->backgroundColor = CLAY__INIT(Clay_Color) { + .r = CLAY__LERP(arguments.initial.backgroundColor.r, arguments.target.backgroundColor.r, lerpAmount), + .g = CLAY__LERP(arguments.initial.backgroundColor.g, arguments.target.backgroundColor.g, lerpAmount), + .b = CLAY__LERP(arguments.initial.backgroundColor.b, arguments.target.backgroundColor.b, lerpAmount), + .a = CLAY__LERP(arguments.initial.backgroundColor.a, arguments.target.backgroundColor.a, lerpAmount), + }; + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_OVERLAY_COLOR) { + arguments.current->overlayColor = CLAY__INIT(Clay_Color) { + .r = CLAY__LERP(arguments.initial.overlayColor.r, arguments.target.overlayColor.r, lerpAmount), + .g = CLAY__LERP(arguments.initial.overlayColor.g, arguments.target.overlayColor.g, lerpAmount), + .b = CLAY__LERP(arguments.initial.overlayColor.b, arguments.target.overlayColor.b, lerpAmount), + .a = CLAY__LERP(arguments.initial.overlayColor.a, arguments.target.overlayColor.a, lerpAmount), + }; + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_BORDER_COLOR) { + arguments.current->borderColor = CLAY__INIT(Clay_Color) { + .r = CLAY__LERP(arguments.initial.borderColor.r, arguments.target.borderColor.r, lerpAmount), + .g = CLAY__LERP(arguments.initial.borderColor.g, arguments.target.borderColor.g, lerpAmount), + .b = CLAY__LERP(arguments.initial.borderColor.b, arguments.target.borderColor.b, lerpAmount), + .a = CLAY__LERP(arguments.initial.borderColor.a, arguments.target.borderColor.a, lerpAmount), + }; + } + if (arguments.properties & CLAY_TRANSITION_PROPERTY_BORDER_WIDTH) { + arguments.current->borderWidth = CLAY__INIT(Clay_BorderWidth) { + .left = (uint16_t)CLAY__LERP(arguments.initial.borderWidth.left, arguments.target.borderWidth.left, lerpAmount), + .right = (uint16_t)CLAY__LERP(arguments.initial.borderWidth.right, arguments.target.borderWidth.right, lerpAmount), + .top = (uint16_t)CLAY__LERP(arguments.initial.borderWidth.top, arguments.target.borderWidth.top, lerpAmount), + .bottom = (uint16_t)CLAY__LERP(arguments.initial.borderWidth.bottom, arguments.target.borderWidth.bottom, lerpAmount), + .betweenChildren = (uint16_t)CLAY__LERP(arguments.initial.borderWidth.betweenChildren, arguments.target.borderWidth.betweenChildren, lerpAmount), + }; + } + return ratio >= 1; +} + +#endif // CLAY_IMPLEMENTATION + +/* +LICENSE +zlib/libpng license + +Copyright (c) 2024 Nic Barker + +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. +*/ diff --git a/libraries/clay/clay-odin/linux/clay.a b/libraries/clay/clay-odin/linux/clay.a new file mode 100644 index 0000000000000000000000000000000000000000..d84fd1e711592da3e8580738820db81cd98eb746 GIT binary patch literal 267396 zcmeEv4SZC^x%Y0ege691qtT+p8g;D+Mog4eVyJfy*(GOj0}+G7ijp)WLW@Adu0{)z zu)C7uVF6ouwfA~&X>0H6z4g7dYJsY?y9p*CDhB*0YCj^{mTj~JZ4oVX-~Tgn&VHT* zP$A*>5@pXhGjrxV^UO2P*E}StVM2Ex^PKT%M9PrM(^TfOPx*44ZbB_lPK}E zWy_XGEiEW4Em^XxvBBH4Kx%1P+Ms1O`daYhtz5R$+tjMRGfeqJbyZDX(}L-!eSy<8 zLz?TU)oK(k&uLhCYg6T-rp9k%z=0QUXjtNFGRoj@R5mPcXk6^QGoygCaAC?v@T`|L z{M7YJ7B@C6AVAY`F{kOaWw$q7e@DaeuQeEec)h_ZNL%0pnrfH%8W(w*mfq@Jq*c3k zsrSk&7I=rjT1p9mM@vXUU3#%(G^OVmVJf9e0$It)=_pCgTVRNlloAQVq$dx7o5n>A zEyExtkxf{kr!VHx($QNy>Ms@ zq!o$NYCJs^AMs>SBZ?>CBs0?hFKLD1xJgYoMniblmc%1eDH|)zJzZLJ=qbfQ?PuI3IEM2jf>-I<2$-}*n=wIVfX_Ax-LTy4ZMtn}4!B_WSK@s)RI#+q8>*OL z_Z_jYQ3nqHQlbloEtlSj!xlE~#^GN{bmS4s4bhd=O${r2ElmsOEo&J@4O@^|EZ$`) zd1?J*_*$~sYFNOiKQap@`XD1O9q$y#pf<6+qE4TF1wnlt(!v&;~Eky&uqJ~1es(Kp6rhUlY|@lxB;)HG|^!r>I= zVag|Z$*@pbHyM^O?5E*N8g-onPxMNlMp2u8}HTm9jKPd$VR4 zyqWG5ZYbFco8~k%>i%MUhk(eH9CYUL}JEL+i( ziuCHH+bVBcuH{odre-IlP}AdGLg~c3Q%eiXKsQNxt;VYp%5}b`mOF*bmx6Sow={s< zOJQm>ELnV4lWX}RI51lpmH^;oExJE`UPH^$;XQSU8fuzaRxDoO1=*!kF=NTH2CwUz zzJ?_Uq-w3Ye(_zXTua776Hx&-a92o6mcc>Tx_Ct#P&ngLs0e5DFS0 z#FlCql?_W8eM``DGZw>Y7Nbef2uOSO+}c#CrXfU>($q5h_NEs1LLClg)7N~rB2)W} zKyB@v%bPq6Uu)7^DBv2Z2p>sK*YvqnH@IE%7F5pm%$~F0N{w98)2C?Aiz@loQy9St z4^Xa^;kh>~Zn{IWKk1hAEb)Q>HKQmI*{p`!2=$3USGlYOUWPdh3m5xVq~c}4LP7x5 zEHA!w(GvW_eA1F-ItgZgnbO5^01Xf%H#L9i3Lg^$MRKCgG# zQtm8i;8SMCpU_g{t<%_`VP9P#3WEw#2b*ExvLQP5dY8vlS?h8xm@|8xsBiXC8S_*+ z3Q|WNO@{I6=Sg#BWw7At#Y@GIqcIe337;9PZfK3up>L^9DGSB4Au^K~CYd{2H?Le4 zFIm~rM7*vAlZc!%YqNFIQZVHNn}BRgsz;xj6o4QvgD+*25ESZMj2V;_nAOw<8xU-q zfjYIpdA%3l#k(UjF~ObU&=^Tf!P3**Wf~OIn{HjK311DhpsS@im*)b@)wg??o1>$Ev#u-w!EpuySQmZ?J})PL`m1ug`%0_5v@+*?z%uoupFZlE;=xIpvfUl zM@^bcOk!j452Up;A(0cGNu&YWd`MNp8gMOb_}UV^X7>u?bi7dMTe1YKJ*7C3U9G}r zDZbB#YkDa_U`Vrg+b~^}Pa;1~!km^9WGr4jLZLZLD^lo~SEO}O!-}TaK7I6Xc9g~z zg$l*FMk0rgSXa&UZqMvl8EgRKeu36%r$V4mAq zE1OJ>OB(K+yetuIG*q0?m#0kO5lB~jX=-WdRJyItUG4JB$TFKv`k&c!jVbY@rzQLA&s{(NO#>vVa*}uK! zrmlTd7dzjH3jOcMiDJCcpMET>xk~Q`d;9}{zgIT*$Q5@PfnP}AUqDsiYNso26M>IL z;r>$It~BsVb?~PW_=N<1X)^d>0{?0`dpd!iC(v5qu{(TY0J|(eZ;s)>q}XfGUlRB$gugObpG1h}=Y3n~<_u_y z2-+hPNgA|AAd*CvbIP!$5C$lG)Z&+IF%6AkcD?~UgC6oKt{QdZz|L=@5tB*3a^q}E z1zS}htMjZO$*fdaz(H~y9aC~g4=E?;V=fW2th}%MGeJ_sMan-|nMumWW#EJEOUmCmw^9Fz|RPNC@7^2(o|DFr_pUGgVY`kdtUF~;jCwl59odj#PMUKh4JDHOc-NGs^5Aj&HcYQ$>DocWY6_ z4VG0GDgCh70P_qh3M8DnG7GGMMH<~i9o+hsvPpzYq*nfxfw1N>KA4+Gn*SN_hjM6k`)(XkvGSXAoGU@MvWvJ(tkR- z`@?vA$c-~B<(=$5BEj7b_CSxr`l4?x)COgSMOJUOD!XKK0JB-fW3pttPMjD(1={RL ztzBlppVQbeAK>H5ygyFJ)Sc!yA&=t06(Ek!8lE(Vu zNrwM4d+!oCwnKqst*)l|mdGD*XSqsNYp=4>cz~E>&|R(?^k&Gq<23hmbYo&TePt5l z!52O77;w>MaVrHTx8gBbN2g39fiQf0zkAES%jRMID+L%&qq_Ts;|JRO+)Z(PHze#$tsj|90=Ar4K$kE+ zZPx)^Hv(1jv+z@!1%#!WqoF*7t3KQ$eRR|a+ac%oPNM!Z9)FqkDGP3-ah7bOYQ2J} zzVRCU>jtZ>c0BrY{`mAUkZ!_8sY;lz`Vc2Gmc|k&Bz-Iqfq+o*M}c|!X~w;=el{25 z{kr&g5lR6eDoJ5R0~6WB4qh3*-asf<7Ck&;`-5%^a%&_ ziR_bHpU~Pcgg!CiK4}Dt+hhd}Y4E^wpR_UmNXVN}+C4|1FOQsg3Pl%uqQ7=`-%RFpMyUF3wg2-%eQ3Z_p;I*4H8Qk3Df^PS^W~e9S4T5 zuZpuUZM9V!l`!nDggh9f-Ib8neEfiwC#`qW4E*VG$ZM|;$!7A+(qQ5f{Z&@2gZ?2a zJpwIiB_gA)MVY)EG_Oe$%VP#Uj>QZlchT{f`qwA~jYtYW@Z}_}j62f!I*IyAnkU^L z)l#p?=}{RDPh+#iS-zK+lI&&=M640tJa_DQr_yZk(5!R6Cp0bWj{Ip%wfO^mlzEho zc_$_)0PDvbEcgUS``VD@ZR&KlxtkaFC^3(6(0EWD7gu~LP`-PxAoD8akkh_gp?SA4a%kcXni7)DukqHpm5*iRMdk0{L;C2K)LE9; zv*l4XJ1QwlEp9};7{uis7aC7n$UrY!+QbG0dVr@el-<|Z|E zh}IpKj!tWx!)N8|y`)<*`_oX~f1{`FWDxa3`V-^x)!zu$jV{}JBgc0-r;(H6zc|bp zvRuS}5gQp10e(&Vt8xu&?Hb{CJT@Qx(Dt4_-#Xg5%g`UEiSzk!{a&-b33&CJz>YTy z=s9+${Wo^hi5Rkn4FvshVG~AzJ|#}Uu>DE#W23OYjK`OefBt(kmXiJR)B$Skc=X`) z=)h0xr2jkB3nx7x$Gl%wYf#~J+JG6|j{47HkQ?gnUxjXPLwvlz-Un`A>(`L2e=K9= zWc3GBqy2EeY4N0@{hx?ekexaTg58t!e?$FYanA%YI!}Utx1s#QhzDTkr^R93kWuFz zNV7MM^ocK%f1nKh0lf_wDur+l@CJ?+_kaeBZXhI?oVq@4$Y1#SiqY9!e0(GfFWUb` zQy}2fP51-!PJ%l?;2_f-uy_a0A#cFGQRWRu;s+;N{~VkBKR4C>UwnwVgv@`9aECJg zABRrhUc8-3k@Zj4QDgmUpeK#F4C_Cse}}aHXF$fm#U{I)pkf)Az)`mWOYCn|t5emm8a3mwXEO{H~)cAPA z`QcOhiyb%n(3oE&$CsUwr>Ep8PD%N+QyIhU*P+MrX%X(DDW1)Ed}PLlosy@g%&Kn3p^e#CbzG) z%2_7UitMs*m)t&hY`?CJpBYsbjQjg)-n@@Rk()k-?R@t9c5>39z=92|EjtJmTHM>@9A-~_~e zeJK+EUh6p({-^QYs{F*7T7MV`gUxO=2cqqm!8i*q1B_2-A*HRf+o%JpnvMy-ppA3{ zA3B9#I^{AI!5fc~UQgjOwo4;LwT-JOorq$+NO(s12HK**wP+pAgPAhv+ z`7rV)X8tf1QLM^xi&A6lapduLRn7wV<{u8?nBYgK&#fGAN1}zU;10Ha0OhK2oS##9 z(f_AxxBpP~3ahIu9Q`)ZrS>-ugNNcV3H}-EnSw0I+~-tw0VJn+m!$Mbkw521Wqs4x zGoCE7p0qbtD;3RgmhHl8wOPZxmu>u>+aI=6mq&aZaxmuovfJG6D%+7_zf}PqE577X zUXmhj<+{u-IhEHU^v&1Yv52SqMc;3+?mrVzJq`<@NRi{nQkL6frDlRSa5o`;2w(5H zBYy_IcC+`M9ks<@Q+v8HYq{v{7 ztE>xo&RnyeM8Jz;`;fT@ne%hA^dzGv1W)D9l{uUMUuKD!{5GL6e3Uj^hXR#DtXiHXEB4X2lk}jN>K)GcdB6 z*)mSXxbhBj&u_bU+$-?B*dY>U!M z3B5`u_)A%5^zR@BGB)D`5@vy$kBUIv99*c=zZ|*?^bscdxbV}{$47!b0Lb5n68(ob zeH^m1T<2DL-NpUCB9w!x7PefW^!Wdj=Tx(t3TWFOvv@z}RHs{lx~r@(vrn*v*{MhKWy=ohkY-|%CF19AjRmOqoAA5lumZY zPoh8D(DpW2>6Jg&D@Xo(zPXQWy?X-NI_q4vb;d-{X<}C|n@=`>q`VsWW3KsCfW3`(8fWAl6-Ti1JJ~Y zJ_gg;qh3t?DYdP>)Wm|<Qb{?t(wpsusiTMQ%}Gy(N)|!wOi!MxJ3kG!0zU0 zNV%47kl?|UZx0aCY|?f18YH>Z*&vv8_Bz~yAB*~NBXZwot37rbel7M`fAn!1QL@JT z1NM5n0_&Is?!*n4@bDT!XdQoH@D`lMah&*nJ^_^A|2IN+kc)pUJxOQ+KQ3%3my}M) zzc)|4T6vm7R7=J)}bnx{EvUwZnHzZ{CP}3-SXz9}mu}&GgiO5Avrh zdit9Flub{Kc#{1+P$~}j!g1m7)Tj{-GbV7Q0ZgBG`o5g9UJ@4kfvXQfpCHcUAPEA6 zB0>^EFASA7St5i=tg&Y$waOBb&j*3Idm|r?L8M+Ob)>SdZ1)ET-0Ipep#&;jol`B@ z=nB5e0!0{lp3oC^LZn_?4siulSz<34JWumixzvUB2~H%Hx|Bb-f^W0HUtox!iqY#-X2q({eL#&SyI;q@NKDliM@aYAH;2R2|lL#zf!lK6C-1+)H5TS z0G4`k=z^h06lIpWXXKiik!j__atYEFB3o7-v@gfKtU53r1NK(j^YKVD#K$A$CXdHm zI-f{}E$|9jB3%1m`7P?pDL+K>{kCjV=PEp+eYt3T?zY0=UG~S&544a zV9Fzy0)GWe!2VTI#ZO6su9_@y>|20+lAi9ywIs@=inV)iVIdD%6(wFaD)65U-Tz`x zy44K>02Mlcq})%iD<$pm<_7c0IjK7BQ=Mx41ftxIb5R7O_W*C+>G%bG6WuwLDBpLi z#{z00qPAM`E)0pkhCvEWYaUW2QVs}|=vE3 z=5E|TEr1@));|QW-0J<*HczAX-ov5mP-+9wB#4+wRl^<7aUnfJNe-QZ8_+qCsYiKF zj_e&H_gJ8;m`u+Qje^(bTf3e4HWL<9$&WEf}W~2Hj$wCPRz{F@N#sOgF@2K|^Y@wD|`2iMumB5HAPLrTGjiI7K zXDUQy7IdHsaHT)o+O=DBKoM@a&Q#3Pka8*Apil{}D{(6)bf!`y={nO?+;bjH^>ZFg zxzXj|_r|@9DoHlcA8twEpg&zQklMDGry=DVbc2K?xN`ZRFWBC6tYSiA4LV9&CrIVp ztIn)e{+1-)qW^`@j3St|o{TbpRlaN0*FlyX?o5 zCwkn^YsW#8aFT#+um3z5Cn1pz5wxT14OiJgc!J)?SuXY|NZB1-gI6}PqILE*+`P}~ zdRg&0JHeprDJC;NGEfMmd|Xd6yL)HSOx?I{kJ8DCvC+mplr^y;+(E;BA7@|Mr=l8B z2X->E%SfxWm$2^e-1pgnerITf8PLg%IB~m6E`N@NHlf|%D!sVGc1YzLp2rOf+`y+S zXIi0Omz*Q{|C#H}!Ed3j8-SoX{Nh7SdtQfdOv^ccr8z0C2fuCzNeOjj#^tX8(iY}LvD#^7KM{2k;>E9!k; zVhcR>JY4c|;V^!YV1yK@XMu+yc=YxI)ac*wtoze~??U?2bM)PPi5&Suq0%Fd`zzYi z?S2Lj@X1imxPw43$1V^%n48FvL*FuE&(@?|pcu*tE1GX#4%~ME&*)wWQ=c}o=xR0( z+n^@;qNppn1mKjtK_s9PNHSgQ0G(7Te{dGR&(;%%gRZ+7Z~?C*bLbBwW_362l+6*s z>BE!)96yR{5^m{{vnv%UZF_VqCW%(sX}KXTBiw} zeq?5&iMw#6Kis}7?ug^>!7Ud$ukkdbkWxg2euK+@<6n}{8Nj11bO=)3eyX1f9m-8M z4Eo_Nm}HKQ0Vo_b#5rmtwiWV|cgmzNn&7cdd7sVi1!p*n*CoYer8ZTY=y$F~XfxHy zJKpnJFV}RmRbNce&v@gLH63MQNAy0_bs{+^F|&HKliAjBu}DM5Mk6jhGpN)hO>IiSss4m|d@2|@Qg6-b^Ev%_tg7T74<&l zCG|c!nBWNfAPYv215P1WzAjSD8`rL*c9S^!HC}-NOG8#&(ta3Spzur>WJ(|MxI0!G z%p37M4ug{joc?f2hBWYSxBgJWDF?8Zs?+pi0=)L}V;P*i^mtl2|tyPMsxs zj^u4UEArTvv!YG*HWb1kZ015hVy4lAlV2%v1m~WX60PMs%~N}vW|=+=AGfF5X|6%* zo#yM%WT*LhybfjGJdeaM5lCpRxqKI!jalmZ=}{vSh&J>I$tQrqX%Qcps+8Q9|ytm<5^a^IN4#w z!vfn;LLT|EoOFd0mI>K*H^0A@GCbEJBTix1kyDTttWOf;4pO3OlBud~^-41fUe3R? zr@QhxvjK21R2d~(PZj|TvN{gu|B}7>=~1ptS3JQ7t*p8Wbvr zpWd3m+u64rHF2(}al?EENLVh^aE$m2*&{=x0y)d2-Hz)x_sn-p%|L;#2ohosu#hAn z06|7M?;euKrXl!$#?DaM6jrr*jdCcR8w*Cv0>4Ck%0E1zCH4z6-YbVLqmO9*E->E` z2xZQEFM?1`;=Oe?-#2-%S~5JzGdEI?OY=&)s7A2_SL$|gpQOvm2~DhsCjY1y52Or& zkP3;AN)v>HiKKz@I-7Tb&R`c}I3R6stTs%Oa79s0OrOh1m$%Tks#@8+-E4BFFY8-1 zc${rxlly$1zv~>_&nsZ_-e8koLRRkk?8Z*0pcHyY#ru$U0g5arV3S|>eeSNaaDNuH z>V0-gKg#Yx*?9$BN%GkLP931KTwH`gq)OI!RE}AZ*8m@n2gNW)f{Oe(L&Qfkdbut8A{o+ukp< zt;A+G-pe(DsPGd@W$TtXr`5sBb^HA&=yNp&!;$H;185sD`b?$FOEt>8Xei1| z8J{O&{AlojTriA?q^NW1K$Dyd@oNK>f|l@;L`wyNG$#_7UY15zoIag`J}26~p-d?P zX;-5^goc3DEFgh`=F;!2=%fYDz0Yp$qc0jhoRQ{B@9^&|`8`>y!s-@NHDn9e8!35v^h5@=yUz%|r z5;b$_m=qw63K=Uh9J;w=r~suYVqb*f9T&Oe&!+jxFhKA>Mfl2Eb!T)u#?kTC$}}`- zA7$(Q4c~SI-u31+$J!?1`OlcpiKi<$L zRBi;e)^J0hF3GGSX%Ceu?msKrq4X!~ZwTqR8?NJJ7KWd^@y*QJ+w5e&j!5nMW3W^G z;r&=IWOD_>-dC_dseG6BqF7(@`v|vTSL0mrO<|w4yiX3f&AxZK9yQ0~`zgGO*3d6c zzzKDDk*4`pt5>-j@1Z`I)b-?1z`SUAzjv(Ec6X84cM;+_ipYT0Yzj1R5et6b0z&m~ zUyj4KaNrn)9!i9D8PiwmsU{hxtjRcK&7J*B7?1ogv9g044{mimC260;VW}vHsnyWL ze7U`g7F4+#*At~l73;}5W$T(axxwb*Hh@gF2z&$F7V*#(wg`96*stUF*OM($D{PUt z>WM>Qgbh$nHUP!}`3@4kQ~*Ptgd5GwHV}Ea)#LiTxGKRNbxH)^j=qW?w>pDjBaf+# z@nK%)R%gM^q1hCJHug&@?_*g#4<7>hQ;;0`cOX92>sJ4D0GWImatmQZvD}-CoAqx~ z|ETM!kjAI96;7?^N)^2R#F{R5_B~;gqcvS80-0>9Y-L+FQtz4j#Cn-fUY4?x!mti# zi&}O@{*qI+Gn97_$$vSmY^QP{@<(Pq0H=w^UIbII1jC|Kw{f*j;wMzY+*MSXaU|3h z5&2AwlMf~t1z|VdQ-Tt}LlG{k5Vng_ zIBcsYgL3u*F4c4IVcZgkif7GXFcj(!L_W-d^O@gAe}>?U;|y`M8s891m)nOa{*km} z0gs9a7G*L)oDX?5jGZ)>k0l9^)(c-|kzc$B}&=D+fT zB{beBDGy#oeJ%9_E+fRz-!b#cz5FG8$Q{#a&N#n3f@3VYiGPDLt7G~=oLQCX%*xR7 zb_8bi1yG?evx3@bvEzr&l4(2#;47V@j2myjn8Ak)zNmwXFNX7h7FY%pT`B_ z=wk?bGajGq?>qpyPpBK1B&Yc+n!IyRbgirzCe>;a)DaB@e4G^*zL7SFsh)q zTuu}EDVmF@iUofNYaG6B`cRUR=57>I(_|l<;a1n#2SDSxGCp{l8&k$4n`=n_fTqFq zk6OASv5xyfZ{+tkk^V71%@kRaH&yYicb-1%1;gbu4%aT;vV*)KsUG=(ZWC+==1Z0;{W986F`|>Bh0N6B^ z#cbKkb}gnLv`M~vG0BIe3}~*HOmS5_!Dp&i=*Os`T78;>E`?@59E!*jM4fm-Q?Ov= zk7KS4O}mN?SrQ)+L{ixkxQae$1~U|aDelH~yvt?nyk)#?b+>m5^>Lj&E>9o92dQJ9 zCeTTs@<=;OlM9Jji%O}hQ$*@d>79hr`M6+JU+9Bo=&-J@<+3#i)-3=;io^Oa2Wyi( zA!avmxP_cuXHOEe;(^*tN&;0u#t~ab5g5n2Wqg(D@%~6g(?S%MDxoK-qhmYV>Lxp= z#e`EnCFKc@1to6{(Jq+C?>JGpl^(X$1&uMpHO7bgfNa z40Sq9{I=nCEGE<2aiu@p2E-lBwRhkaY(8KoR~a~cz^>923F~l4;rDtp-%PN;bv$^2 zCVtycjA9@*(lx>Q$wDa7`M#J8n^>`i=y+8DAcm$$(;aKVNQja%P%j#fuWm!)rvqD) z1)Df%LL7*gkD;lW^FeXP*+?wN@-3&t z8F^aj?G0M<(E$k2$iYZzKs_Wv38N%i7jfCTnBRYcGM13dlN1fGTviFu9(ya%7>r*E z^GM)VYI}xvDF2X$X2vPPbSewHI~LVwqyob~olIcZTFE9;evHpWv(2Lh^SlkIR6~Ha zHdfrrspckG<6DWxK#1mfz3R2q@D1tQbf0*Sx$Nyor2%VRDc>8)^zG`i> z8+|FM|IOPgI5y(c%HGI~9@FC$h((iSN0{@3zJy-{9&&XkO3vAh#zRs9t!kkN7CXJ8 zGZ9iuc{qa8ZcSkz9>^-<4o5izJ<2|*{5AxE5d+d<6asCyN5^+8B7rDkC|KwwQZ2NA zD1=k=*MYI*moLe;`FiCF-lN`Y;a`K*N4)6Ld&8(i#+o#FTlxC8rqcg1`zdLm9fwYb zal3{@CR_gw?n&;h28+T3_ZrfoqK)GTIbM5_=F4)70U9LKM?=?1SF}De!e<^blEyS5 ze1tE{IKl_(G3Xmp%ihK4UPF~K*PuR@p}!Xn!SNqL$>_GxL&vG3m}{sV=K#ElHC%BB zoz6kMmk>)!aPB3%$HIIeiNZTU8?O~>_92I@TREDVHs4+(#%X-sg>4WG8cjR|Q0ft2 zjsE$-Vuins<1&C>mc2XpIXU($a6k=n z`=70o%b#VTUX+#}!0oCFp-$M4-Ou z8|PTt$;l7_c?q~!5R>4D(X)0tK!ZwG^a4D}!8f?HV8P9Rt7456t$}+MTuAR~p@M&# znu*Sqv6`hw*-H2T3h3B-B`=HSyYrn{RuELy1XN>sPn&Fh54vVnA>|d(4c;}6 zGb^XM{m*Qp%CT!v@*+G62;wG>rpIby%7QT!)+T6}LKGi;7(aZQiO+yW^-w?E+@byd zj>6ml-T{Md>4=R03p{XaxydJ<{gW`VN0X(asd|FgKq;l_nu#C{XhZ9{yoIlh#+Iw> zZ3O5IO0>U=vi2}iz_47{<7%yma|lc!$^LBvNJqwZ*V3@8Rt~#k-57dQpBrI%q4PM+ z;da%f)r&tSHsr~EvJi=q`akr9K=(taz}Fl75iW`NDuL59ldzI&pFR9n*FC!{p?UUH zT2u7SPs(a2Xr6|S9zvM{BMTN{>`DG#Sphe+a9RQ`^{k~Q`qK#9qZSIi`w6}y0QvXY zPy(8_CY5PrL*Ny>kTicT;)BK7(Nz~xfN(D&(Zvdx^2J!4K|9MuH`7Z-@qs$&pBVf= zNruY2*oNJ@B(YB8E5wsTpm(=a155yg)yn<*P)-tVD6Ews0%C#3AR?viwX|a19Q`pK zs)KK9yvzlvfS!n77J7_ut3JjlMExa~UX8RGQ5-)HrZIrp5ZVfQbSp63zs*TXX(zhl zj4hDcPv6TACdBV%B2QU+J2q_4*5hb5wr4iE;ZJv1akREK?#dSB<#C^TpB0|XAfLNn^Bkr#{zW7 z{akqrA*aUyJC|ywUsKe9q|aU^eJflf!9eTuLY!&y)a)bDJj7gRre7`qOSmlctctJnx#6S3mfj|BrzDRoQ$%E{~izh}F#mkp}TWf>@+vKdwPc`irbQ9;S=` z&9EH0uZ>ih5ya|QvdV!YRQV$g9mhSDr3*Q%*G_dQf0H6_TM}5E8Or?1>^* zkNT6%)WsUP0!oh}QnGa@WdUUkE?D!%`GLnAmCY}}HabyY%Bf&-KA?fA^MN`Jrdm(P z{Ik~Qe+HFaJ-YgwcrwNpX#mPjjYaJQbG>Hd#y{s#8dueM)E*Az;{&)A%|wC83{<4V87Q|#l+lI*i$aj}1U%}rgzg45Rb zCAR0H>hXNReN}+0Wz4ahVaa3xg@HZbAfIIFb~Rusd``u9buPoi9sWenfRPUWfPi*0AvIZ_gK;!+V=G}L>-yZo9L&cb#btUZ z@0Va>M`IzM2&5Vetf%$}Xa@+X@d4#Fzw9pGZXnl>3zQ!9N2weZhLK2#%k^y>%I}16 zfn1NgiEZZha+%;U@0HEFM%Cbds#gHppN3LyYko6B1vySA-~ z&BgRpRUx(_DC(lS65LIRuNO=5m$koB#9@1a?*oS@?Aiom2)rw#%*5m;g2ATxx6za= z!b8Tu=gB8g5vZZw!#%xvq~1LyUTJ`Dgr?p@=9U%-EUWhn;EBS@>S)%|jDncbtW|oa zm^+;I%h{Ix$lfeD^mUsYnm$3sTlBJe4}CMR;}=DEcxDP!z+4Apgwv3(;TMIJN@|v# zO2EjWnNw-Liu57b-*>gFAhs6wWjkoAVlt=(FNx1@YSG}a2;bILZfxVz&IrT^oj(z; zW1^Jr>o$P5R+V8U&yC&KvPIeK2kNP@joB2BrTiyKM3*2TdHr4z2E~@CgdT(WQ!A3w z_mAT4aa0=jDsB=xByv?zi*rWsA=OC1hc>##gX7>~{-^Dmac5#1%24OXH36Vt>aFdmA8=rT5nQ6DVIU>>gGUZH z6-2->oQ$ybFCwf#MzHe3fK@R|PXm7@y#ayQcyg*gc>rk|+=x!Y4rB(K>1cECdbvbY z-U*{0G)s@3QF@&;_ZHXy!1Z7>Kkg}NjN;GY!DzGakP(dL$y3WQ=M__F?{3PWrSeqM&6TCRI=u$A{%tHX zbCtygFXG#!BE0tjR`_Qh}94qF_%lA)Z8nN8~NnT?ih-~_FgCXKUIU(lz&Im_^5 zKO9C$zQoyh{_;fjZ+!YYz*!|GwVh)?aqBp<#FOWA6K#9*24c@?QNPW38RoaQxSY+B zf0Y&DjE;r~%(R+JVBc5Kl(<6+R0lHG@pU1On!)W?@>Fo9B1Bl&9cVwIRS;hF5Z&Pq zr61(G&Edvrr#`~|l^*30dl;Fb2jcS3i48MLv0o~mfS1d=n7y`Wv9+O=~ZU$ruA9A<by#6o*tH)&i}4f74!u(uCr6gG<+tS5O^4PNTQPO z;gOF9M5RyOj@Qruz8t2ub8J4ru}25y5{9><;#3SrzsieojqZ4J^`Ws4!}emv?M|V9 z9FR`*zj+%*7~rGrHtMJIfnkvEF0kfM)!}LXyyI%U_sl-NgwSE~T|zwC0V)>C(0@@I ziIVxI8kC3K@29onyc6O#IOfED)zze;2B)EJsM?OUSe7@N6=63ptVt-MjbrdoM(Jkk z)qtTu%*`A*2<~TwCQ46UE9Y-TgV+xOxZj2(yeIY(Lk-a69!w;O2e8YPNF&+=kwqO;6j7qZ0 zs7JOM>`(YI3vNITyH}xKWTEIND67NhLn52A4(5(m`;?V$`R$b4+(4O@8f02lUrDB0OP@1UcxD7Y2@Rd-v6P5+V* zf^Ng!3@ms(>WSWo^rZeotrXvPC9*`Nq;n`@r*I5IJk=9<6$^RAw@EG%+ZwT(ab19t z`6dvXr~DsSX!LjL1sJqCp)E)zv^m2N8Vhy;P7U-w;uf~L469uxR^XU`83tRFcvG7G zIdb&K?EyX*bQ%m?qtW0VzzL`=R@uCddTR%7miJ=4H;`8g8F}$w@kVMTJQDI0YUM<< zvH*pChWE`{p&Wj#Z^Ig*AZ!~iF2VOv^iC)mcY_CZsIQS=q z{hZz&ovMQ605gfRp?5DqilqF8pDH|R#zPYP;5A}@Izh@h_jv^YY$(OY44aJ3(_Xnh zjH7@-yb&Vu;7?I1As^k!E6PhSxxj+hymtkcrHJr+m*blVu zgq)-O3p3;#4--#(Z=~p%6+^hO;z#UlpvTxQRwVBD(FF+_2f`q`xcGmL)t-)`#AmpC zVUu^UwSNO)up(@I*V$`kMY~w-OKk27?1ny8)DKSm5}Vx5?&(7rJdl0{eoq<$qW7Xt z(3^x$904M+NzbBM4|UKjy}Xmagt5sdFN%c~Wb+T6#pM@g7qKp9`5+5D532^ehFa2k z32pEUtq~}1*ZIZ|0B-a-{EUk6mWEo5eO#VQFc;!D8HDPm+R0+n>GFA`=!HmxC?;;` zk_A?Pa}Lm<^ScZ@s7QxJd-{BT|+#saXz?m6RK8ekER@@KHD4GUm@L}Tv= zm4|Cl@8UsQ@6Bst_Y5EOQ_sH`H9Rjfm>0grh+ZFl_ z+#;QyAV(stOg1!@qA!%KNV3m!!7mN}U}Ov*cLV|M57dvh$9Y;rBiV z8y~N_V9>2k8IqHUW)w_aN_Q;WZMoty6j(V4E?|H6$8hUv=lQ}ta0SlsrIUZ1SKxG% z9=ZGjIdpq$<$$@J0~i@7#1t~@cWgDfDA8y*_v_=Wfdj4Md3;LUNN#n0w&AL|I6Wmq z?qoSsYhNy_kJ5eUPP4L&N^ERiD*}jT3NAq*=Q=5Z@ zN1hy7c$5?UJ>F|;Erx&Z72I_@im|4X?;cv1)pInPY)xUjFm-bNyZ5bw^Cu02DQeiSdx2pX5Gx=iXsg zAz68W699JYBLD3*wCB}1e9tT1lY?gv2anS$I@UE`C@ya7k28;q#zIZ4D zVxI&0o=aVAmHZG1fx93nU~jT{oTujx)oM3btgiCIx>;YHs5x;;+w zeiu~lJW1&mRnR(KmG^PQnyCPZg?^3{7x;Opv*Jl|fv>v6g$2b}r{u~0AyEuYL}fvu zg6I=~JqbVYhN4~kh+Zmvf~XeVG9Ly7O)cTdihzLx!t`wk2yhx()LqylhgZp^d0v)wfk5N~m-k5aq&)@j@HVSz7Oy75_9_Cy=qmTqUa zl@9Oi9!D|P-KUw9+U`6Ik8WFZ5{7Joo+LPLaX_f|90PdRJ=Z`@l0s7^`#;XwhL4(< zXFrzpa}e(p9kmXrZdIx&+ugRZG*;+fo4R3>Vrpn!SZ@5MY(C`Zc+aUEEPjTu+_WyJ!2ns^ywtIsOBF6O9Dmb=k^J49{)E{I1;#&BjstB1iU zr21G`Qb;!dvyT4pgAoR<8tOM9@&Jnzn*pu}7^8~_sKy7mZiIbI*!qvq7o_D7tAWb| zeSbPqu*1v6{Gx43MhmzT{Oi->+M_&lEQ*N^6>khIB<@zd#nFn%Mw*Gu$I(gnDHR@S z@1$!REzdyDVjb6Gu1M%wEL27FM!IiW?0-18Rb3;a-6WLJKx|A?gC~j=#qE6D(wyB_ zLBAM&+D12J?;<#Guqu__aX1$3H9}UuJX5h0V~|Y;)fQW4_Be|t5FXvJ?HHR>rR;xp z0s^mD=tFvV0Jp0!lGfDIlX)LkmlFCmK>9TDl=i?Gpo+EN&7)KQG^OQU(!8r1|1!PX zQj7siigD|gHN|yu8X}$8k(V&Y)*XQGiv9;~llj4C#bZB3dlC@N<}O;Tkt2ZM=zfSE z;@BIA*vevM2g`PIU6d1d@C}WhvGrcSm^3oeMkIx8B>Y96)?PTq@u-hOj7u>H`S`Qx zGel2XOs4o4T#z&dX*{Np&frraDb|dT%U_^DCN@0+rXi1*gref0QduOK~!RNh5tcU{=5VDYneSz54UU&IU-gV5s1GsXldG?u&c|W6FNjoM`H}MTWStyTp zQ{Ikb({v@$bb9M{T4QECya`Sb+Ey(dthWpg*ar+}!w+7q`JZCX(oWnudo0t~V;Ql> zGL1bxD;kTn`pkbBYS8)&Jq!L*3T@W{P%RG=6Dre~P;nY1RXoCZ(8~LwG&V*V|IvVB z>-O`;jU4-N$C6OJ=DUC<`b(&j9Q}0Yq{q%rousXw>7+6-AXs1kD5XI`iogkxPY~$j z0n2n!faf5Cld*tL8zA5l?gW`L|BvA=O`-4^Nfdr{CWQ|^Qx=Y{#!Eu<(_wDw%E8ER zw3qzBYuwAhr;MDCr!jCLm>5NTNk%5^M%YdpEio*Hn7s z@*aUy8&PDs;wdVm*n#9saqo7Jsw zy@GTQs1`KIPzpr?9$MOkkMp-`-q@STI^Y^ec^A&VRPQB~16xn%(mF|hA4*<7A-qsC zz%Su#%Aw!57itE1p=Maqyii}FGPG{ysMQd+^6S_x9M8=m6`NYA*IBWahEOG|`LwKt z5ancB8}iuJ>&|XQ0$~Q{B4eSRKpE{bIEj;prdnaML4^HGz?nXI&Cc>SS?C2Kd?7;} zc=fXxkGcaK5FK@UNkiAZ4n;iyU{Jo5oRiMRQTK%8@_lU9v)EOR z?mfy!K)tB=S+=g0jO5MeL9Xs5ceDl-jr=JX8X+ZuI+-qb3;)E9c7T^%$Qq$mi z);v$tk3TXawv+Wn!}5LmFqrRtdY%O+d#eeRS;9 zuJ%a9JN)6#Ic0sJyxmCt^J!&$%C5*>X5JNxfD-sz2OU$emA(!U*~TY3#BP(AQE+Bq zUc;G1^BP&S_oM@*Xm3fn_n1sM01|XadMCv&i0uT4H28Lc2QEjIuvxlSmCO#6+zz8B z8-89QK6fKj&|sK$;G*}KLN-9Oi*85QpRM_S(*SI}RMR3Z(!)>S+zF8@1It` z{)Ch+mRGn`pT&d29i7Vlj73{{x-j;C7-PYQr~y0m2E_f>pWa^oWbkXl(pkRT=B-dc z`G7INKrN(j-U_KCRcu&-M;7`j9&mzm;$U`q$A{U-HZ+E>gZKg6u)v?_k!@LL|2}T~ zA6nVkxp4nLConxZmJ0l+ujTW2lC4ip6^|>da1wBrhGs}Wdw_Fl%O*Q5oeZ^na;xL=5_AmpQy>(M%zNNANBH2a7R2o(dYjNK;1*H zzy(%oFVIT$w=CXfr?&p6f5kW8e(M`-ipQU5cp{BjG&6V(@BuZM6+@b%`>n7See
Cih*KiPg<2MKod$sk(Om6 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 z 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 literal 0 HcmV?d00001 diff --git a/libraries/clay/clay-odin/macos-arm64/clay.a b/libraries/clay/clay-odin/macos-arm64/clay.a new file mode 100644 index 0000000000000000000000000000000000000000..5b0da83a817fa38ee64300b7d3b362987020b920 GIT binary patch literal 631268 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 z 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Ⓢ!!QG{CmnY$_0Pad_EaP?|+&US++MR&A=MLQG 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 z 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 literal 0 HcmV?d00001 diff --git a/libraries/clay/clay-odin/macos/clay.a b/libraries/clay/clay-odin/macos/clay.a new file mode 100644 index 0000000000000000000000000000000000000000..602d49f92d776706ca0e4c944ea79f4ac4fb4ac7 GIT binary patch literal 187844 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

rb`U(Wt-RClVR@aTPCMmH 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 literal 0 HcmV?d00001 diff --git a/libraries/clay/clay-odin/wasm/clay.o b/libraries/clay/clay-odin/wasm/clay.o new file mode 100644 index 0000000000000000000000000000000000000000..641c5dece4bac173d9b5607f2e2e3af53ff2be71 GIT binary patch literal 234467 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 literal 0 HcmV?d00001 diff --git a/libraries/clay/clay-odin/windows/clay.lib b/libraries/clay/clay-odin/windows/clay.lib new file mode 100644 index 0000000000000000000000000000000000000000..e23c296c784f94e3b3e8f7bcf862f3e80efee16a GIT binary patch literal 212419 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 K+_6upK{ppDu1ae$@493?F6Bd}SnuZO*S6 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 fPCc=zubq9$)Oj{QrZS4m&yItT5oW8;Y{<&7jAQ literal 0 HcmV?d00001 diff --git a/libraries/clay/clay.odin b/libraries/clay/clay.odin new file mode 100644 index 0000000..d7be7e7 --- /dev/null +++ b/libraries/clay/clay.odin @@ -0,0 +1,601 @@ +package clay + +import "core:c" + +when ODIN_OS == .Windows { + foreign import Clay "clay-odin/windows/clay.lib" +} else when ODIN_OS == .Linux { + foreign import Clay "clay-odin/linux/clay.a" +} else when ODIN_OS == .Darwin { + when ODIN_ARCH == .arm64 { + foreign import Clay "clay-odin/macos-arm64/clay.a" + } else { + foreign import Clay "clay-odin/macos/clay.a" + } +} else when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { + foreign import Clay "clay-odin/wasm/clay.o" +} + +String :: struct { + isStaticallyAllocated: c.bool, + length: c.int32_t, + chars: [^]c.char, +} + +StringSlice :: struct { + length: c.int32_t, + chars: [^]c.char, + baseChars: [^]c.char, +} + +Vector2 :: [2]c.float + +Dimensions :: struct { + width: c.float, + height: c.float, +} + +Arena :: struct { + nextAllocation: uintptr, + capacity: c.size_t, + memory: [^]c.char, +} + +BoundingBox :: struct { + x: c.float, + y: c.float, + width: c.float, + height: c.float, +} + +Color :: [4]c.float + +CornerRadius :: struct { + topLeft: c.float, + topRight: c.float, + bottomLeft: c.float, + bottomRight: c.float, +} + +ElementId :: struct { + id: u32, + offset: u32, + baseId: u32, + stringId: String, +} + +ElementIdArray :: struct { + capacity: i32, + length: i32, + internalArray: [^]ElementId, +} + +when ODIN_OS == .Windows { + EnumBackingType :: u32 +} else { + EnumBackingType :: u8 +} + +RenderCommandType :: enum EnumBackingType { + None, + Rectangle, + Border, + Text, + Image, + ScissorStart, + ScissorEnd, + OverlayColorStart, + OverlayColorEnd, + Custom, +} + +RectangleElementConfig :: struct { + color: Color, +} + +TextWrapMode :: enum EnumBackingType { + Words, + Newlines, + None, +} + +TextAlignment :: enum EnumBackingType { + Left, + Center, + Right, +} + +TextElementConfig :: struct { + userData: rawptr, + textColor: Color, + fontId: u16, + fontSize: u16, + letterSpacing: u16, + lineHeight: u16, + wrapMode: TextWrapMode, + textAlignment: TextAlignment, +} + +AspectRatioElementConfig :: struct { + aspectRatio: f32, +} + +ImageElementConfig :: struct { + imageData: rawptr, +} + +CustomElementConfig :: struct { + customData: rawptr, +} + +BorderWidth :: struct { + left: u16, + right: u16, + top: u16, + bottom: u16, + betweenChildren: u16, +} + +BorderElementConfig :: struct { + color: Color, + width: BorderWidth, +} + +TransitionData :: struct { + boundingBox: BoundingBox, + backgroundColor: Color, + overlayColor: Color, + borderColor: Color, + borderWidth: BorderWidth, +} + +TransitionState :: enum c.int { + Idle, + Entering, + Transitioning, + Exiting, +} + +TransitionProperty :: enum c.int { + X, + Y, + Width, + Height, + BackgroundColor, + OverlayColor, + CornerRadius, + BorderColor, + BorderWidth, +} + +TransitionPropertyFlags :: bit_set[TransitionProperty;c.int] +TransitionPropertyPosition :: TransitionPropertyFlags{.X, .Y} +TransitionPropertyDimensions :: TransitionPropertyFlags{.Width, .Height} +TransitionPropertyBoundingBox :: TransitionPropertyPosition + TransitionPropertyDimensions +TransitionPropertyBorder :: TransitionPropertyFlags{.BorderColor, .BorderWidth} + +TransitionCallbackArguments :: struct { + transitionState: TransitionState, + initial: TransitionData, + current: ^TransitionData, + target: TransitionData, + elapsedTime: f32, + duration: f32, + properties: TransitionPropertyFlags, +} + +TransitionEnterTriggerType :: enum EnumBackingType { + SkipOnFirstParentFrame, + TriggerOnFirstParentFrame, +} + +TransitionExitTriggerType :: enum EnumBackingType { + SkipWhenParentExits, + TriggerWhenParentExits, +} + +TransitionInteractionHandlingType :: enum EnumBackingType { + DisableInteractionsWhileTransitioningPosition, + AllowInteractionsWhileTransitioningPosition, +} + +ExitTransitionSiblingOrdering :: enum EnumBackingType { + UnderneathSiblings, + NaturalOrder, + AboveSiblings, +} + +TransitionElementConfig :: struct { + handler: proc "c" (args: TransitionCallbackArguments) -> bool, + duration: f32, + properties: TransitionPropertyFlags, + interactionHandling: TransitionInteractionHandlingType, + enter: struct { + setInitialState: proc "c" (initialState: TransitionData, properties: TransitionPropertyFlags) -> TransitionData, + trigger: TransitionEnterTriggerType, + }, + exit: struct { + setFinalState: proc "c" (finalState: TransitionData, properties: TransitionPropertyFlags) -> TransitionData, + trigger: TransitionExitTriggerType, + siblingOrdering: ExitTransitionSiblingOrdering, + }, +} + +ClipElementConfig :: struct { + horizontal: bool, // clip overflowing elements on the "X" axis + vertical: bool, // clip overflowing elements on the "Y" axis + childOffset: Vector2, // offsets the [X,Y] positions of all child elements, primarily for scrolling containers +} + +FloatingAttachPointType :: enum EnumBackingType { + LeftTop, + LeftCenter, + LeftBottom, + CenterTop, + CenterCenter, + CenterBottom, + RightTop, + RightCenter, + RightBottom, +} + +FloatingAttachPoints :: struct { + element: FloatingAttachPointType, + parent: FloatingAttachPointType, +} + +PointerCaptureMode :: enum EnumBackingType { + Capture, + Passthrough, +} + +FloatingAttachToElement :: enum EnumBackingType { + None, + Parent, + ElementWithId, + Root, +} + +FloatingClipToElement :: enum EnumBackingType { + None, + AttachedParent, +} + +FloatingElementConfig :: struct { + offset: Vector2, + expand: Dimensions, + parentId: u32, + zIndex: i16, + attachment: FloatingAttachPoints, + pointerCaptureMode: PointerCaptureMode, + attachTo: FloatingAttachToElement, + clipTo: FloatingClipToElement, +} + +TextRenderData :: struct { + stringContents: StringSlice, + textColor: Color, + fontId: u16, + fontSize: u16, + letterSpacing: u16, + lineHeight: u16, +} + +RectangleRenderData :: struct { + backgroundColor: Color, + cornerRadius: CornerRadius, +} + +ImageRenderData :: struct { + backgroundColor: Color, + cornerRadius: CornerRadius, + imageData: rawptr, +} + +CustomRenderData :: struct { + backgroundColor: Color, + cornerRadius: CornerRadius, + customData: rawptr, +} + +ClipRenderData :: struct { + horizontal: bool, + vertical: bool, +} + +OverlayColorRenderData :: struct { + color: Color, +} + +BorderRenderData :: struct { + color: Color, + cornerRadius: CornerRadius, + width: BorderWidth, +} + +RenderCommandData :: struct #raw_union { + rectangle: RectangleRenderData, + text: TextRenderData, + image: ImageRenderData, + custom: CustomRenderData, + border: BorderRenderData, + clip: ClipRenderData, + overlayColor: OverlayColorRenderData, +} + +RenderCommand :: struct { + boundingBox: BoundingBox, + renderData: RenderCommandData, + userData: rawptr, + id: u32, + zIndex: i16, + commandType: RenderCommandType, +} + +ScrollContainerData :: struct { + // Note: This is a pointer to the real internal scroll position, mutating it may cause a change in final layout. + // Intended for use with external functionality that modifies scroll position, such as scroll bars or auto scrolling. + scrollPosition: ^Vector2, + scrollContainerDimensions: Dimensions, + contentDimensions: Dimensions, + config: ClipElementConfig, + // Indicates whether an actual scroll container matched the provided ID or if the default struct was returned. + found: bool, +} + +ElementData :: struct { + boundingBox: BoundingBox, + found: bool, +} + +PointerDataInteractionState :: enum EnumBackingType { + PressedThisFrame, + Pressed, + ReleasedThisFrame, + Released, +} + +PointerData :: struct { + position: Vector2, + state: PointerDataInteractionState, +} + +SizingType :: enum EnumBackingType { + Fit, + Grow, + Percent, + Fixed, +} + +SizingConstraintsMinMax :: struct { + min: c.float, + max: c.float, +} + +SizingConstraints :: struct #raw_union { + sizeMinMax: SizingConstraintsMinMax, + sizePercent: c.float, +} + +SizingAxis :: struct { + // Note: `min` is used for CLAY_SIZING_PERCENT, slightly different to clay.h due to lack of C anonymous unions + constraints: SizingConstraints, + type: SizingType, +} + +Sizing :: struct { + width: SizingAxis, + height: SizingAxis, +} + +Padding :: struct { + left: u16, + right: u16, + top: u16, + bottom: u16, +} + +LayoutDirection :: enum EnumBackingType { + LeftToRight, + TopToBottom, +} + +LayoutAlignmentX :: enum EnumBackingType { + Left, + Right, + Center, +} + +LayoutAlignmentY :: enum EnumBackingType { + Top, + Bottom, + Center, +} + +ChildAlignment :: struct { + x: LayoutAlignmentX, + y: LayoutAlignmentY, +} + +LayoutConfig :: struct { + sizing: Sizing, + padding: Padding, + childGap: u16, + childAlignment: ChildAlignment, + layoutDirection: LayoutDirection, +} + +ClayArray :: struct($type: typeid) { + capacity: i32, + length: i32, + internalArray: [^]type, +} + +ElementDeclaration :: struct { + layout: LayoutConfig, + backgroundColor: Color, + overlayColor: Color, + cornerRadius: CornerRadius, + aspectRatio: AspectRatioElementConfig, + image: ImageElementConfig, + floating: FloatingElementConfig, + custom: CustomElementConfig, + clip: ClipElementConfig, + border: BorderElementConfig, + transition: TransitionElementConfig, + userData: rawptr, +} + +ErrorType :: enum EnumBackingType { + TextMeasurementFunctionNotProvided, + ArenaCapacityExceeded, + ElementsCapacityExceeded, + TextMeasurementCapacityExceeded, + DuplicateId, + FloatingContainerParentNotFound, + PercentageOver1, + InternalError, + UnbalancedOpenClose, +} + +ErrorData :: struct { + errorType: ErrorType, + errorText: String, + userData: rawptr, +} + +ErrorHandler :: struct { + handler: proc "c" (errorData: ErrorData), + userData: rawptr, +} + +Context :: struct {} // opaque structure, only use as a pointer + +@(link_prefix = "Clay_", default_calling_convention = "c") +foreign Clay { + _OpenElement :: proc() --- + _OpenElementWithId :: proc(id: ElementId) --- + _CloseElement :: proc() --- + MinMemorySize :: proc() -> u32 --- + CreateArenaWithCapacityAndMemory :: proc(capacity: c.size_t, offset: [^]u8) -> Arena --- + SetPointerState :: proc(position: Vector2, pointerDown: bool) --- + GetPointerState :: proc() -> PointerData --- + Initialize :: proc(arena: Arena, layoutDimensions: Dimensions, errorHandler: ErrorHandler) -> ^Context --- + GetCurrentContext :: proc() -> ^Context --- + SetCurrentContext :: proc(ctx: ^Context) --- + UpdateScrollContainers :: proc(enableDragScrolling: bool, scrollDelta: Vector2, deltaTime: c.float) --- + SetLayoutDimensions :: proc(dimensions: Dimensions) --- + BeginLayout :: proc() --- + EndLayout :: proc(deltaTime: c.float) -> ClayArray(RenderCommand) --- + GetOpenElementId :: proc() -> u32 --- + GetElementId :: proc(id: String) -> ElementId --- + GetElementIdWithIndex :: proc(id: String, index: u32) -> ElementId --- + GetElementData :: proc(id: ElementId) -> ElementData --- + Hovered :: proc() -> bool --- + OnHover :: proc(onHoverFunction: proc "c" (id: ElementId, pointerData: PointerData, userData: rawptr), userData: rawptr) --- + PointerOver :: proc(id: ElementId) -> bool --- + GetPointerOverIds :: proc() -> ElementIdArray --- + GetScrollOffset :: proc() -> Vector2 --- + GetScrollContainerData :: proc(id: ElementId) -> ScrollContainerData --- + SetMeasureTextFunction :: proc(measureTextFunction: proc "c" (text: StringSlice, config: ^TextElementConfig, userData: rawptr) -> Dimensions, userData: rawptr) --- + SetQueryScrollOffsetFunction :: proc(queryScrollOffsetFunction: proc "c" (elementId: u32, userData: rawptr) -> Vector2, userData: rawptr) --- + RenderCommandArray_Get :: proc(array: ^ClayArray(RenderCommand), index: i32) -> ^RenderCommand --- + SetDebugModeEnabled :: proc(enabled: bool) --- + IsDebugModeEnabled :: proc() -> bool --- + SetCullingEnabled :: proc(enabled: bool) --- + GetMaxElementCount :: proc() -> i32 --- + SetMaxElementCount :: proc(maxElementCount: i32) --- + GetMaxMeasureTextCacheWordCount :: proc() -> i32 --- + SetMaxMeasureTextCacheWordCount :: proc(maxMeasureTextCacheWordCount: i32) --- + ResetMeasureTextCache :: proc() --- + EaseOut :: proc(arguments: TransitionCallbackArguments) -> bool --- +} + +@(link_prefix = "Clay_", default_calling_convention = "c", private) +foreign Clay { + _ConfigureOpenElement :: proc(config: ElementDeclaration) --- + _HashString :: proc(key: String, seed: u32) -> ElementId --- + _HashStringWithOffset :: proc(key: String, index: u32, seed: u32) -> ElementId --- + _OpenTextElement :: proc(text: String, textConfig: TextElementConfig) --- +} + +ConfigureOpenElement :: proc(config: ElementDeclaration) -> bool { + _ConfigureOpenElement(config) + return true +} + +@(deferred_none = _CloseElement) +UI_WithId :: proc(id: ElementId) -> proc(config: ElementDeclaration) -> bool { + _OpenElementWithId(id) + return ConfigureOpenElement +} + +@(deferred_none = _CloseElement) +UI_AutoId :: proc() -> proc(config: ElementDeclaration) -> bool { + _OpenElement() + return ConfigureOpenElement +} + +UI :: proc { + UI_WithId, + UI_AutoId, +} + +Text :: proc { + TextStatic, + TextDynamic, +} + +TextStatic :: proc($text: string, config: TextElementConfig) { + wrapped := MakeString(text) + wrapped.isStaticallyAllocated = true + _OpenTextElement(wrapped, config) +} + +TextDynamic :: proc(text: string, config: TextElementConfig) { + _OpenTextElement(MakeString(text), config) +} + +PaddingAll :: proc(allPadding: u16) -> Padding { + return {left = allPadding, right = allPadding, top = allPadding, bottom = allPadding} +} + +BorderOutside :: proc(width: u16) -> BorderWidth { + return {width, width, width, width, 0} +} + +BorderAll :: proc(width: u16) -> BorderWidth { + return {width, width, width, width, width} +} + +CornerRadiusAll :: proc(radius: f32) -> CornerRadius { + return CornerRadius{radius, radius, radius, radius} +} + +SizingFit :: proc(sizeMinMax: SizingConstraintsMinMax = {}) -> SizingAxis { + return SizingAxis{type = SizingType.Fit, constraints = {sizeMinMax = sizeMinMax}} +} + +SizingGrow :: proc(sizeMinMax: SizingConstraintsMinMax = {}) -> SizingAxis { + return SizingAxis{type = SizingType.Grow, constraints = {sizeMinMax = sizeMinMax}} +} + +SizingFixed :: proc(size: c.float) -> SizingAxis { + return SizingAxis{type = SizingType.Fixed, constraints = {sizeMinMax = {size, size}}} +} + +SizingPercent :: proc(sizePercent: c.float) -> SizingAxis { + return SizingAxis{type = SizingType.Percent, constraints = {sizePercent = sizePercent}} +} + +MakeString :: proc(label: string) -> String { + return String{chars = raw_data(label), length = cast(c.int)len(label)} +} + +ID :: proc(label: string, index: u32 = 0) -> ElementId { + return _HashString(MakeString(label), index) +} + +ID_LOCAL :: proc(label: string, index: u32 = 0) -> ElementId { + return _HashStringWithOffset(MakeString(label), index, GetOpenElementId()) +} diff --git a/main.odin b/main.odin index eda9e16..dd515c2 100644 --- a/main.odin +++ b/main.odin @@ -10,11 +10,6 @@ import "base:runtime" import "core:strings" import "core:fmt" -WINDOW_WIDTH :: 1280 -WINDOW_HEIGHT :: 720 -WINDOW_FRAMERATE :: 30 -WINDOW_CAPTION :: "Transformation Visualizer" - when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 { @(private="file") web_context: runtime.Context diff --git a/program.odin b/program.odin index dd0b77d..b8ac268 100644 --- a/program.odin +++ b/program.odin @@ -1,3 +1,82 @@ +package main + +import rl "libraries/raylib" +import "core:fmt" +import "core:strings" +import "core:mem" +import "base:runtime" + +WINDOW_WIDTH :: 1280 +WINDOW_HEIGHT :: 720 +WINDOW_FRAMERATE :: 30 +WINDOW_CAPTION :: "Transformation Visualizer" + +v2 :: [2]f32 +rect2 :: rl.Rectangle + +UiElementType :: enum { + Input, + Button, +} + +UiElementData :: union { + UiButtonData, +} + +UiButtonData :: struct { + label: cstring, +} + +UiElement :: struct { + area: rect2, + type: UiElementType, + data: UiElementData, +} + +UiState :: struct { + origin, position: v2, + same_line: bool, + style: UiStyle, + elements: [dynamic]UiElement, +} + +UiStyle :: struct { + margin, padding: f32, +} + +ui_button :: proc(state: ^UiState, size: v2, data: UiButtonData) { + element := UiElement{area = {**state.position, **size}, type = .Button, data = data} + if state.same_line { + state.position.x += size.x + state.style.padding + state.same_line = false + } else { + state.position.y += size.y + state.style.padding + } + append(&state.elements, element) +} + +ui_same_line :: proc(state: ^UiState) { + state.same_line = true +} + +ui_start :: proc(state: ^UiState) { + clear(&state.elements) + state.position = state.origin + state.style.margin +} + +ui_end :: proc(state: UiState) -> []UiElement { + return state.elements[:] +} + +ui_init :: proc(state: ^UiState, style: UiStyle, origin: v2, allocator: mem.Allocator) { + state^ = { + origin = origin, + position = origin, + style = style, + elements = make(type_of(state.elements), 0, 512, allocator) + } +} + init :: proc() { rl.SetTraceLogLevel(.WARNING) rl.SetConfigFlags({.WINDOW_RESIZABLE, .VSYNC_HINT}) @@ -6,10 +85,34 @@ init :: proc() { } update :: proc() { + ui_style := UiStyle{margin = 4.0, padding = 4.0} + ui_state: UiState + ui_init(&ui_state, ui_style, {0, 0}, context.temp_allocator) + ui_start(&ui_state) + ui_button_size := v2{192.0, 32.0} + ui_same_line(&ui_state) + ui_button(&ui_state, ui_button_size, {label = "Hi"}) + ui_same_line(&ui_state) + ui_button(&ui_state, ui_button_size, {label = "Hi"}) + ui_same_line(&ui_state) + ui_button(&ui_state, ui_button_size, {label = "Hi"}) + ui_elements := ui_end(ui_state) + rl.BeginDrawing() + defer rl.EndDrawing() rl.ClearBackground(rl.BLACK) - rl.DrawText("Hello world", 4, 4, 32, rl.WHITE) - rl.EndDrawing() + + for element in ui_elements { + fmt.println(element) + switch element.type { + case .Button: + data := element.data.(UiButtonData) + rl.GuiButton(element.area, data.label) + case .Input: + } + } + fmt.println() + free_all(context.temp_allocator) }