From 5aa61dcd6070108f179ab059def6ed1e10b51cfc Mon Sep 17 00:00:00 2001 From: Nic Barker Date: Fri, 23 Aug 2024 16:05:23 +1200 Subject: [PATCH] initial commit --- .gitignore | 6 + CMakeLists.txt | 7 + LICENSE.md | 22 + README.md | 1417 +++++++++ VERSION | 1 + clay.h | 2273 +++++++++++++++ examples/clay-official-website/CMakeLists.txt | 17 + examples/clay-official-website/build.sh | 17 + .../fonts/Calistoga-Regular.ttf | Bin 0 -> 47144 bytes .../fonts/Quicksand-Semibold.ttf | Bin 0 -> 18980 bytes .../clay-official-website/images/check_1.png | Bin 0 -> 1508 bytes .../clay-official-website/images/check_2.png | Bin 0 -> 1508 bytes .../clay-official-website/images/check_3.png | Bin 0 -> 1508 bytes .../clay-official-website/images/check_4.png | Bin 0 -> 1508 bytes .../clay-official-website/images/check_5.png | Bin 0 -> 1508 bytes .../images/declarative.png | Bin 0 -> 197794 bytes .../clay-official-website/images/renderer.png | Bin 0 -> 317532 bytes examples/clay-official-website/index.html | 688 +++++ examples/clay-official-website/main.c | 349 +++ .../CMakeLists.txt | 33 + .../raylib-sidebar-scrolling-container/main.c | 168 ++ .../resources/Roboto-Regular.ttf | Bin 0 -> 168260 bytes .../resources/RobotoMono-Medium.ttf | Bin 0 -> 87172 bytes .../resources/profile-picture.png | Bin 0 -> 103413 bytes generator/array_add.template.c | 7 + generator/array_define.template.c | 10 + generator/array_get.template.c | 3 + generator/array_remove_swapback.template.c | 9 + generator/array_set.template.c | 11 + generator/generate_templates.js | 69 + renderers/raylib/clay_renderer_raylib.c | 228 ++ renderers/raylib/raylib.h | 1689 +++++++++++ renderers/raylib/raymath.h | 2583 +++++++++++++++++ renderers/web/build-wasm.sh | 13 + .../web/canvas2d/clay-canvas2d-renderer.html | 480 +++ renderers/web/clay.wasm | Bin 0 -> 17551 bytes renderers/web/html/clay-html-renderer.html | 522 ++++ 37 files changed, 10622 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 LICENSE.md create mode 100644 README.md create mode 100644 VERSION create mode 100644 clay.h create mode 100644 examples/clay-official-website/CMakeLists.txt create mode 100755 examples/clay-official-website/build.sh create mode 100644 examples/clay-official-website/fonts/Calistoga-Regular.ttf create mode 100644 examples/clay-official-website/fonts/Quicksand-Semibold.ttf create mode 100644 examples/clay-official-website/images/check_1.png create mode 100644 examples/clay-official-website/images/check_2.png create mode 100644 examples/clay-official-website/images/check_3.png create mode 100644 examples/clay-official-website/images/check_4.png create mode 100644 examples/clay-official-website/images/check_5.png create mode 100644 examples/clay-official-website/images/declarative.png create mode 100644 examples/clay-official-website/images/renderer.png create mode 100644 examples/clay-official-website/index.html create mode 100644 examples/clay-official-website/main.c create mode 100644 examples/raylib-sidebar-scrolling-container/CMakeLists.txt create mode 100644 examples/raylib-sidebar-scrolling-container/main.c create mode 100644 examples/raylib-sidebar-scrolling-container/resources/Roboto-Regular.ttf create mode 100644 examples/raylib-sidebar-scrolling-container/resources/RobotoMono-Medium.ttf create mode 100644 examples/raylib-sidebar-scrolling-container/resources/profile-picture.png create mode 100644 generator/array_add.template.c create mode 100644 generator/array_define.template.c create mode 100644 generator/array_get.template.c create mode 100644 generator/array_remove_swapback.template.c create mode 100644 generator/array_set.template.c create mode 100644 generator/generate_templates.js create mode 100644 renderers/raylib/clay_renderer_raylib.c create mode 100644 renderers/raylib/raylib.h create mode 100644 renderers/raylib/raymath.h create mode 100755 renderers/web/build-wasm.sh create mode 100644 renderers/web/canvas2d/clay-canvas2d-renderer.html create mode 100755 renderers/web/clay.wasm create mode 100644 renderers/web/html/clay-html-renderer.html diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e49d685 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +cmake-build-debug/ +cmake-build-release/ +.DS_Store +.idea/ +build/ +node_modules/ \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..86955ec --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.28) +project(clay C) + +set(CMAKE_C_STANDARD 99) + +add_subdirectory("examples/raylib-sidebar-scrolling-container") +add_subdirectory("examples/clay-official-website") \ No newline at end of file diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..2968c61 --- /dev/null +++ b/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. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0d2c071 --- /dev/null +++ b/README.md @@ -0,0 +1,1417 @@ +# Clay +**_Clay_** (short for **C Layout**) is a high performance 2D UI layout library. + +### Major Features +- Microsecond layout performance +- Flex-box like layout model for complex, responsive layouts including text wrapping, scrolling containers and aspect ratio scaling +- Single ~2k LOC **clay.h** file with **zero** dependencies (including no standard library) +- Wasm support: compile with clang to a 15kb uncompressed **.wasm** file for use in the browser +- Static arena based memory use with no malloc / free, and low total memory overhead (e.g. ~3.5mb for 8192 layout elements). +- React-like nested declarative syntax +- Renderer agnostic: outputs a sorted list of rendering primitives that can be easily composited in any 3D engine, and even compiled to HTML (examples provided) + +Take a look at the [clay website](https://nicbarker.com/clay) for an example of clay compiled to wasm and running in the browser, or others in the [examples directory](https://github.com/nicbarker/clay/tree/main/examples). + +A screenshot of a code IDE with lots of visual and textual elements + +_An example GUI application built with clay_ + +## Quick Start + +1. Download or clone clay.h and include it. + +```C +#include "clay.h" +``` + +2. Ask clay for how much static memory it needs using [Clay_MinMemorySize()](#clay_minmemorysize), create an Arena for it to use with [Clay_CreateArenaWithCapacityAndMemory(size, void *memory)](#clay_createarenawithcapacityandmemory), and initialize it with [Clay_Initialize(arena)](#clay_initialize). + +```C +// Note: malloc is only used here as an example, any allocator that provides +// a pointer to addressable memory of at least totalMemorySize will work +uint64_t totalMemorySize = Clay_MinMemorySize(); +Clay_Arena arena = Clay_CreateArenaWithCapacityAndMemory(totalMemorySize, malloc(totalMemorySize)); +Clay_Initialize(arena); +``` + +3. Provide a `MeasureText(text, config)` function pointer with [Clay_SetMeasureTextFunction(function)](#clay_setmeasuretextfunction) so that clay can measure and wrap text. + +```C +// Example measure text function +static inline Clay_Dimensions MeasureText(Clay_String *text, Clay_TextElementConfig *config) { + // Clay_TextElementConfig contains members such as fontId, fontSize, letterSpacing etc + // Note: Clay_String->chars is not guaranteed to be null terminated +} + +// Tell clay how to measure text +Clay_SetMeasureTextFunction(MeasureText); +``` + +4. **Optional** - Call [Clay_SetPointerPosition(pointerPosition)](#clay_setpointerposition) if you want to use mouse interactions. + +```C +// Update internal pointer position for handling mouseover / click / touch events +Clay_SetPointerPosition((Clay_Vector2) { mousePositionX, mousePositionY }); +``` + +5. Call [Clay_BeginLayout(screenWidth, screenHeight)](#clay_beginlayout) and declare your layout using the provided macros. + +```C +const Clay_Color COLOR_LIGHT = (Clay_Color) {224, 215, 210, 255}; +const Clay_Color COLOR_RED = (Clay_Color) {168, 66, 28, 255}; +const Clay_Color COLOR_ORANGE = (Clay_Color) {225, 138, 50, 255}; + +// Layout config is just a struct that can be declared statically, or inline +Clay_LayoutConfig sidebarItemLayout = (Clay_LayoutConfig) { + .sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(50) }, +}; + +// Re-useable components are just normal functions +void SidebarItemComponent(int index) { + CLAY_RECTANGLE(CLAY_IDI("SidebarBlob", index), sidebarItemLayout, CLAY_RECTANGLE_CONFIG(.color = COLOR_ORANGE), {}); +} + +// An example function to begin the "root" of your layout tree +Clay_RenderCommandArray CreateLayout() { + Clay_BeginLayout(windowWidth, windowHeight); + + // An example of laying out a UI with a fixed width sidebar and flexible width main content + CLAY_RECTANGLE(CLAY_ID("OuterContainer"), CLAY_LAYOUT(.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()}, .padding = {16, 16}, .childGap = 16), CLAY_RECTANGLE_CONFIG(.color = {250,250,255,255}) { + CLAY_RECTANGLE(CLAY_ID("SideBar"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_GROW() }, .padding = {16, 16}, .childGap = 16), CLAY_RECTANGLE_CONFIG(.color = COLOR_LIGHT), { + CLAY_RECTANGLE(CLAY_ID("ProfilePictureOuter"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }, .padding = {16, 16}, .childGap = 16, .childAlignment = { .y = CLAY_ALIGN_Y_CENTER }), CLAY_RECTANGLE_CONFIG(.color = COLOR_RED), { + CLAY_IMAGE(CLAY_ID("ProfilePicture"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(60), .height = CLAY_SIZING_FIXED(60) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .height = 60, .width = 60), {}); + CLAY_TEXT(CLAY_ID("ProfileTitle"), CLAY_STRING("Clay - UI Library"), CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {255, 255, 255, 255})); + }); + + // Standard C code like loops etc work inside components + for (int i = 0; i < 5; i++) { + SidebarItemComponent(i); + } + }); + + CLAY_RECTANGLE(CLAY_ID("MainContent"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_GROW() }), CLAY_RECTANGLE_CONFIG(.color = COLOR_LIGHT), {}); + }); + // ... +}); +``` + +6. Call [Clay_EndLayout(screenWidth, screenHeight)](#clay_endlayout) and process the resulting [Clay_RenderCommandArray](#clay_rendercommandarray) in your choice of renderer. + +```C +Clay_RenderCommandArray renderCommands = Clay_EndLayout(windowWidth, windowHeight); + +for (int i = 0; i < renderCommands.length; i++) { + Clay_RenderCommand *renderCommand = &renderCommands.internalArray[i]; + + switch (renderCommand->commandType) { + case CLAY_RENDER_COMMAND_TYPE_RECTANGLE: { + DrawRectangle( + renderCommand->boundingBox, + renderCommand->config.rectangleElementConfig->color); + } + // ... Implement handling of other command types + } +} +``` + +The above example, rendered correctly will look something like the following: + +![Clay Example](https://github.com/user-attachments/assets/1928c6d4-ada9-4a4c-a3d1-44fe9b23b3bd) + +In summary, the general order of steps is: + +1. [Clay_SetPointerPosition(pointerPosition)](#clay_setpointerposition) +2. [Clay_UpdateScrollContainers(isPointerActive, scrollDelta, deltaTime)](#clay_updatescrollcontainers) +3. [Clay_BeginLayout(screenWidth, screenHeight)](#clay_beginlayout) +4. Declare your layout with the provided [Element Macros](#element-macros) +5. [Clay_EndLayout(screenWidth, screenHeight)](#clay_endlayout) +6. Render the results using the outputted [Clay_RenderCommandArray](#clay_rendercommandarray) + +## High Level Documentation + +### Building UI Hierarchies +Clay UI hierarchies are built using C macros that allow _nested_ declarations, similar to other declarative UI systems like HTML. + +This means that child elements are declared _inside_ their parent elements. The common way to do this with clay element macros is to pass a block: `{}` as the `children` argument, and define child components inside the braces. +```C +// Parent element +CLAY_CONTAINER(id, layout, { + // Child element 1 + CLAY_TEXT(id, text, config); + // Child element 2 + CLAY_RECTANGLE(id, layout, config, { + // etc + }); +}); +``` + +However, unlike HTML and other declarative DSLs, these macros are just C. As a result, you can use arbitrary C code such as loops, functions and conditions inside your layout declaration code: +```C +// Re-usable "components" are just functions that declare more UI +void ButtonComponent(Clay_String buttonText) { + CLAY_RECTANGLE(id, layout, config, { + CLAY_TEXT(id, buttonText, config); + }); +} + +// Parent element +CLAY_CONTAINER(id, layout, { + // Render a bunch of text elements + for (int i = 0; i < textArray.length; i++) { + CLAY_TEXT(id, textArray.elements[i], config); + } + // Only render this element if we're on a mobile screen + if (isMobileScreen) { + CLAY_CONTAINER(id, layout, { + // etc + }); + } + // Re-usable components + ButtonComponent(CLAY_STRING("Click me!")); + ButtonComponent(CLAY_STRING("No, click me!")); +}); +``` + +### Configuring Layout and Styling UI Elements +Many of the element macros in Clay take a `Clay_LayoutConfig` as the second argument. Clay provides a convenience macro, [CLAY_LAYOUT()](#clay_layout) for easy construction of element styles. +```C +CLAY_CONTAINER(id, CLAY_LAYOUT(.padding = {.x = 8, .y = 8}, .backgroundColor = {120, 120, 120, 255}), { + // ... +}); +``` +This macro isn't magic - all it's doing is wrapping the standard designated initializer syntax and adding the result to an internal array. e.g. `(Clay_LayoutConfig) { .padding = { .x = 8, .y = 8 } ...`. + +See the [Clay_LayoutConfig](#clay_layout) API for the full list of options. + +A `Clay_LayoutConfig` struct can be defined in file scope or elsewhere, as long as the lifetime ends after `EndLayout` is called. +```C +// Define a style in the global / file scope +Clay_LayoutConfig reusableStyle = (Clay_LayoutConfig) {.backgroundColor = {120, 120, 120, 255}}; + +CLAY_CONTAINER(id, &reusableStyle, { + // ... +}); +``` + +Some of the other element macros, such as [CLAY_TEXT()](#clay_text) and [CLAY_RECTANGLE()](#clay_rectangle) take an element-specific config object as their 3rd argument. These config objects also have convenience macros for constructing them, generally of the form [CLAY_TEXT_CONFIG()](#clay_text_config) or [CLAY_RECTANGLE_CONFIG()](#clay_rectangle_config): + +```C +CLAY_TEXT(id, CLAY_STRING("button text"), CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_LATO, .textColor = {255, 255, 255, 255})); +``` + +See the [Full API](#api) for details on the specific config macros. + +### Element IDs + +All element macros take a `uint32_t` ID as their first argument. Clay provides the [CLAY_ID()](#clay_id) macro to generate these IDs as string hashes: +```C +// Will always produce the same ID from the same input string +CLAY_CONTAINER(CLAY_ID("OuterContainer"), style, {}); +``` + +To avoid having to construct dynamic strings at runtime to differentiate ids, clay provides the [CLAY_IDI(string, index)](#clay_idi) macro to generate different ids from a single input string. Think of IDI as "**ID** + **I**ndex" +```C +// This is the equivalent of calling CLAY_ID("Item0"), CLAY_ID("Item1") etc +for (int index = 0; index < items.length; index++) { + CLAY_CONTAINER(CLAY_IDI("Item", index), style, {}); +} +``` + +**_Generally, you should try to keep IDs unique if possible._** + +This ID is used for querying mouse / pointer events, and will be forwarded to the final `Clay_RenderCommandArray` for use in retained mode UIs. Using duplicate IDs may cause some functionality to misbehave (i.e. if you're trying to attach a floating container to a specific element with ID that is duplicated, it may not attach to the one you expect) + +### Mouse, Touch and Pointer Interactions + +Clay provides a very simple unified API for handling mouse and pointer interactions, with specific handling left to user code. + +All pointer interactions depend on the function `void Clay_SetPointerPosition(Clay_Vector2 position)` being called after each mouse position update and before any other clay functions. + +The function `bool Clay_PointerOver(uint32_t id)` takes an element id that was used during layout creation and returns a bool representing whether the current pointer position is within its bounding box. +```C +// Reminder: Clay_SetPointerPosition must be called before functions that rely on pointer position otherwise it will have no effect +Clay_Vector2 mousePosition = { x, y }; +Clay_SetPointerPosition(mousePosition); +// ... +// If profile picture was clicked +if (mouseButtonDown(0) && Clay_PointerOver(CLAY_ID("ProfilePicture"))) { + // Handle profile picture clicked +} +``` + +Querying `Clay_PointerOver` also works _during_ layout construction, and can be used as a convenient way for applying "hover" states, for example: + +```C +// Reminder: Clay_SetPointerPosition must be called before functions that rely on pointer position otherwise it will have no effect +Clay_Vector2 mousePosition = { x, y }; +Clay_SetPointerPosition(mousePosition); +// ... +uint32_t buttonId = CLAY_ID("HeaderButton"); +// An orange button that turns blue when hovered +CLAY_CONTAINER(buttonId, CLAY_LAYOUT(.backgroundColor = Clay_PointerOver(buttonId) ? COLOR_BLUE : COLOR_ORANGE), { + CLAY_TEXT(CLAY_IDI("Button", index), text, &headerTextConfig); +}); +``` +Note that the bounding box queried by `Clay_PointerOver` is from the last frame. This shouldn't make a difference except in the case of animations that move at high speed. +If this is an issue for you, performing layout twice per frame with the same data will give you the correct interaction the second time. + +### Scrolling Containers + +Scrolling containers are defined with the `CLAY_SCROLL_CONTAINER` element macro and function just like normal containers, however to make scroll containers respond to mouse wheel and scroll events, two functions need to be called: +```C +// Reminder: Clay_SetPointerPosition must be called before Clay_UpdateScrollContainers otherwise it will have no effect +Clay_Vector2 mousePosition = { x, y }; +Clay_SetPointerPosition(mousePosition); +// Clay_UpdateScrollContainers needs to be called before Clay_BeginLayout for the position to avoid a 1 frame delay +Clay_UpdateScrollContainers( + true, // Did the mouse click or touch occur this frame? + scrollDelta, // Clay_Vector2 scrollwheel / trackpad scroll x and y delta this frame + float deltaTime, // Time since last frame in seconds as a float e.g. 8ms is 0.008f +); +// ... +``` + +More specific details can be found in the full [Scroll Container API](#clay_scroll_container). + +### Floating Containers ("Absolute" Positioning) + +All standard elements in clay are laid out on top of, and _within_ their parent, positioned according to their parent's layout rules, and affect the positioning and sizing of siblings. + +**"Floating"** elements are defined with the `CLAY_FLOATING_CONTAINER` element macro and don't affect the parent they are defined in, or the position of their siblings. +They also have a **z-index**, and as a result can intersect and render over the top of other elements. +Aside from positioning, `CLAY_FLOATING_CONTAINER` elements function like standard `CLAY_CONTAINER` elements. + +A classic example use case for floating elements is tooltips and modals. + +```C +// The two text elements will be laid out top to bottom, and the floating container +// will be attached to "Outer" +CLAY_CONTAINER(CLAY_ID("Outer"), CLAY_LAYOUT(.layoutDirection = TOP_TO_BOTTOM), { + CLAY_TEXT(CLAY_ID("Button"), text, &headerTextConfig); + CLAY_FLOATING_TEXT(CLAY_ID("Tooltip"), &CLAY_LAYOUT_DEFAULT, CLAY_FLOATING_CONFIG); + CLAY_TEXT(CLAY_ID("Button"), text, &headerTextConfig); +}); +``` + +More specific details can be found in the full [Floating Container API](#clay_floating_container). + +### Laying Out Your Own Custom Elements + +Clay only supports a simple set of UI element primitives, such as rectangles, text and images. Clay provides a simple, singular API for layout out custom elements: +```C +// Extend CLAY_CUSTOM_ELEMENT_CONFIG with your custom data +#define CLAY_EXTEND_CONFIG_CUSTOM struct t_CustomElementData customData; +// Extensions need to happen _before_ the clay include +#include "clay.h" + +// A rough example of how you could handle laying out 3d models in your UI +typedef struct t_CustomElementData { + CustomElementType type; + union { + Model model; + Video video; + // ... + }; +} CustomElementData; + +Model myModel = Load3DModel(filePath); +CustomElement modelElement = (CustomElement) { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel } +// ... +CLAY_CONTAINER(id, style, { + // This config is type safe and contains the CustomElementData struct + CLAY_CUSTOM_ELEMENT(id, style, CLAY_CUSTOM_ELEMENT_CONFIG(.customData = { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel })) +}); + +// Later during your rendering +switch (renderCommand->commandType) { + // ... + case CLAY_RENDER_COMMAND_TYPE_CUSTOM: { + // Your extended struct is passed through + CustomElementData *data = renderCommand->elementConfig.customElementConfig->customData; + if (!customElement) continue; + switch (customElement->type) { + case CUSTOM_ELEMENT_TYPE_MODEL: { + // Render your 3d model here + break; + } + case CUSTOM_ELEMENT_TYPE_VIDEO: { + // Render your video here + break; + } + // ... + } + break; + } +} +``` + +More specific details can be found in the full [Custom Container API](#clay_custom_element). + +### Retained Mode Rendering +Clay was originally designed for [Immediate Mode](https://www.youtube.com/watch?v=Z1qyvQsjK5Y) rendering - where the entire UI is redrawn every frame. This may not be possible with your platform, renderer design or performance constraints. + +There are some general techniques that can be used to integrate clay into a retained mode rendering system: + +- `Clay_RenderCommand` includes the `uint32_t id` that was used to declare the element. If unique ids are used, these can be mapped to persistent graphics objects across multiple frames / layouts. +- Render commands are culled automatically to only currently visible elements, and `Clay_RenderCommand` is a small enough struct that you can simply compare the memory of two render commands with matching IDs to determine if the element is "dirty" and needs to be re-rendered or updated. + +For a worked example, see the provided [HTML renderer](https://github.com/nicbarker/clay/blob/main/renderers/web/html-canvas/index.html). This renderer converts clay layouts into persistent HTML documents with minimal changes per frame. + +### Visibility Culling +Clay provides a built-in visibility-culling mechanism that is **enabled by default**. It will only output render commands for elements that are visible - that is: +- At least one pixel of their bounding box is inside the viewport +- Their rendering color has an alpha value > zero, for example `renderCommand.rectangle.color` or `renderCommand.text.color`. + +This culling mechanism can be disabled via the use of the `#define CLAY_DISABLE_CULLING` directive. See [Preprocessor Directives](#preprocessor-directives) for more information. + +### Preprocessor Directives +Clay supports C preprocessor directives to modulate functionality at compile time. These can be set either in code using `#define CLAY_DISABLE_CULLING` or on the command line when compiling using the appropriate compiler specific arguments, e.g. `clang -DCLAY_DISABLE_CULLING main.c ...` + +The supported directives are: + +- `CLAY_MAX_ELEMENT_COUNT` - Controls the maximum number of clay elements that memory is pre-allocated for. Defaults to **8192**, which should be more than enough for the majority of use cases. Napkin math is ~450 bytes of memory overhead per element (8192 elements is ~3.5mb of memory) +- `CLAY_DISABLE_CULLING` - Disables [Visibility Culling](#visibility-culling) of render commands. +- `CLAY_WASM` - Required when targeting Web Assembly. +- `CLAY_OVERFLOW_TRAP` - By default, clay will continue to allow function calls without crashing even when it exhausts all its available pre-allocated memory. This can produce erroneous layout results that are difficult to interpret. If `CLAY_OVERFLOW_TRAP` is defined, clay will raise a `SIGTRAP` signal that will be caught by your debugger. Relies on `signal.h` being available in your environment. +- `CLAY_DEBUG` - Used for debugging clay's internal implementation. Useful if you want to modify or debug clay, or learn how things work. It enables a number of debug features such as preserving source strings for has IDs to make debugging easier. +- `CLAY_EXTEND_CONFIG_RECTANGLE` - Provide additional struct members to `CLAY_RECTANGLE_CONFIG` that will be passed through with output render commands. +- `CLAY_EXTEND_CONFIG_TEXT` - Provide additional struct members to `CLAY_TEXT_CONFIG` that will be passed through with output render commands. +- `CLAY_EXTEND_CONFIG_IMAGE` - Provide additional struct members to `CLAY_IMAGE_CONFIG` that will be passed through with output render commands. +- `CLAY_EXTEND_CONFIG_CUSTOM` - Provide additional struct members to `CLAY_IMAGE_CONFIG` that will be passed through with output render commands. + +# API + +### Naming Conventions + +- "**CAPITAL_LETTERS()**" are used for macros. +- "**Clay__**" ("Clay" followed by **double** underscore) is used for internal functions that are not intended for use and are subject to change. +- "**Clay_**" ("Clay" followed by **single** underscore) is used for external functions that can be called by the user. + +## Public Functions + +### Lifecycle for public functions + +**At startup / initialization time, run once** +`Clay_MinMemorySize` -> `Clay_CreateArenaWithCapacityAndMemory` -> `Clay_SetMeasureTextFunction` -> `Clay_Initialize` + +**Each Frame** +`Clay_SetPointerPosition` -> `Clay_UpdateScrollContainers` -> `Clay_BeginLayout` -> `CLAY_CONTAINER() etc...` -> `Clay_EndLayout` + +### Clay_MinMemorySize + +`uint32_t Clay_MinMemorySize()` + +Returns the minimum amount of memory **in bytes** that clay needs to accomodate the current [CLAY_MAX_ELEMENT_COUNT](#preprocessor-directives). + +### Clay_CreateArenaWithCapacityAndMemory + +`Clay_Arena Clay_CreateArenaWithCapacityAndMemory(uint32_t capacity, void *offset)` + +Creates a `Clay_Arena` struct with the given capacity and base memory pointer, which can be passed to [Clay_Initialize](#clay_initialize). + +### Clay_SetMeasureTextFunction + +`void Clay_SetMeasureTextFunction(Clay_Dimensions (*measureTextFunction)(Clay_String *text, Clay_TextElementConfig *config))` + +Takes a pointer to a function that can be used to measure the `width, height` dimensions of a string. Used by clay during layout to determine [CLAY_TEXT](#clay_text) element sizing and wrapping. +**Note: It is essential that this function is as fast as possible.** For text heavy use-cases this function is called many times, and despite the fact that clay caches text measurements internally, it can easily become the dominant overall layout cost if the provided function is slow. **This is on the hot path!** + +### Clay_Initialize + +`void Clay_Initialize(Clay_Arena arena)` + +Takes a `Clay_Arena` and initializes the internal memory mapping. + +### Clay_SetPointerPosition + +`void Clay_SetPointerPosition(Clay_Vector2 position)` + +Sets the internal pointer position (i.e. current mouse / touch position) and recalculates overlap info, which is used for mouseover / click calculation (via [Clay_PointerOver](#clay_pointerover) and updating scroll containers with [Clay_UpdateScrollContainers](#clay_updatescrollcontainers) + +### Clay_UpdateScrollContainers + +`void Clay_UpdateScrollContainers(bool isPointerActive, Clay_Vector2 scrollDelta, float deltaTime)` + +This function handles scrolling of containers. It responds to both `scrollDelta`, which represents mouse wheel or trackpad scrolling this frame, as well as "touch scrolling" on mobile devices. + +Touch scrolling only occurs if the `isPointerActive` parameter is `true`, **and** [Clay_SetPointerPosition](#clay_setpointerposition) has been called this frame. As a result, you can simply always call it with `false` as the first argument if you want to disable touch scrolling. + +`deltaTime` is the time **in seconds** since the last frame (e.g. 0.016 is **16 milliseconds**), and is used to normalize & smooth scrolling across different refresh rates. + +### Clay_BeginLayout + +`void Clay_BeginLayout(int screenWidth, int screenHeight)` + +Prepares clay to calculate a new layout. Called each frame / layout **before** any of the [Element Macros](#element-macros). `screenWidth` and `screenHeight` don't neccessarily have to be the screen or window height - you can use clay to lay out an arbitrary sub-section of a window. + +### Clay_EndLayout + +`Clay_RenderCommandArray Clay_EndLayout(int screenWidth, int screenHeight)` + +Ends declaration of element macros and calculates the results of the currrent layout. Renders a [Clay_RenderCommandArray](#clay_rendercommandarrray) containing the results of the layout calculation. + +### Clay_PointerOver + +`bool Clay_PointerOver(uint32_t id)` + +Returns `true` if the pointer position previously set with `Clay_SetPointerPosition` is inside the bounding box of the layout element with the provided `id`. Note: this is based on the element's position from the **last** frame. If frame-accurate pointer overlap detection is required, perhaps in the case of significant change in UI layout between frames, you can simply run your layout code twice that frame. The second call to `Clay_PointerOver` will be frame-accurate. + +## Element Macros + +### CLAY_CONTAINER +**Usage** + +`CLAY_CONTAINER(uint32_t id, Clay_LayoutConfig *layoutConfig, children);` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_CONTAINER()` -> `Clay_EndLayout()` + +**Notes** + +**CONTAINER** is a generic rectangular container that supports child elements. It uses a [Clay_LayoutConfig](#clay_layout) for styling and layout. + +**Examples** +```C +// Define a container with 16px of x and y padding +CLAY_CONTAINER(CLAY_ID("SideBar"), CLAY_LAYOUT(.padding = {16, 16}), { + // A nested child container + CLAY_CONTAINER(CLAY_ID("SideBar"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 16), { + // Children laid out top to bottom + }); +}); +``` + +**Rendering** + +`CLAY_CONTAINER` elements will not generate any render commands. + +### CLAY_TEXT +**Usage** + +`CLAY_TEXT(uint32_t id, Clay_String textContents, Clay_TextElementConfig *textConfig);` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_TEXT()` -> `Clay_EndLayout()` + +**Notes** + +**TEXT** is a measured, auto-wrapped text element. It uses [Clay_TextElementConfig]() to configure text specific options. + +Note that `Clay_TextElementConfig` uses `uint32_t fontId`. Font ID to font asset mapping is managed in user code and passed to render commands. + +**Examples** + +```C +// Define a font somewhere in your code +const uint32_t FONT_ID_LATO = 3; +// .. +CLAY_TEXT(CLAY_ID("Username"), CLAY_STRING("John Smith"), CLAY_TEXT_CONFIG(.fontId = FONT_ID_LATO, .fontSize = 24, .textColor = {255, 0, 0, 255})); +// Rendering example +Font fontToUse = LoadedFonts[renderCommand->elementConfig.textElementConfig->fontId]; +``` + +**Rendering** + +Element is subject to [culling](#visibility-culling). Otherwise, multiple `Clay_RenderCommand`s with `commandType = CLAY_RENDER_COMMAND_TYPE_TEXT` may be created, one for each wrapped line of text. + +`Clay_RenderCommand.textContent` will be populated with a `Clay_String` _slice_ of the original string passed in (i.e. wrapping doesn't reallocate, it just returns a `Clay_String` pointing to the start of the new line with a `length`) + +### CLAY_IMAGE +**Usage** + +`CLAY_IMAGE(id, layoutConfig, imageConfig, children);` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_IMAGE()` -> `Clay_EndLayout()` + +**Notes** + +**IMAGE_CONTAINER** is a used to layout images, and can optionally have children.It uses [Clay_LayoutConfig](#clay_layout) for styling and layout, and [Clay_ImageElementConfig]() to configure image specific options. + +**Examples** + +```C +// Load an image somewhere in your code +Image profilePicture = LoadImage("profilePicture.png"); +// .. +CLAY_IMAGE(CLAY_ID("ProfilePicture"), &CLAY_LAYOUT_DEFAULT, CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .height = 60, .width = 60), {}); +// Rendering example +Image *imageToRender = renderCommand->elementConfig.imageElementConfig->imageData; +``` + +**Rendering** + +Element is subject to [culling](#visibility-culling). Otherwise, a single `Clay_RenderCommand`s with `commandType = CLAY_RENDER_COMMAND_TYPE_IMAGE` will be created. The user will need to access `renderCommand->elementConfig.imageElementConfig->imageData` to retrieve image data referenced during layout creation. It's also up to the user to decide how / if they wish to blend `renderCommand->color` with the image. + +### CLAY_SCROLL_CONTAINER +**Usage** + +`CLAY_SCROLL_CONTAINER(id, layoutConfig, scrollConfig, children);` + +**Lifecycle** + +`Clay_SetPointerPosition()` -> `Clay_UpdateScrollContainers()` -> `Clay_BeginLayout()` -> `CLAY_SCROLL_CONTAINER()` -> `Clay_EndLayout()` + +**Notes** + +**SCROLL_CONTAINER** creates a masked container that allows layout of children to extend beyond its boundaries.It uses [Clay_LayoutConfig](#clay_layout) for styling and layout, and [Clay_ScrollElementConfig]() to configure scroll specific options. + +Note: In order to process scrolling based on pointer position and mouse wheel or touch interactions, you must call `Clay_SetPointerPosition()` and `Clay_UpdateScrollContainers()` _before_ calling `BeginLayout`. + +**Examples** + +```C +CLAY_SCROLL_CONTAINER(CLAY_ID("MainContent"), &CLAY_LAYOUT_DEFAULT, CLAY_SCROLL_CONFIG(.vertical = true), { + // Create child content with a fixed height of 5000 + CLAY_CONTAINER(CLAY_ID("ScrollInner"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(5000) }), {}); +}); +``` + +**Rendering** + +Scroll containers will result in two render commands: +- `commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_START`, which should create a rectangle mask with its `boundingBox` and is **not** subject to [culling](#visibility-culling) +- `commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_END`, which disables the previous rectangle mask and is **not** subject to [culling](#visibility-culling) + +### CLAY_BORDER_CONTAINER +**Usage** + +`CLAY_BORDER_CONTAINER(id, layoutConfig, borderConfig, children);` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_BORDER_CONTAINER()` -> `Clay_EndLayout()` + +**Notes** + +**BORDER_CONTAINER** is functionally identical to **CONTAINER** but also allows configuration of a border around the element. It uses [Clay_LayoutConfig](#clay_style) for styling and layout, and [Clay_BorderElementConfig]() to configure border specific options. + +**Examples** + +```C +// 300x300 container with a 1px red border around all the edges +CLAY_BORDER_CONTAINER(CLAY_ID("OuterBorder"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_FIXED(300)}), CLAY_BORDER_CONFIG_OUTSIDE(.color = COLOR_RED, .width = 1), { + // ... +}); + +// Container with a 3px yellow bottom border +CLAY_BORDER_CONTAINER(CLAY_ID("OuterBorder"), &CLAY_LAYOUT_DEFAULT, CLAY_BORDER_CONFIG(.bottom = { .color = COLOR_YELLOW, .width = 3 }), { + // ... +}); + +// Container with a 5px curved border around the edges, and a 5px blue border between all children laid out top to bottom +CLAY_BORDER_CONTAINER(CLAY_ID("OuterBorder"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM), CLAY_BORDER_CONFIG_ALL_RADIUS({ .color = COLOR_BLUE, .width = 5 }), { + // Child + // -- border will be here -- + // Child +}); +``` + +**Rendering** + +Element is subject to [culling](#visibility-culling). Otherwise, a single `Clay_RenderCommand` with `commandType = CLAY_RENDER_COMMAND_TYPE_BORDER` representing the container will be created. +Rendering of borders and rounded corners is left up to the user. See the provided [renderers]() for examples of how to draw borders using line and curve primitives. + +### CLAY_FLOATING_CONTAINER +**Usage** + +`CLAY_FLOATING_CONTAINER(id, layoutConfig, floatingConfig, children)` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_FLOATING_CONTAINER()` -> `Clay_EndLayout()` + +**Notes** + +**FLOATING_CONTAINER** defines an element that "floats" above other content. Typical use-cases include tooltips and modals. + +Floating containers: + +- With the [default configuration](), attach to the top left corner of their "parent" +- Don't affect the width and height of their parent +- Don't affect the positioning of sibling elements +- Depending on their z-index can appear above or below other elements, partially or completely occluding them +- Apart from positioning, function just like standard `CLAY_CONTAINER` elements - including expanding to fit their children, etc. + +The easiest mental model to use when thinking about floating containers is that they are a completely separate UI hierarchy, attached to a specific x,y point on their "parent". + +Floating elements use [Clay_LayoutConfig](#clay_style) for styling and layout, and [Clay_FloatingElementConfig]() to configure specific options. + +**Examples** + +```C +// Horizontal container with three option buttons +CLAY_CONTAINER(CLAY_ID("OptionsList"), CLAY_LAYOUT(.childGap = 16), { + CLAY_RECTANGLE(CLAY_IDI("Option", 1), CLAY_LAYOUT(.padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = COLOR_BLUE), { + CLAY_TEXT(CLAY_IDI("OptionText", 1), CLAY_STRING("Option 1"), CLAY_TEXT_CONFIG()); + }); + CLAY_RECTANGLE(CLAY_IDI("Option", 2), CLAY_LAYOUT(.padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = COLOR_BLUE), { + CLAY_TEXT(CLAY_IDI("OptionText", 2), CLAY_STRING("Option 2"), CLAY_TEXT_CONFIG()); + // Floating tooltip will attach above the "Option 2" container and not affect widths or positions of other elements + CLAY_FLOATING_CONTAINER(CLAY_ID("OptionTooltip"), &CLAY_LAYOUT_DEFAULT, CLAY_FLOATING_CONFIG(.zIndex = 1, .offset = {.x = 0, .y = -80}), { + CLAY_TEXT(CLAY_IDI("OptionTooltipText", 1), CLAY_STRING("Most popular!"), CLAY_TEXT_CONFIG()); + }); + }); + CLAY_RECTANGLE(CLAY_IDI("Option", 3), CLAY_LAYOUT(.padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = COLOR_BLUE), { + CLAY_TEXT(CLAY_IDI("OptionText", 3), CLAY_STRING("Option 3"), CLAY_TEXT_CONFIG()); + }); +}); + +// Floating containers can also be declared elsewhere in a layout, to avoid branching or polluting other UI +for (int i = 0; i < 1000; i++) { + CLAY_CONTAINER(CLAY_IDI("Option", i + 1), &CLAY_LAYOUT_DEFAULT, {}) { + // ... + } +} +// Note the use of "parentId". +// Floating tooltip will attach above the "Option 2" container and not affect widths or positions of other elements +CLAY_FLOATING_CONTAINER(CLAY_ID("OptionTooltip"), &CLAY_LAYOUT_DEFAULT, CLAY_FLOATING_CONFIG(.parentId = CLAY_IDI("Option", 2) .zIndex = 1, .offset = {.x = 0, .y = -80}), { + CLAY_TEXT(CLAY_IDI("OptionTooltipText", 1), CLAY_STRING("Most popular!"), CLAY_TEXT_CONFIG()); +}); +``` + +When using `.parentId`, the floating container can be declared anywhere after `BeginLayout` and before `EndLayout`. The target element matching the `.parentId` doesn't need to exist when `CLAY_FLOATING_CONTAINER` is called. + +**Rendering** + +`CLAY_FLOATING_CONTAINER` elements will not generate any render commands. + + +### CLAY_CUSTOM_ELEMENT +**Usage** + +`CLAY_CUSTOM_ELEMENT(uint32_t id, Clay_LayoutConfig *layoutConfig, Clay_CustomElementConfig *customElementConfig);` + +**Lifecycle** + +`Clay_BeginLayout()` -> `CLAY_CUSTOM_ELEMENT()` -> `Clay_EndLayout()` + +**Notes** + +**CUSTOM_ELEMENT** uses [Clay_LayoutConfig](#clay_style) for styling and layout, but has no children and allows the user to pass custom data to the renderer. + +**Examples** +```C +// Extend CLAY_CUSTOM_ELEMENT_CONFIG with your custom data +#define CLAY_EXTEND_CONFIG_CUSTOM struct t_CustomElementData customData; +// Extensions need to happen _before_ the clay include +#include "clay.h" + +// A rough example of how you could handle laying out 3d models in your UI +typedef struct t_CustomElementData { + CustomElementType type; + union { + Model model; + Video video; + // ... + }; +} CustomElementData; + +Model myModel = Load3DModel(filePath); +CustomElement modelElement = (CustomElement) { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel } +// ... +CLAY_CONTAINER(id, style, { + // This config is type safe and contains the CustomElementData struct + CLAY_CUSTOM_ELEMENT(id, style, CLAY_CUSTOM_ELEMENT_CONFIG(.customData = { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel })) +}); + +// Later during your rendering +switch (renderCommand->commandType) { + // ... + case CLAY_RENDER_COMMAND_TYPE_CUSTOM: { + // Your extended struct is passed through + CustomElementData *data = renderCommand->elementConfig.customElementConfig->customData; + if (!customElement) continue; + switch (customElement->type) { + case CUSTOM_ELEMENT_TYPE_MODEL: { + // Render your 3d model here + break; + } + case CUSTOM_ELEMENT_TYPE_VIDEO: { + // Render your video here + break; + } + // ... + } + break; + } +} +``` + +**Rendering** + +Element is subject to [culling](#visibility-culling). Otherwise, a single `Clay_RenderCommand` with `commandType = CLAY_RENDER_COMMAND_TYPE_CUSTOM` will be created. +The user will need to access `renderCommand.data.custom.customData` to retrieve custom data referenced during layout creation. + +## Config Macros + +A number of clay element macros take element-specific **config** structs. + +### CLAY_LAYOUT + +**CLAY_LAYOUT()** is used for configuring layout for most clay elements. + +**Struct API (Pseudocode)** + +```C +// CLAY_LAYOUT(.member = value) supports these options +Clay_LayoutConfig { + Clay_LayoutDirection layoutDirection = CLAY_LEFT_TO_RIGHT (default) | CLAY_TOP_TO_BOTTOM; + Clay_Padding padding { + float x; float y; + }; + uint16_t childGap; + Clay_ChildAlignment childAlignment { + .x = CLAY_ALIGN_X_LEFT (default) | CLAY_ALIGN_X_CENTER | CLAY_ALIGN_X_RIGHT; + .y = CLAY_ALIGN_Y_TOP (default) | CLAY_ALIGN_Y_CENTER | CLAY_ALIGN_Y_BOTTOM; + }; + Clay_Sizing sizing { // Recommended to use the provided macros here - see #sizing for more in depth explanation + .width = CLAY_SIZING_FIT(float min, float max) (default) | CLAY_SIZING_GROW(float min, float max) | CLAY_SIZING_FIXED(width) | CLAY_SIZING_PERCENT(float percent) + .height = CLAY_SIZING_FIT(float min, float max) (default) | CLAY_SIZING_GROW(float min, float max) | CLAY_SIZING_FIXED(height) | CLAY_SIZING_PERCENT(float percent) + }; // See CLAY_SIZING_GROW() etc for more details +}; +``` +As with all config macros, `CLAY_LAYOUT()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Fields** + +**`.layoutDirection`** - `Clay_LayoutDirection` + +`CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM)` + +Controls the axis / direction in which child elements are laid out. Available options are `CLAY_LEFT_TO_RIGHT` (default) and `CLAY_TOP_TO_BOTTOM`. + +_Did you know that "left to right" and "top to bottom" both have 13 letters?_ + +Screenshot 2024-08-22 at 11 10 27 AM + +--- + +**`.padding`** - `Clay_Padding` + +`CLAY_LAYOUT(.padding = { .x = 16, .y = 16 })` + +Controls horizontal and vertical white-space "padding" around the **outside** of child elements. + +Screenshot 2024-08-22 at 10 50 49 AM + +--- + +**`.childGap`** - `uint16_t` + +`CLAY_LAYOUT(.childGap = 16)` + +Controls the white-space **between** child elements as they are laid out. When `.layoutDirection` is `CLAY_LEFT_TO_RIGHT` (default), this will be horizontal space, whereas for `CLAY_TOP_TO_BOTTOM` it will be vertical space. + +Screenshot 2024-08-22 at 11 05 15 AM + +--- + +**`.childAlignment`** - `Clay_ChildAlignment` + +`CLAY_LAYOUT(.childAlignment = { .x = CLAY_ALIGN_X_LEFT, .y = CLAY_ALIGN_Y_CENTER })` + +Controls the alignment of children relative to the height and width of the parent container. Available options are: +```C +.x = CLAY_ALIGN_X_LEFT (default) | CLAY_ALIGN_X_CENTER | CLAY_ALIGN_X_RIGHT; +.y = CLAY_ALIGN_Y_TOP (default) | CLAY_ALIGN_Y_CENTER | CLAY_ALIGN_Y_BOTTOM; +``` + +Screenshot 2024-08-22 at 11 25 16 AM + +--- + +**`.sizing`** - `Clay_Sizing` + +`CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_PERCENT(0.5) })` + +Controls how final width and height of element are calculated. The same configurations are available for both the `.width` and `.height` axis. There are several options: + +- `CLAY_SIZING_FIT(float min, float max) (default)` - The element will be sized to fit its children (plus padding and gaps), up to `max`. If `max` is left unspecified, it will default to `FLOAT_MAX`. When elements are compressed to fit into a smaller parent, this element will not shrink below `min`. + +- `CLAY_SIZING_GROW(float min, float max)` - The element will grow to fill available space in its parent, up to `max`. If `max` is left unspecified, it will default to `FLOAT_MAX`. When elements are compressed to fit into a smaller parent, this element will not shrink below `min`. + +- `CLAY_SIZING_FIXED(float fixed)` - The final size will always be exactly the provided `fixed` value. Shorthand for `CLAY_SIZING_FIT(fixed, fixed)` + +- `CLAY_SIZING_PERCENT(float percent)` - Final size will be a percentage of parent size, minus padding and child gaps. `percent` is assumed to be a float between `0` and `1`. + +Screenshot 2024-08-22 at 2 10 33 PM + +Screenshot 2024-08-22 at 2 19 04 PM + + +**Example Usage** + +```C +CLAY_CONTAINER(CLAY_ID("Button"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_GROW() }, .padding = {16, 16}, .childGap = 16), { + // Children will be laid out vertically with 16px of padding around and between +}); +``` + +### CLAY_RECTANGLE_CONFIG + +**CLAY_RECTANGLE_CONFIG()** is used for configuring rendering for [CLAY_RECTANGLE()]() elements. The config will be passed through to render commands as `Clay_RenderCommand.config.rectangleElementConfig` + +**Struct API (Pseudocode)** + +```C +// CLAY_RECTANGLE_CONFIG(.member = value) supports these options +Clay_RectangleConfig { + Clay_Color color { + float r; float g; float b; float a; + }; + float cornerRadius; + + #ifdef CLAY_EXTEND_CONFIG_RECTANGLE + // Contents of CLAY_EXTEND_CONFIG_RECTANGLE will be pasted here + #endif +} +``` + +As with all config macros, `CLAY_RECTANGLE_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Extension** + +The underlying `Clay_RectangleElementConfig` can be extended with new members by using: +```C +#define CLAY_EXTEND_CONFIG_RECTANGLE float newField; +#include "clay.h" // Define your extension before including clay.h +``` + +**Fields** + +**`.color`** - `Clay_Color` + +`CLAY_RECTANGLE_CONFIG(.color = {120, 120, 120, 255})` + +Conventionally accepts `rgba` float values between 0 and 255, but interpretation is left up to the renderer and does not affect layout. + +--- + +**`.cornerRadius`** - `float` + +`CLAY_RECTANGLE_CONFIG(.cornerRadius = 16)` + +Defines the radius in pixels for the arc of rectangle corners (`0` is square, `rectangle.width / 2` is circular). + +Note that the `CLAY_CORNER_RADIUS(radius)` function-like macro is available to provide short hand for setting all four corner radii to the same value. e.g. `CLAY_BORDER_CONFIG(.cornerRadius = CLAY_CORNER_RADIUS(10))` + +### CLAY_TEXT_CONFIG + +**CLAY_TEXT_CONFIG()** is a macro used to create and store `Clay_TextElementConfig` structs, which are for configuring [CLAY_TEXT]() elements. The config used in declaration will be passed both as an argument to the user-provided `Clay_MeasureText(Clay_String *text, Clay_TextElementConfig *config)` function as well as the in the final output as `Clay_RenderCommand.config.textElementConfig`. + +**Struct API (Pseudocode)** + +```C +// CLAY_TEXT_CONFIG(.member = value) supports these options +Clay_TextElementConfig { + Clay_Color textColor { + float r; float g; float b; float a; + }; + uint16_t fontId; + uint16_t fontSize; + uint16_t letterSpacing; + uint16_t lineSpacing; + + #ifdef CLAY_EXTEND_CONFIG_TEXT + // Contents of CLAY_EXTEND_CONFIG_TEXT will be pasted here + #endif +}; +``` +As with all config macros, `CLAY_TEXT_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Extension** + +The underlying `Clay_TextElementConfig` can be extended with new members by using: +```C +#define CLAY_EXTEND_CONFIG_TEXT float newField; +#include "clay.h" // Define your extension before including clay.h +``` + +**Fields** + +**`.textColor`** + +`CLAY_TEXT_CONFIG(.textColor = {120, 120, 120, 255})` + +Conventionally accepts `rgba` float values between 0 and 255, but interpretation is left up to the renderer and does not affect layout. + +--- + +**`.fontId`** + +`CLAY_TEXT_CONFIG(.fontId = FONT_ID_LATO)` + +It's up to the user to load fonts and create a mapping from `fontId` to a font that can be measured and rendered. + +--- + +**`.fontSize`** + +`CLAY_TEXT_CONFIG(.fontSize = 16)` + +Font size is generally thought of as `x pixels tall`, but interpretation is left up to the user & renderer. + +--- + +**`.letterSpacing`** + +`CLAY_TEXT_CONFIG(.letterSpacing = 1)` + +`.letterSpacing` results in **horizontal** white space between individual rendered characters. + +--- + +**`.lineSpacing`** + +`CLAY_TEXT_CONFIG(.lineSpacing = 1)` + +`.lineSpacing` results in **vertical** white space between lines of text (from both `\n` characters and text wrapping) and will affect layout of parents and siblings. + +**Example Usage** +```C +// A 24px, red text element that says "John Smith" +CLAY_TEXT(CLAY_ID("Username"), CLAY_STRING("John Smith"), CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = 2, .textColor = {255, 0, 0, 255})); +``` + +### CLAY_IMAGE_CONFIG + +**CLAY_IMAGE_CONFIG()** is a macro used to create and store `Clay_ImageElementConfig` structs, which are for configuring [CLAY_IMAGE]() elements. The config will be passed through to render commands as `Clay_RenderCommand.config.imageElementConfig` + +**Struct API (Pseudocode)** + +```C +Clay_ImageElementConfig { + Clay_Dimensions sourceDimensions { + float width; float height; + }; + // -- + #ifndef CLAY_EXTEND_CONFIG_IMAGE + void * imageData; // Note: This field will be replaced if #define CLAY_EXTEND_CONFIG_IMAGE is specified + #else CLAY_EXTEND_CONFIG_IMAGE + // Contents of CLAY_EXTEND_CONFIG_IMAGE will be pasted here + #endif +}; +``` + +As with all config macros, `CLAY_IMAGE_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Extension** + +The underlying `Clay_ImageElementConfig` can be extended with new members by using: +```C +#define CLAY_EXTEND_CONFIG_IMAGE float newField; +#include "clay.h" // Define your extension before including clay.h +``` + +**Fields** + +**`.sourceDimensions`** - `Clay_Dimensions` + +`CLAY_IMAGE_CONFIG(.sourceDimensions = { 1024, 768 })` + +Used to perform **aspect ratio scaling** on the image element. As of this version of clay, aspect ratio scaling only applies to the `height` of an image (i.e. image height will scale with width growth and limitations, but width will not scale with height growth and limitations) + +--- + +**`.imageData`** - `void *` + +`CLAY_IMAGE_CONFIG(.imageData = &myImage)` + +`.imageData` is a generic void pointer that can be used to pass through image data to the renderer. **Note:** this field is generally not recommended for usage due to the lack of type safety, see `#define CLAY_EXTEND_CONFIG_IMAGE` in [Preprocessor Directives]() for an alternative. + +```C +// Load an image somewhere in your code +Image profilePicture = LoadImage("profilePicture.png"); +// Note that when rendering, .imageData will be void* type. +CLAY_IMAGE(CLAY_ID("ProfilePicture"), &CLAY_LAYOUT_DEFAULT, CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = { 60, 60 }), {}); + +// OR ---------------- + +// Extend CLAY_CUSTOM_IMAGE_CONFIG with your custom image format +#define CLAY_EXTEND_CONFIG_IMAGE struct t_Image image; +// Extensions need to happen _before_ the clay include +#include "clay.h" + +typedef struct t_Image { + ImageFormat format; + u8int_t *internalData; + // ... etc +} Image; + +// You can now use CLAY_IMAGE_CONFIG with your custom type and still have type safety & code completion +CLAY_IMAGE(CLAY_ID("ProfilePicture"), &CLAY_LAYOUT_DEFAULT, CLAY_IMAGE_CONFIG(.image = { .format = IMAGE_FORMAT_RGBA, .internalData = &imageData }, .sourceDimensions = { 60, 60 }), {}); +``` + +### CLAY_FLOATING_CONFIG + +**CLAY_FLOATING_CONFIG()** is a macro used to create and store `Clay_FloatingElementConfig` structs, which are for configuring [CLAY_FLOATING_CONTAINER]() elements. + +**Struct Definition (Pseudocode)** + +```C +typedef struct +{ + Clay_Vector2 offset { + float x, float y + }; + Clay_Dimensions expand { + float width, float height + }; + uint16_t zIndex; + uint32_t parentId; + Clay_FloatingAttachPoints attachment { + .element = CLAY_ATTACH_POINT_LEFT_TOP (default) | 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 + .parent = CLAY_ATTACH_POINT_LEFT_TOP (default) | 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_FloatingElementConfig; +``` + +As with all config macros, `CLAY_FLOATING_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Fields** + +**`.offset`** - `Clay_Vector2` + +`CLAY_FLOATING_CONFIG(.offset = { -24, -24 })` + +Used to apply a position offset to the floating container _after_ all other layout has been calculated. + +--- + +**`.expand`** - `Clay_Dimensions` + +`CLAY_FLOATING_CONFIG(.expand = { 16, 16 })` + +Used to expand the width and height of the floating container _before_ laying out child elements. + +--- + +**`.zIndex`** - `float` + +`CLAY_FLOATING_CONFIG(.zIndex = 1)` + +All floating elements (as well as their entire child hierarchies) will be sorted by `.zIndex` order before being converted to render commands. If render commands are drawn in order, elements with higher `.zIndex` values will be drawn on top. + +--- + +**`.parentId`** - `uint32_t` + +`CLAY_FLOATING_CONFIG(.parentId = CLAY_ID("HeaderButton"))` + +By default, floating containers will "attach" to the parent element that they are declared inside. However, there are cases where this limitation could cause significant performance or ergonomics problems. `.parentId` allows you to specify a `CLAY_ID()` to attach the floating container to. The parent element with the matching id can be declared anywhere in the hierarchy, it doesn't need to be declared before or after the floating container in particular. + +Consider the following case: +```C +// Load an image somewhere in your code +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 1), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents + if (tooltip.attachedButtonIndex == 1) { + CLAY_FLOATING_CONTAINER(/* floating config... */); + } +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 2), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents + if (tooltip.attachedButtonIndex == 2) { + CLAY_FLOATING_CONTAINER(/* floating config... */); + } +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 3), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents + if (tooltip.attachedButtonIndex == 3) { + CLAY_FLOATING_CONTAINER(/* floating config... */); + } +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 4), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents + if (tooltip.attachedButtonIndex == 4) { + CLAY_FLOATING_CONTAINER(/* floating config... */); + } +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 5), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents + if (tooltip.attachedButtonIndex == 5) { + CLAY_FLOATING_CONTAINER(/* floating config... */); + } +}); +``` + +The definition of the above UI is significantly polluted by the need to conditionally render floating tooltips as a child of many possible elements. The alternative, using `parentId`, looks like this: + +```C +// Load an image somewhere in your code +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 1), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 2), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 3), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 4), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents +}); +CLAY_CONTAINER(CLAY_IDI("SidebarButton", 5), &CLAY_LAYOUT_DEFAULT, { + // .. some button contents +}); + +// Any other point in the hierarchy +CLAY_FLOATING_CONTAINER(CLAY_ID("OptionTooltip"), &CLAY_LAYOUT_DEFAULT, CLAY_FLOATING_CONFIG(.parentId = CLAY_IDI("SidebarButton", tooltip.attachedButtonIndex)), { + // Tooltip contents... +}); +``` + +--- + +**`.attachment`** - `Clay_FloatingAttachPoints` + +`CLAY_FLOATING_CONFIG(.attachment = { .element = CLAY_ATTACH_POINT_LEFT_CENTER, .parent = CLAY_ATTACH_POINT_RIGHT_TOP });` + +In terms of positioning the floating container, `.attachment` specifies + +- The point on the floating container (`.element`) +- The point on the parent element that it "attaches" to (`.parent`) + +![Screenshot 2024-08-23 at 11 47 21 AM](https://github.com/user-attachments/assets/b8c6dfaa-c1b1-41a4-be55-013473e4a6ce) + +You can mentally visualise this as finding a point on the floating container, then finding a point on the parent, and lining them up over the top of one another. + +For example: + +"Attach the LEFT_CENTER of the floating container to the RIGHT_TOP of the parent" + +`CLAY_FLOATING_CONFIG(.attachment = { .element = CLAY_ATTACH_POINT_LEFT_CENTER, .parent = CLAY_ATTACH_POINT_RIGHT_TOP });` + +![Screenshot 2024-08-23 at 11 53 24 AM](https://github.com/user-attachments/assets/ebe75e0d-1904-46b0-982d-418f929d1516) + + +### CLAY_SCROLL_CONFIG + +**CLAY_SCROLL_CONFIG()** is a macro used to create and store `Clay_ScrollContainerElementConfig` structs, which are for configuring [CLAY_SCROLL_CONTAINER]() elements. + +**Struct Definition (Pseudocode)** + +```C +typedef struct +{ + bool horizontal; + bool vertical; +} Clay_ScrollContainerElementConfig; +``` + +As with all config macros, `CLAY_SCROLL_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Fields** + +**`.horizontal`** - `bool` + +`CLAY_SCROLL_CONFIG(.horizontal = true)` + +Enables or disables horizontal scrolling for this container element. + +--- + +**`.vertical`** - `bool` + +`CLAY_SCROLL_CONFIG(.vertical = true)` + +Enables or disables vertical scrolling for this container element. + +**Examples** + +```C +CLAY_SCROLL_CONTAINER(CLAY_ID("MainContent"), &CLAY_LAYOUT_DEFAULT, CLAY_SCROLL_CONFIG(.vertical = true), { + // Create child content with a fixed height of 5000 + CLAY_CONTAINER(CLAY_ID("ScrollInner"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(5000) }), {}); +}); +``` + +### CLAY_BORDER_CONFIG + +**CLAY_BORDER_CONFIG()** is a macro used to create and store `Clay_BorderContainerElementConfig` structs, which are for configuring [CLAY_BORDER_CONTAINER]() elements. + +**Struct Definition (Pseudocode)** + +```C +typedef struct +{ + Clay_Border left { + float width; + Clay_Color color { + float r; float g; float b; float a; + }; + }; + Clay_Border right { + float width; + Clay_Color color { + float r; float g; float b; float a; + }; + } + Clay_Border top { + float width; + Clay_Color color { + float r; float g; float b; float a; + }; + }; + Clay_Border bottom { + float width; + Clay_Color color { + float r; float g; float b; float a; + }; + }; + Clay_Border betweenChildren { + float width; + Clay_Color color { + float r; float g; float b; float a; + }; + }; + Clay_CornerRadius cornerRadius { + float topLeft; + float topRight; + float bottomLeft; + float bottomRight; + }; +} Clay_BorderContainerElementConfig; +``` + +**Usage** + +As with all config macros, `CLAY_BORDER_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + + +**Fields** + +**`.left, .right, .top, .bottom`** - `Clay_Border` + +`CLAY_BORDER_CONFIG(.left = { 2, COLOR_RED }, .right = { 4, COLOR_YELLOW } /* etc */)` + +Indicates to the renderer that a border of `.color` should be draw at the specified edges of the bounding box, **overlapping the box contents by `.width`**. + +This means that border configuration does not affect layout, as the width of the border doesn't contribute to the total container width or layout position. Border containers with zero padding will be drawn over the top of child elements. + +--- + +**`.betweenChildren`** - `Clay_Border` + +`CLAY_BORDER_CONFIG(.betweenChildren = { 2, COLOR_RED })` + +Configures the width and color of borders to be drawn between children. These borders will be vertical lines if the parent uses `.layoutDirection = CLAY_LEFT_TO_RIGHT` and horizontal lines if the parent uses `CLAY_TOP_TO_BOTTOM`. Unlike `.left, .top` etc, this option **will generate additional rectangle render commands representing the borders between children.** As a result, the renderer does not need to specifically implement rendering for these border elements. + +--- + +**`.cornerRadius`** - `float` + +`CLAY_BORDER_CONFIG(.cornerRadius = 16)` + +Defines the radius in pixels for the arc of border corners (`0` is square, `rectangle.width / 2` is circular). It is up to the renderer to decide how to interpolate between differing border widths and colors across shared corners. + +Note that the `CLAY_CORNER_RADIUS(radius)` function-like macro is available to provide short hand for setting all four corner radii to the same value. e.g. `CLAY_BORDER_CONFIG(.cornerRadius = CLAY_CORNER_RADIUS(10))` + +**Convenience Macros** + +There are some common cases for border configuration that are repetitive, i.e. specifying the same border around all four edges. Some convenience macros are provided for these cases: + +- `CLAY_BORDER_CONFIG_OUTSIDE(.width = 2, .color = COLOR_RED)` - Shorthand for configuring all 4 outside borders at once.` +- `CLAY_BORDER_CONFIG_OUTSIDE_RADIUS(width, color, radius)` - Shorthand for configuring all 4 outside borders at once, with the provided `.cornerRadius`. Note this is a function-like macro and does not take `.member = value` syntax. +- `CLAY_BORDER_CONFIG_ALL(.width = 2, .color = COLOR_RED)` - Shorthand for configuring all 4 outside borders and `.betweenChildren` at once. +- `CLAY_BORDER_CONFIG_ALL_RADIUS(width, color, radius)` - Shorthand for configuring all 4 outside borders and `.betweenChildren` at once, with the provided `cornerRadius`. Note this is a function-like macro and does not take `.member = value` syntax. + +### CLAY_CUSTOM_ELEMENT_CONFIG + +**CLAY_CUSTOM_ELEMENT_CONFIG()** is a macro used to create and store `Clay_CustomElementConfig` structs, which are for configuring [CLAY_CUSTOM_ELEMENT]() elements. + +**Struct Definition (Pseudocode)** + +```C +typedef struct +{ + #ifndef CLAY_EXTEND_CONFIG_CUSTOM + void * customData; // Note: This field will be replaced if #define CLAY_EXTEND_CONFIG_CUSTOM is specified + #else CLAY_EXTEND_CONFIG_CUSTOM + // Contents of CLAY_EXTEND_CONFIG_CUSTOM will be pasted here + #endif +} Clay_CustomElementConfig; +``` + +As with all config macros, `CLAY_CUSTOM_ELEMENT_CONFIG()` accepts designated initializer syntax and provides default values for any unspecified struct members. + +**Extension** + +The underlying `Clay_ImageCustomConfig` can be extended with new members by using: +```C +#define CLAY_EXTEND_CONFIG_CUSTOM float newField; +#include "clay.h" // Define your extension before including clay.h +``` + +**Fields** + +`.customData` - `void *` + +`CLAY_CUSTOM_CONFIG(.customData = &myCustomData)` + +`.customData` is a generic void pointer that can be used to pass through custom data to the renderer. **Note:** this field is generally not recommended for usage due to the lack of type safety, see `#define CLAY_EXTEND_CONFIG_CUSTOM` in [Preprocessor Directives]() for an alternative. + +```C +// Extend CLAY_CUSTOM_ELEMENT_CONFIG with your custom data +#define CLAY_EXTEND_CONFIG_CUSTOM struct t_CustomElementData customData; +// Extensions need to happen _before_ the clay include +#include "clay.h" + +// A rough example of how you could handle laying out 3d models in your UI +typedef struct t_CustomElementData { + CustomElementType type; + union { + Model model; + Video video; + // ... + }; +} CustomElementData; + +Model myModel = Load3DModel(filePath); +CustomElement modelElement = (CustomElement) { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel } +// ... +CLAY_CONTAINER(id, style, { + // This config is type safe and contains the CustomElementData struct + CLAY_CUSTOM_ELEMENT(id, style, CLAY_CUSTOM_ELEMENT_CONFIG(.customData = { .type = CUSTOM_ELEMENT_TYPE_MODEL, .model = myModel })) +}); + +// Later during your rendering +switch (renderCommand->commandType) { + // ... + case CLAY_RENDER_COMMAND_TYPE_CUSTOM: { + // Your extended struct is passed through + CustomElementData *data = renderCommand->elementConfig.customElementConfig->customData; + if (!customElement) continue; + switch (customElement->type) { + case CUSTOM_ELEMENT_TYPE_MODEL: { + // Render your 3d model here + break; + } + case CUSTOM_ELEMENT_TYPE_VIDEO: { + // Render your video here + break; + } + // ... + } + break; + } +} +``` + +## Misc Macros + +### CLAY_ID + +`uint32_t CLAY_ID(char *label)` + +Generates a `uint32_t` string hash from the provided `char *label`. Used both to generate ids when defining element macros, as well as for referencing ids later when using utility functions such as [Clay_PointerOver](#clay-pointerover) + +### CLAY_IDI() + +`uint32_t CLAY_IDI(char *label, int index)` + +Generates a `uint32_t` string hash from the provided `char *label`, combined with the `int index`. Used for generating ids for sequential elements (such as in a `for` loop) without having to construct dynamic strings at runtime. diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..688abaa --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +0.10 \ No newline at end of file diff --git a/clay.h b/clay.h new file mode 100644 index 0000000..3596e3d --- /dev/null +++ b/clay.h @@ -0,0 +1,2273 @@ +#pragma once + +#ifndef CLAY_IMPLEMENTATION +#define CLAY_IMPLEMENTATION + +#ifdef CLAY_WASM +#define CLAY_WASM_EXPORT(name) __attribute__((export_name(name))) +#else +#define CLAY_WASM_EXPORT(null) +#endif + +#include "stdint.h" +#include "stdbool.h" +#ifdef CLAY_OVERFLOW_TRAP + #include "signal.h" +#endif + +#ifndef CLAY_MAX_ELEMENT_COUNT +#define CLAY_MAX_ELEMENT_COUNT 8192 +#endif + +#ifndef CLAY__NULL +#define CLAY__NULL 0 +#endif + +#ifndef CLAY__MAXFLOAT +#define CLAY__MAXFLOAT 3.40282346638528859812e+38F +#endif + +#define CLAY__MAX(x, y) (((x) > (y)) ? (x) : (y)) +#define CLAY__MIN(x, y) (((x) < (y)) ? (x) : (y)) + +// Publicly visible config macro ----------------------------------------------------- + +#define CLAY_LAYOUT(...) Clay_LayoutConfigArray_Add(&Clay__layoutConfigs, (Clay_LayoutConfig) {__VA_ARGS__ }) + +#define CLAY_RECTANGLE_CONFIG(...) Clay_RectangleElementConfigArray_Add(&Clay__rectangleElementConfigs, (Clay_RectangleElementConfig) {__VA_ARGS__ }) + +#define CLAY_TEXT_CONFIG(...) Clay_TextElementConfigArray_Add(&Clay__textElementConfigs, (Clay_TextElementConfig) {__VA_ARGS__ }) + +#define CLAY_IMAGE_CONFIG(...) Clay_ImageElementConfigArray_Add(&Clay__imageElementConfigs, (Clay_ImageElementConfig) {__VA_ARGS__ }) + +#define CLAY_FLOATING_CONFIG(...) Clay_FloatingElementConfigArray_Add(&Clay__floatingElementConfigs, (Clay_FloatingElementConfig) {__VA_ARGS__ }) + +#define CLAY_CUSTOM_ELEMENT_CONFIG(...) Clay_CustomElementConfigArray_Add(&Clay__customElementConfigs, (Clay_CustomElementConfig) {__VA_ARGS__ }) + +#define CLAY_SCROLL_CONFIG(...) Clay_ScrollContainerElementConfigArray_Add(&Clay__scrollElementConfigs, (Clay_ScrollContainerElementConfig) {__VA_ARGS__ }) + +#define CLAY_BORDER_CONFIG(...) Clay_BorderContainerElementConfigArray_Add(&Clay__borderElementConfigs, (Clay_BorderContainerElementConfig ) { __VA_ARGS__ }) + +#define CLAY_BORDER_CONFIG_OUTSIDE(...) Clay_BorderContainerElementConfigArray_Add(&Clay__borderElementConfigs, (Clay_BorderContainerElementConfig ) { .left = { __VA_ARGS__ }, .right = { __VA_ARGS__ }, .top = { __VA_ARGS__ }, .bottom = { __VA_ARGS__ } }) + +#define CLAY_BORDER_CONFIG_OUTSIDE_RADIUS(width, color, radius) Clay_BorderContainerElementConfigArray_Add(&Clay__borderElementConfigs, (Clay_BorderContainerElementConfig ) { .left = { width, color }, .right = { width, color }, .top = { width, color }, .bottom = { width, color }, .cornerRadius = { radius, radius, radius, radius } }) + +#define CLAY_BORDER_CONFIG_ALL(...) Clay_BorderContainerElementConfigArray_Add(&Clay__borderElementConfigs, (Clay_BorderContainerElementConfig ) { .left = { __VA_ARGS__ }, .right = { __VA_ARGS__ }, .top = { __VA_ARGS__ }, .bottom = { __VA_ARGS__ }, .betweenChildren = { __VA_ARGS__ } }) + +#define CLAY_BORDER_CONFIG_ALL_RADIUS(width, color, radius) Clay_BorderContainerElementConfigArray_Add(&Clay__borderElementConfigs, (Clay_BorderContainerElementConfig ) { .left = { __VA_ARGS__ }, .right = { __VA_ARGS__ }, .top = { __VA_ARGS__ }, .bottom = { __VA_ARGS__ }, .betweenChildren = { __VA_ARGS__ }, .cornerRadius = { radius, radius, radius, radius }}) + +#define CLAY_CORNER_RADIUS(radius) (Clay_CornerRadius) { radius, radius, radius, radius } + +#define CLAY_SIZING_FIT(...) (Clay_SizingAxis) { .type = CLAY__SIZING_TYPE_FIT, .sizeMinMax = (Clay_SizingMinMax) {__VA_ARGS__} } + +#define CLAY_SIZING_GROW(...) (Clay_SizingAxis) { .type = CLAY__SIZING_TYPE_GROW, .sizeMinMax = (Clay_SizingMinMax) {__VA_ARGS__} } + +#define CLAY_SIZING_FIXED(fixedSize) (Clay_SizingAxis) { .type = CLAY__SIZING_TYPE_GROW, .sizeMinMax = { fixedSize, fixedSize } } + +#define CLAY_SIZING_PERCENT(percentOfParent) (Clay_SizingAxis) { .type = CLAY__SIZING_TYPE_PERCENT, .sizePercent = percentOfParent } + +#define CLAY_ID(label) Clay__HashString(CLAY_STRING(label), 0) + +#define CLAY_IDI(label, index) Clay__HashString(CLAY_STRING(label), index) + +#define CLAY__STRING_LENGTH(s) ((sizeof(s) / sizeof(s[0])) - sizeof(s[0])) + +#define CLAY_STRING(string) (Clay_String) { .length = CLAY__STRING_LENGTH(string), .chars = string } + +// Publicly visible layout element macros ----------------------------------------------------- +#define CLAY_CONTAINER(id, layoutConfig, children) \ + Clay__OpenContainerElement(id, layoutConfig); \ + children \ + Clay__CloseContainerElement() + +#define CLAY_RECTANGLE(id, layoutConfig, rectangleConfig, children) \ + Clay__OpenRectangleElement(id, layoutConfig, rectangleConfig); \ + children \ + Clay__CloseContainerElement() + +#define CLAY_TEXT(id, text, textConfig) Clay__OpenTextElement(id, text, textConfig) + +#define CLAY_IMAGE(id, layoutConfig, imageConfig, children) \ + Clay__OpenImageContainerElement(id, layoutConfig, imageConfig); \ + children \ + Clay__CloseContainerElement() + +#define CLAY_SCROLL_CONTAINER(id, layoutConfig, scrollConfig, children) \ + Clay__OpenScrollElement(id, layoutConfig, scrollConfig); \ + children \ + Clay__CloseScrollContainerElement() + +#define CLAY_FLOATING_CONTAINER(id, layoutConfig, floatingConfig, children) \ + Clay__OpenFloatingContainerElement(id, layoutConfig, floatingConfig); \ + children \ + Clay__CloseFloatingContainer() + +#define CLAY_BORDER_CONTAINER(id, layoutConfig, borderConfig, children) \ + Clay__OpenBorderContainerElement(id, layoutConfig, borderConfig); \ + children \ + Clay__CloseContainerElement() + +#define CLAY_CUSTOM_ELEMENT(id, layoutConfig, customElementConfig, children) \ + Clay__OpenCustomElement(id, layoutConfig, customElementConfig); \ + children \ + Clay__CloseContainerElement() + +// 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 { + int length; + const char *chars; +} Clay_String; + +Clay_String CLAY__SPACECHAR = (Clay_String) { .length = 1, .chars = " " }; +Clay_String CLAY__STRING_DEFAULT = (Clay_String) { .length = 0, .chars = "" }; + +typedef struct { + Clay_String label; + uint64_t nextAllocation; + uint64_t capacity; + char *memory; +} Clay_Arena; + +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_String *internalArray; +} Clay_StringArray; + +Clay_StringArray Clay_warnings = (Clay_StringArray) {}; + +Clay_String *Clay_StringArray_Add(Clay_StringArray *array, Clay_String item) +{ + if (array->length < array->capacity) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + else { + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } + return &CLAY__STRING_DEFAULT; +} + +Clay_StringArray Clay_StringArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) +{ + uint64_t totalSizeBytes = capacity * sizeof(Clay_String); + Clay_StringArray array = (Clay_StringArray){.capacity = capacity, .length = 0}; + uint64_t arenaOffsetAligned = arena->nextAllocation + (arena->nextAllocation % sizeof(Clay_String)); + if (arenaOffsetAligned + totalSizeBytes <= arena->capacity) { + array.internalArray = (Clay_String*)(arena->memory + arenaOffsetAligned); + arena->nextAllocation = arenaOffsetAligned + totalSizeBytes; + } + else { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to allocate array in arena, but arena is already at capacity and would overflow.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } + return array; +} + +void* Clay__Array_Allocate_Arena(uint32_t capacity, uint32_t itemSize, Clay_Arena *arena) +{ + uint64_t totalSizeBytes = capacity * itemSize; + uint64_t arenaOffsetAligned = arena->nextAllocation + (arena->nextAllocation % itemSize); + if (arenaOffsetAligned + totalSizeBytes <= arena->capacity) { + arena->nextAllocation = arenaOffsetAligned + totalSizeBytes; + return (void*)(arena->memory + arenaOffsetAligned); + } + else { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to allocate array in arena, but arena is already at capacity and would overflow.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } + return CLAY__NULL; +} + +bool Clay__Array_RangeCheck(int index, uint32_t length) +{ + if (index < length && index >= 0) { + return true; + } + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Array access out of bounds.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + return false; +} + +bool Clay__Array_IncrementCapacityCheck(uint32_t length, uint32_t capacity) +{ + if (length < capacity) { + return true; + } + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to add to array that is already at capacity.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + return false; +} + +bool CLAY__BOOL_DEFAULT = false; + +// __GENERATED__ template array_define TYPE=bool NAME=Clay__BoolArray +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + bool *internalArray; +} Clay__BoolArray; + +Clay__BoolArray Clay__BoolArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__BoolArray){.capacity = capacity, .length = 0, .internalArray = (bool *)Clay__Array_Allocate_Arena(capacity, sizeof(bool), arena)}; +} +#pragma endregion +// __GENERATED__ template + +typedef struct { + float r, g, b, a; +} Clay_Color; + +typedef struct { + float x, y, width, height; +} Clay_Rectangle; + +typedef struct { + float width, height; +} Clay_Dimensions; + +typedef struct { + float x, y; +} Clay_Vector2; + +typedef enum __attribute__((__packed__)) { + CLAY_LEFT_TO_RIGHT, + CLAY_TOP_TO_BOTTOM, +} Clay_LayoutDirection; + +typedef enum __attribute__((__packed__)) { + CLAY_ALIGN_X_LEFT, + CLAY_ALIGN_X_RIGHT, + CLAY_ALIGN_X_CENTER, +} Clay_LayoutAlignmentX; + +typedef enum __attribute__((__packed__)) { + CLAY_ALIGN_Y_TOP, + CLAY_ALIGN_Y_BOTTOM, + CLAY_ALIGN_Y_CENTER, +} Clay_LayoutAlignmentY; + +typedef enum __attribute__((__packed__)) { + CLAY__SIZING_TYPE_FIT, + CLAY__SIZING_TYPE_GROW, + CLAY__SIZING_TYPE_PERCENT, +} Clay__SizingType; + +typedef enum { + CLAY_RENDER_COMMAND_TYPE_NONE, + CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + CLAY_RENDER_COMMAND_TYPE_BORDER, + CLAY_RENDER_COMMAND_TYPE_TEXT, + CLAY_RENDER_COMMAND_TYPE_IMAGE, + CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + CLAY_RENDER_COMMAND_TYPE_SCISSOR_END, + CLAY_RENDER_COMMAND_TYPE_CUSTOM, +} Clay_RenderCommandType; + +typedef enum __attribute__((__packed__)) { + CLAY__LAYOUT_ELEMENT_TYPE_CONTAINER, + CLAY__LAYOUT_ELEMENT_TYPE_RECTANGLE, + CLAY__LAYOUT_ELEMENT_TYPE_BORDER_CONTAINER, + CLAY__LAYOUT_ELEMENT_TYPE_FLOATING_CONTAINER, + CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER, + CLAY__LAYOUT_ELEMENT_TYPE_IMAGE, + CLAY__LAYOUT_ELEMENT_TYPE_TEXT, + CLAY__LAYOUT_ELEMENT_TYPE_CUSTOM, +} Clay__LayoutElementType; + +Clay_RenderCommandType Clay__LayoutElementTypeToRenderCommandType[] = { + [CLAY__LAYOUT_ELEMENT_TYPE_CONTAINER] = CLAY_RENDER_COMMAND_TYPE_NONE, + [CLAY__LAYOUT_ELEMENT_TYPE_RECTANGLE] = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + [CLAY__LAYOUT_ELEMENT_TYPE_FLOATING_CONTAINER] = CLAY_RENDER_COMMAND_TYPE_NONE, + [CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER] = CLAY_RENDER_COMMAND_TYPE_NONE, + [CLAY__LAYOUT_ELEMENT_TYPE_BORDER_CONTAINER] = CLAY_RENDER_COMMAND_TYPE_BORDER, + [CLAY__LAYOUT_ELEMENT_TYPE_IMAGE] = CLAY_RENDER_COMMAND_TYPE_IMAGE, + [CLAY__LAYOUT_ELEMENT_TYPE_TEXT] = CLAY_RENDER_COMMAND_TYPE_TEXT, + [CLAY__LAYOUT_ELEMENT_TYPE_CUSTOM] = CLAY_RENDER_COMMAND_TYPE_CUSTOM, +}; + +typedef enum __attribute__((__packed__)) { + 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; + +typedef struct +{ + Clay_FloatingAttachPointType element; + Clay_FloatingAttachPointType parent; +} Clay_FloatingAttachPoints; + +typedef struct { + Clay_LayoutAlignmentX x; + Clay_LayoutAlignmentY y; +} Clay_ChildAlignment; + +typedef struct { + float min; + float max; +} Clay_SizingMinMax; + +typedef struct { + union { + Clay_SizingMinMax sizeMinMax; + float sizePercent; + }; + Clay__SizingType type; +} Clay_SizingAxis; + +typedef struct { + Clay_SizingAxis width; + Clay_SizingAxis height; +} Clay_Sizing; + +typedef struct { + uint16_t x; + uint16_t y; +} Clay_Padding; + +typedef struct { + float topLeft; + float topRight; + float bottomLeft; + float bottomRight; +} Clay_CornerRadius; + +typedef struct { + Clay_Sizing sizing; + Clay_Padding padding; + uint16_t childGap; + Clay_LayoutDirection layoutDirection; + Clay_ChildAlignment childAlignment; +} Clay_LayoutConfig; + +Clay_LayoutConfig CLAY_LAYOUT_DEFAULT = (Clay_LayoutConfig){}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_LayoutConfig NAME=Clay_LayoutConfigArray DEFAULT_VALUE=&CLAY_LAYOUT_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_LayoutConfig *internalArray; +} Clay_LayoutConfigArray; + +Clay_LayoutConfigArray Clay_LayoutConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_LayoutConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_LayoutConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_LayoutConfig), arena)}; +} +Clay_LayoutConfig *Clay_LayoutConfigArray_Add(Clay_LayoutConfigArray *array, Clay_LayoutConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY_LAYOUT_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct { + Clay_Color color; + Clay_CornerRadius cornerRadius; + #ifdef CLAY_EXTEND_CONFIG_RECTANGLE + CLAY_EXTEND_CONFIG_RECTANGLE + #endif +} Clay_RectangleElementConfig; + +Clay_RectangleElementConfig CLAY__RECTANGLE_ELEMENT_CONFIG_DEFAULT = (Clay_RectangleElementConfig){0}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_RectangleElementConfig NAME=Clay_RectangleElementConfigArray DEFAULT_VALUE=&CLAY__RECTANGLE_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_RectangleElementConfig *internalArray; +} Clay_RectangleElementConfigArray; + +Clay_RectangleElementConfigArray Clay_RectangleElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_RectangleElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_RectangleElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_RectangleElementConfig), arena)}; +} +Clay_RectangleElementConfig *Clay_RectangleElementConfigArray_Add(Clay_RectangleElementConfigArray *array, Clay_RectangleElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__RECTANGLE_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_Color textColor; + uint16_t fontId; + uint16_t fontSize; + uint16_t letterSpacing; + uint16_t lineSpacing; + #ifdef CLAY_EXTEND_CONFIG_TEXT + CLAY_EXTEND_CONFIG_TEXT + #endif +} Clay_TextElementConfig; + +Clay_TextElementConfig CLAY__TEXT_ELEMENT_CONFIG_DEFAULT = (Clay_TextElementConfig) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_TextElementConfig NAME=Clay_TextElementConfigArray DEFAULT_VALUE=&CLAY__TEXT_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_TextElementConfig *internalArray; +} Clay_TextElementConfigArray; + +Clay_TextElementConfigArray Clay_TextElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_TextElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_TextElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_TextElementConfig), arena)}; +} +Clay_TextElementConfig *Clay_TextElementConfigArray_Add(Clay_TextElementConfigArray *array, Clay_TextElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__TEXT_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + void * imageData; + Clay_Dimensions sourceDimensions; + #ifdef CLAY_EXTEND_CONFIG_IMAGE + CLAY_EXTEND_CONFIG_IMAGE + #endif +} Clay_ImageElementConfig; + +Clay_ImageElementConfig CLAY__IMAGE_ELEMENT_CONFIG_DEFAULT = (Clay_ImageElementConfig) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_ImageElementConfig NAME=Clay_ImageElementConfigArray DEFAULT_VALUE=&CLAY__IMAGE_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_ImageElementConfig *internalArray; +} Clay_ImageElementConfigArray; + +Clay_ImageElementConfigArray Clay_ImageElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_ImageElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_ImageElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_ImageElementConfig), arena)}; +} +Clay_ImageElementConfig *Clay_ImageElementConfigArray_Add(Clay_ImageElementConfigArray *array, Clay_ImageElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__IMAGE_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_Vector2 offset; + Clay_Dimensions expand; + uint16_t zIndex; + uint32_t parentId; + Clay_FloatingAttachPoints attachment; +} Clay_FloatingElementConfig; + +Clay_FloatingElementConfig CLAY__FLOATING_ELEMENT_CONFIG_DEFAULT = (Clay_FloatingElementConfig) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_FloatingElementConfig NAME=Clay_FloatingElementConfigArray DEFAULT_VALUE=&CLAY__FLOATING_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_FloatingElementConfig *internalArray; +} Clay_FloatingElementConfigArray; + +Clay_FloatingElementConfigArray Clay_FloatingElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_FloatingElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_FloatingElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_FloatingElementConfig), arena)}; +} +Clay_FloatingElementConfig *Clay_FloatingElementConfigArray_Add(Clay_FloatingElementConfigArray *array, Clay_FloatingElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__FLOATING_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + #ifndef CLAY_EXTEND_CONFIG_CUSTOM + void* customData; + #else + CLAY_EXTEND_CONFIG_CUSTOM + #endif +} Clay_CustomElementConfig; + +Clay_CustomElementConfig CLAY__CUSTOM_ELEMENT_CONFIG_DEFAULT = (Clay_CustomElementConfig) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_CustomElementConfig NAME=Clay_CustomElementConfigArray DEFAULT_VALUE=&CLAY__CUSTOM_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_CustomElementConfig *internalArray; +} Clay_CustomElementConfigArray; + +Clay_CustomElementConfigArray Clay_CustomElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_CustomElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_CustomElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_CustomElementConfig), arena)}; +} +Clay_CustomElementConfig *Clay_CustomElementConfigArray_Add(Clay_CustomElementConfigArray *array, Clay_CustomElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__CUSTOM_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + bool horizontal; + bool vertical; +} Clay_ScrollContainerElementConfig; + +Clay_ScrollContainerElementConfig CLAY__SCROLL_CONTAINER_ELEMENT_CONFIG_DEFAULT = (Clay_ScrollContainerElementConfig ) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_ScrollContainerElementConfig NAME=Clay_ScrollContainerElementConfigArray DEFAULT_VALUE=&CLAY__SCROLL_CONTAINER_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_ScrollContainerElementConfig *internalArray; +} Clay_ScrollContainerElementConfigArray; + +Clay_ScrollContainerElementConfigArray Clay_ScrollContainerElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_ScrollContainerElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_ScrollContainerElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_ScrollContainerElementConfig), arena)}; +} +Clay_ScrollContainerElementConfig *Clay_ScrollContainerElementConfigArray_Add(Clay_ScrollContainerElementConfigArray *array, Clay_ScrollContainerElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__SCROLL_CONTAINER_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + uint32_t width; + Clay_Color color; +} Clay_Border; + +typedef struct +{ + Clay_Border left; + Clay_Border right; + Clay_Border top; + Clay_Border bottom; + Clay_Border betweenChildren; + Clay_CornerRadius cornerRadius; +} Clay_BorderContainerElementConfig; + +Clay_BorderContainerElementConfig CLAY__BORDER_CONTAINER_ELEMENT_CONFIG_DEFAULT = (Clay_BorderContainerElementConfig ) {}; + +// __GENERATED__ template array_define,array_add TYPE=Clay_BorderContainerElementConfig NAME=Clay_BorderContainerElementConfigArray DEFAULT_VALUE=&CLAY__BORDER_CONTAINER_ELEMENT_CONFIG_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_BorderContainerElementConfig *internalArray; +} Clay_BorderContainerElementConfigArray; + +Clay_BorderContainerElementConfigArray Clay_BorderContainerElementConfigArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_BorderContainerElementConfigArray){.capacity = capacity, .length = 0, .internalArray = (Clay_BorderContainerElementConfig *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_BorderContainerElementConfig), arena)}; +} +Clay_BorderContainerElementConfig *Clay_BorderContainerElementConfigArray_Add(Clay_BorderContainerElementConfigArray *array, Clay_BorderContainerElementConfig item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__BORDER_CONTAINER_ELEMENT_CONFIG_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + struct t_Clay_LayoutElement **elements; + uint16_t length; +} Clay__LayoutElementChildren; + +typedef union +{ + Clay_RectangleElementConfig *rectangleElementConfig; + Clay_TextElementConfig *textElementConfig; + Clay_ImageElementConfig *imageElementConfig; + Clay_FloatingElementConfig *floatingElementConfig; + Clay_CustomElementConfig *customElementConfig; + Clay_ScrollContainerElementConfig *scrollElementConfig; + Clay_BorderContainerElementConfig *borderElementConfig; +} Clay_ElementConfigUnion; + +typedef struct t_Clay_LayoutElement +{ + #ifdef CLAY_DEBUG + Clay_String name; + #endif + union { + Clay__LayoutElementChildren children; + Clay_String text; + }; + Clay_Dimensions dimensions; + Clay_Dimensions minDimensions; + Clay_LayoutConfig *layoutConfig; + Clay_ElementConfigUnion elementConfig; + uint32_t id; + Clay__LayoutElementType elementType; +} Clay_LayoutElement; + +Clay_LayoutElement CLAY__LAYOUT_ELEMENT_DEFAULT = (Clay_LayoutElement) {}; + +// __GENERATED__ template array_define,array_add,array_get TYPE=Clay_LayoutElement NAME=Clay_LayoutElementArray DEFAULT_VALUE=&CLAY__LAYOUT_ELEMENT_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_LayoutElement *internalArray; +} Clay_LayoutElementArray; + +Clay_LayoutElementArray Clay_LayoutElementArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_LayoutElementArray){.capacity = capacity, .length = 0, .internalArray = (Clay_LayoutElement *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_LayoutElement), arena)}; +} +Clay_LayoutElement *Clay_LayoutElementArray_Add(Clay_LayoutElementArray *array, Clay_LayoutElement item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__LAYOUT_ELEMENT_DEFAULT; +} +Clay_LayoutElement *Clay_LayoutElementArray_Get(Clay_LayoutElementArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__LAYOUT_ELEMENT_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_define,array_add,array_get,array_remove_swapback TYPE=Clay_LayoutElement* NAME=Clay__LayoutElementPointerArray DEFAULT_VALUE=CLAY__NULL +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_LayoutElement* *internalArray; +} Clay__LayoutElementPointerArray; + +Clay__LayoutElementPointerArray Clay__LayoutElementPointerArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__LayoutElementPointerArray){.capacity = capacity, .length = 0, .internalArray = (Clay_LayoutElement* *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_LayoutElement*), arena)}; +} +Clay_LayoutElement* *Clay__LayoutElementPointerArray_Add(Clay__LayoutElementPointerArray *array, Clay_LayoutElement* item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return CLAY__NULL; +} +Clay_LayoutElement* *Clay__LayoutElementPointerArray_Get(Clay__LayoutElementPointerArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : CLAY__NULL; +} +Clay_LayoutElement* Clay__LayoutElementPointerArray_RemoveSwapback(Clay__LayoutElementPointerArray *array, int index) { + if (Clay__Array_RangeCheck(index, array->length)) { + array->length--; + Clay_LayoutElement* removed = array->internalArray[index]; + array->internalArray[index] = array->internalArray[array->length]; + return removed; + } + return CLAY__NULL; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_Rectangle boundingBox; + Clay_ElementConfigUnion config; + Clay_String text; // TODO I wish there was a way to avoid having to have this on every render command + uint32_t id; + Clay_RenderCommandType commandType; +} Clay_RenderCommand; + +Clay_RenderCommand CLAY__RENDER_COMMAND_DEFAULT = (Clay_RenderCommand) {}; + +// __GENERATED__ template array_define TYPE=Clay_RenderCommand NAME=Clay_RenderCommandArray +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_RenderCommand *internalArray; +} Clay_RenderCommandArray; + +Clay_RenderCommandArray Clay_RenderCommandArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay_RenderCommandArray){.capacity = capacity, .length = 0, .internalArray = (Clay_RenderCommand *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_RenderCommand), arena)}; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_add TYPE=Clay_RenderCommand NAME=Clay_RenderCommandArray DEFAULT_VALUE=&CLAY__RENDER_COMMAND_DEFAULT +#pragma region generated +Clay_RenderCommand *Clay_RenderCommandArray_Add(Clay_RenderCommandArray *array, Clay_RenderCommand item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__RENDER_COMMAND_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_get TYPE=Clay_RenderCommand NAME=Clay_RenderCommandArray DEFAULT_VALUE=&CLAY__RENDER_COMMAND_DEFAULT +#pragma region generated +Clay_RenderCommand *Clay_RenderCommandArray_Get(Clay_RenderCommandArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__RENDER_COMMAND_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_LayoutElement *layoutElement; + Clay_Rectangle boundingBox; + Clay_Dimensions contentSize; + Clay_Vector2 scrollOrigin; + Clay_Vector2 pointerOrigin; + Clay_Vector2 scrollMomentum; + Clay_Vector2 scrollPosition; + float momentumTime; + uint32_t elementId; + bool openThisFrame; + bool pointerScrollActive; +} Clay__ScrollContainerData; + +Clay__ScrollContainerData CLAY__SCROLL_CONTAINER_DEFAULT = (Clay__ScrollContainerData) {}; + +// __GENERATED__ template array_define TYPE=Clay__ScrollContainerData NAME=Clay__ScrollContainerDataArray +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay__ScrollContainerData *internalArray; +} Clay__ScrollContainerDataArray; + +Clay__ScrollContainerDataArray Clay__ScrollContainerDataArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__ScrollContainerDataArray){.capacity = capacity, .length = 0, .internalArray = (Clay__ScrollContainerData *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay__ScrollContainerData), arena)}; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_add TYPE=Clay__ScrollContainerData NAME=Clay__ScrollContainerDataArray DEFAULT_VALUE=&CLAY__SCROLL_CONTAINER_DEFAULT +#pragma region generated +Clay__ScrollContainerData *Clay__ScrollContainerDataArray_Add(Clay__ScrollContainerDataArray *array, Clay__ScrollContainerData item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__SCROLL_CONTAINER_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_get TYPE=Clay__ScrollContainerData NAME=Clay__ScrollContainerDataArray DEFAULT_VALUE=&CLAY__SCROLL_CONTAINER_DEFAULT +#pragma region generated +Clay__ScrollContainerData *Clay__ScrollContainerDataArray_Get(Clay__ScrollContainerDataArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__SCROLL_CONTAINER_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +// __GENERATED__ template array_remove_swapback TYPE=Clay__ScrollContainerData NAME=Clay__ScrollContainerDataArray DEFAULT_VALUE=CLAY__SCROLL_CONTAINER_DEFAULT +#pragma region generated +Clay__ScrollContainerData Clay__ScrollContainerDataArray_RemoveSwapback(Clay__ScrollContainerDataArray *array, int index) { + if (Clay__Array_RangeCheck(index, array->length)) { + array->length--; + Clay__ScrollContainerData removed = array->internalArray[index]; + array->internalArray[index] = array->internalArray[array->length]; + return removed; + } + return CLAY__SCROLL_CONTAINER_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_Rectangle boundingBox; + uint32_t id; + Clay_LayoutElement* layoutElement; + int32_t nextIndex; +} Clay_LayoutElementHashMapItem; + +Clay_LayoutElementHashMapItem CLAY__LAYOUT_ELEMENT_HASH_MAP_ITEM_DEFAULT = (Clay_LayoutElementHashMapItem) { .layoutElement = &CLAY__LAYOUT_ELEMENT_DEFAULT }; + +// __GENERATED__ template array_define,array_get,array_add,array_set TYPE=Clay_LayoutElementHashMapItem NAME=Clay__LayoutElementHashMapItemArray DEFAULT_VALUE=&CLAY__LAYOUT_ELEMENT_HASH_MAP_ITEM_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay_LayoutElementHashMapItem *internalArray; +} Clay__LayoutElementHashMapItemArray; + +Clay__LayoutElementHashMapItemArray Clay__LayoutElementHashMapItemArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__LayoutElementHashMapItemArray){.capacity = capacity, .length = 0, .internalArray = (Clay_LayoutElementHashMapItem *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay_LayoutElementHashMapItem), arena)}; +} +Clay_LayoutElementHashMapItem *Clay__LayoutElementHashMapItemArray_Get(Clay__LayoutElementHashMapItemArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__LAYOUT_ELEMENT_HASH_MAP_ITEM_DEFAULT; +} +Clay_LayoutElementHashMapItem *Clay__LayoutElementHashMapItemArray_Add(Clay__LayoutElementHashMapItemArray *array, Clay_LayoutElementHashMapItem item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__LAYOUT_ELEMENT_HASH_MAP_ITEM_DEFAULT; +} +void Clay__LayoutElementHashMapItemArray_Set(Clay__LayoutElementHashMapItemArray *array, int index, Clay_LayoutElementHashMapItem value) { + if (index < array->capacity && index >= 0) { + array->internalArray[index] = value; + array->length = index < array->length ? array->length : index + 1; + } else { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to allocate array in arena, but arena is already at capacity and would overflow.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_Dimensions dimensions; + uint32_t id; + int32_t nextIndex; +} Clay__MeasureTextCacheItem; + +Clay__MeasureTextCacheItem CLAY__MEASURE_TEXT_CACHE_ITEM_DEFAULT = (Clay__MeasureTextCacheItem) { }; + +// __GENERATED__ template array_define,array_get,array_add,array_set TYPE=Clay__MeasureTextCacheItem NAME=Clay__MeasureTextCacheItemArray DEFAULT_VALUE=&CLAY__MEASURE_TEXT_CACHE_ITEM_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay__MeasureTextCacheItem *internalArray; +} Clay__MeasureTextCacheItemArray; + +Clay__MeasureTextCacheItemArray Clay__MeasureTextCacheItemArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__MeasureTextCacheItemArray){.capacity = capacity, .length = 0, .internalArray = (Clay__MeasureTextCacheItem *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay__MeasureTextCacheItem), arena)}; +} +Clay__MeasureTextCacheItem *Clay__MeasureTextCacheItemArray_Get(Clay__MeasureTextCacheItemArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__MEASURE_TEXT_CACHE_ITEM_DEFAULT; +} +Clay__MeasureTextCacheItem *Clay__MeasureTextCacheItemArray_Add(Clay__MeasureTextCacheItemArray *array, Clay__MeasureTextCacheItem item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__MEASURE_TEXT_CACHE_ITEM_DEFAULT; +} +void Clay__MeasureTextCacheItemArray_Set(Clay__MeasureTextCacheItemArray *array, int index, Clay__MeasureTextCacheItem value) { + if (index < array->capacity && index >= 0) { + array->internalArray[index] = value; + array->length = index < array->length ? array->length : index + 1; + } else { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to allocate array in arena, but arena is already at capacity and would overflow.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } +} +#pragma endregion +// __GENERATED__ template + +int32_t CLAY__INDEX_ARRAY_DEFAULT_VALUE = -1; + +// __GENERATED__ template array_define,array_get,array_add,array_set TYPE=int32_t NAME=Clay__int32_tArray DEFAULT_VALUE=&CLAY__INDEX_ARRAY_DEFAULT_VALUE +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + int32_t *internalArray; +} Clay__int32_tArray; + +Clay__int32_tArray Clay__int32_tArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__int32_tArray){.capacity = capacity, .length = 0, .internalArray = (int32_t *)Clay__Array_Allocate_Arena(capacity, sizeof(int32_t), arena)}; +} +int32_t *Clay__int32_tArray_Get(Clay__int32_tArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__INDEX_ARRAY_DEFAULT_VALUE; +} +int32_t *Clay__int32_tArray_Add(Clay__int32_tArray *array, int32_t item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__INDEX_ARRAY_DEFAULT_VALUE; +} +void Clay__int32_tArray_Set(Clay__int32_tArray *array, int index, int32_t value) { + if (index < array->capacity && index >= 0) { + array->internalArray[index] = value; + array->length = index < array->length ? array->length : index + 1; + } else { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Attempting to allocate array in arena, but arena is already at capacity and would overflow.")); + #ifdef CLAY_OVERFLOW_TRAP + raise(SIGTRAP); + #endif + } +} +#pragma endregion +// __GENERATED__ template + +Clay_LayoutElement *Clay__openLayoutElement = CLAY__NULL; + +typedef struct +{ + Clay_LayoutElement *layoutElement; + Clay_Vector2 position; + Clay_Vector2 nextChildOffset; +} Clay__LayoutElementTreeNode; + +Clay__LayoutElementTreeNode CLAY__LAYOUT_ELEMENT_TREE_NODE_DEFAULT = (Clay__LayoutElementTreeNode) {}; + +// __GENERATED__ template array_define,array_add,array_get TYPE=Clay__LayoutElementTreeNode NAME=Clay__LayoutElementTreeNodeArray DEFAULT_VALUE=&CLAY__LAYOUT_ELEMENT_TREE_NODE_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay__LayoutElementTreeNode *internalArray; +} Clay__LayoutElementTreeNodeArray; + +Clay__LayoutElementTreeNodeArray Clay__LayoutElementTreeNodeArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__LayoutElementTreeNodeArray){.capacity = capacity, .length = 0, .internalArray = (Clay__LayoutElementTreeNode *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay__LayoutElementTreeNode), arena)}; +} +Clay__LayoutElementTreeNode *Clay__LayoutElementTreeNodeArray_Add(Clay__LayoutElementTreeNodeArray *array, Clay__LayoutElementTreeNode item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__LAYOUT_ELEMENT_TREE_NODE_DEFAULT; +} +Clay__LayoutElementTreeNode *Clay__LayoutElementTreeNodeArray_Get(Clay__LayoutElementTreeNodeArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__LAYOUT_ELEMENT_TREE_NODE_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +typedef struct +{ + Clay_LayoutElement *layoutElement; + 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 + uint32_t zIndex; +} Clay__LayoutElementTreeRoot; + +Clay__LayoutElementTreeRoot CLAY__LAYOUT_ELEMENT_TREE_ROOT_DEFAULT = (Clay__LayoutElementTreeRoot) {}; + +// __GENERATED__ template array_define,array_add,array_get TYPE=Clay__LayoutElementTreeRoot NAME=Clay__LayoutElementTreeRootArray DEFAULT_VALUE=&CLAY__LAYOUT_ELEMENT_TREE_ROOT_DEFAULT +#pragma region generated +typedef struct +{ + uint32_t capacity; + uint32_t length; + Clay__LayoutElementTreeRoot *internalArray; +} Clay__LayoutElementTreeRootArray; + +Clay__LayoutElementTreeRootArray Clay__LayoutElementTreeRootArray_Allocate_Arena(uint32_t capacity, Clay_Arena *arena) { + return (Clay__LayoutElementTreeRootArray){.capacity = capacity, .length = 0, .internalArray = (Clay__LayoutElementTreeRoot *)Clay__Array_Allocate_Arena(capacity, sizeof(Clay__LayoutElementTreeRoot), arena)}; +} +Clay__LayoutElementTreeRoot *Clay__LayoutElementTreeRootArray_Add(Clay__LayoutElementTreeRootArray *array, Clay__LayoutElementTreeRoot item) { + if (Clay__Array_IncrementCapacityCheck(array->length, array->capacity)) { + array->internalArray[array->length++] = item; + return &array->internalArray[array->length - 1]; + } + return &CLAY__LAYOUT_ELEMENT_TREE_ROOT_DEFAULT; +} +Clay__LayoutElementTreeRoot *Clay__LayoutElementTreeRootArray_Get(Clay__LayoutElementTreeRootArray *array, int index) { + return Clay__Array_RangeCheck(index, array->length) ? &array->internalArray[index] : &CLAY__LAYOUT_ELEMENT_TREE_ROOT_DEFAULT; +} +#pragma endregion +// __GENERATED__ template + +Clay_Vector2 Clay__pointerPosition = (Clay_Vector2) { -1, -1 }; +uint64_t Clay__arenaResetOffset = 0; +Clay_Arena Clay__internalArena; +// Layout Elements / Render Commands +Clay_LayoutElementArray Clay__layoutElements; +Clay_RenderCommandArray Clay__renderCommands; +Clay__LayoutElementPointerArray Clay__openLayoutElementStack; +Clay__LayoutElementPointerArray Clay__layoutElementChildren; +Clay__LayoutElementPointerArray Clay__layoutElementChildrenBuffer; +Clay__LayoutElementPointerArray Clay__textElementPointers; +Clay__LayoutElementPointerArray Clay__imageElementPointers; +Clay__LayoutElementPointerArray Clay__layoutElementReusableBuffer; +// Configs +Clay_LayoutConfigArray Clay__layoutConfigs; +Clay_RectangleElementConfigArray Clay__rectangleElementConfigs; +Clay_TextElementConfigArray Clay__textElementConfigs; +Clay_ImageElementConfigArray Clay__imageElementConfigs; +Clay_FloatingElementConfigArray Clay__floatingElementConfigs; +Clay_ScrollContainerElementConfigArray Clay__scrollElementConfigs; +Clay_CustomElementConfigArray Clay__customElementConfigs; +Clay_BorderContainerElementConfigArray Clay__borderElementConfigs; +// Misc Data Structures +Clay__LayoutElementTreeNodeArray Clay__layoutElementTreeNodeArray1; +Clay__LayoutElementTreeRootArray Clay__layoutElementTreeRoots; +Clay__LayoutElementHashMapItemArray Clay__layoutElementsHashMapInternal; +Clay__int32_tArray Clay__layoutElementsHashMap; +Clay__MeasureTextCacheItemArray Clay__measureTextHashMapInternal; +Clay__int32_tArray Clay__measureTextHashMap; +Clay__int32_tArray Clay__openClipElementStack; +Clay__int32_tArray Clay__pointerOverIds; +Clay__ScrollContainerDataArray Clay__scrollContainerOffsets; +Clay__BoolArray Clay__treeNodeVisited; + +#if CLAY_WASM + __attribute__((import_module("clay"), import_name("measureTextFunction"))) Clay_Dimensions Clay__MeasureText(Clay_String *text, Clay_TextElementConfig *config); +#else + Clay_Dimensions (*Clay__MeasureText)(Clay_String *text, Clay_TextElementConfig *config); +#endif + +Clay_String LAST_HASH; + +uint32_t Clay__HashString(Clay_String key, const uint32_t offset) { + uint32_t hash = 0; + + for (int i = 0; i < key.length; i++) { + hash += key.chars[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += offset; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + #ifdef CLAY_DEBUG + LAST_HASH = key; + LAST_HASH.length = (int)offset; + #endif + return hash + 1; // Reserve the hash result of zero as "null id" +} + +uint32_t Clay__RehashWithNumber(uint32_t id, uint32_t number) { + id += number; + id += (id << 10); + id ^= (id >> 6); + + id += (id << 3); + id ^= (id >> 11); + id += (id << 15); + return id; +} + +uint32_t Clay__HashTextWithConfig(Clay_String *text, Clay_TextElementConfig *config) { + union { + float fontSize; + uint32_t bits; + } fontSizeBits = { .fontSize = config->fontSize }; + uint32_t hash = 0; + uint64_t pointerAsNumber = (uint64_t)text->chars; + + hash += pointerAsNumber; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += text->length; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += config->fontId; + hash += (hash << 10); + hash ^= (hash >> 6); + + hash += fontSizeBits.bits; + 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_Dimensions Clay__MeasureTextCached(Clay_String *text, Clay_TextElementConfig *config) { + if (text->length < 50) { + return Clay__MeasureText(text, config); + } + uint32_t id = Clay__HashTextWithConfig(text, config); + uint32_t hashBucket = id % Clay__measureTextHashMap.capacity; + int32_t elementIndexPrevious = 0; + int32_t elementIndex = Clay__measureTextHashMap.internalArray[hashBucket]; + while (elementIndex != 0) { + Clay__MeasureTextCacheItem *hashEntry = Clay__MeasureTextCacheItemArray_Get(&Clay__measureTextHashMapInternal, elementIndex); + if (hashEntry->id == id) { + return hashEntry->dimensions; + } + elementIndexPrevious = elementIndex; + elementIndex = hashEntry->nextIndex; + } + Clay_Dimensions measured = Clay__MeasureText(text, config); + if (elementIndexPrevious != 0) { + Clay__MeasureTextCacheItemArray_Get(&Clay__measureTextHashMapInternal, elementIndexPrevious)->nextIndex = (int32_t)Clay__measureTextHashMapInternal.length - 1; + } else { + Clay__measureTextHashMap.internalArray[hashBucket] = (int32_t)Clay__measureTextHashMapInternal.length - 1; + } + return measured; +} + +bool Clay__PointIsInsideRect(Clay_Vector2 point, Clay_Rectangle 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(uint32_t id, Clay_LayoutElement* layoutElement) { + Clay_LayoutElementHashMapItem item = (Clay_LayoutElementHashMapItem) { .id = id, .layoutElement = layoutElement, .nextIndex = -1 }; + uint32_t hashBucket = id % Clay__layoutElementsHashMap.capacity; + int32_t hashItemPrevious = -1; + int32_t hashItemIndex = Clay__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(&Clay__layoutElementsHashMapInternal, hashItemIndex); + if (hashItem->id == id) { // Collision - swap out linked list item + item.nextIndex = hashItem->nextIndex; + Clay__LayoutElementHashMapItemArray_Set(&Clay__layoutElementsHashMapInternal, hashItemIndex, item); + return Clay__LayoutElementHashMapItemArray_Get(&Clay__layoutElementsHashMapInternal, hashItemIndex); + } + hashItemPrevious = hashItemIndex; + hashItemIndex = hashItem->nextIndex; + } + if (hashItemPrevious != -1) { + Clay__LayoutElementHashMapItemArray_Get(&Clay__layoutElementsHashMapInternal, hashItemPrevious)->nextIndex = (int32_t)Clay__layoutElementsHashMapInternal.length; + } + Clay_LayoutElementHashMapItem *hashItem = Clay__LayoutElementHashMapItemArray_Add(&Clay__layoutElementsHashMapInternal, item); + Clay__layoutElementsHashMap.internalArray[hashBucket] = (int32_t)Clay__layoutElementsHashMapInternal.length - 1; + return hashItem; +} + +Clay_LayoutElementHashMapItem *Clay__GetHashMapItem(uint32_t id) { + uint32_t hashBucket = id % Clay__layoutElementsHashMap.capacity; + int32_t elementIndex = Clay__layoutElementsHashMap.internalArray[hashBucket]; + while (elementIndex != -1) { + Clay_LayoutElementHashMapItem *hashEntry = Clay__LayoutElementHashMapItemArray_Get(&Clay__layoutElementsHashMapInternal, elementIndex); + if (hashEntry->id == id) { + return hashEntry; + } + elementIndex = hashEntry->nextIndex; + } + return CLAY__NULL; +} + +Clay_LayoutElement *Clay__OpenElementWithParent(uint32_t id, Clay__LayoutElementType commandType, Clay_LayoutConfig* layoutConfig, Clay_ElementConfigUnion elementConfig) { + Clay_LayoutElement layoutElement = (Clay_LayoutElement) { + #ifdef CLAY_DEBUG + .name = LAST_HASH, + #endif + .id = id, + .elementType = commandType, + .minDimensions = (Clay_Dimensions) { (float)layoutConfig->padding.x * 2, (float)layoutConfig->padding.y * 2 }, + .children = (Clay__LayoutElementChildren) { .length = 0 }, + .layoutConfig = layoutConfig, + .elementConfig = elementConfig, + }; + + if (layoutConfig->sizing.width.type != CLAY__SIZING_TYPE_PERCENT) { + layoutElement.dimensions.width = (float)layoutConfig->padding.x * 2; + layoutElement.minDimensions.width = CLAY__MAX(layoutElement.minDimensions.width, layoutConfig->sizing.width.sizeMinMax.min); + if (layoutConfig->sizing.width.sizeMinMax.max <= 0) { // Set the max size if the user didn't specify, makes calculations easier + layoutConfig->sizing.width.sizeMinMax.max = CLAY__MAXFLOAT; + } + } + if (layoutConfig->sizing.height.type != CLAY__SIZING_TYPE_PERCENT) { + layoutElement.dimensions.height = (float)layoutConfig->padding.y * 2; + layoutElement.minDimensions.height = CLAY__MAX(layoutElement.minDimensions.height, layoutConfig->sizing.height.sizeMinMax.min); + if (layoutConfig->sizing.height.sizeMinMax.max <= 0) { // Set the max size if the user didn't specify, makes calculations easier + layoutConfig->sizing.height.sizeMinMax.max = CLAY__MAXFLOAT; + } + } + + Clay__openLayoutElement = Clay_LayoutElementArray_Add(&Clay__layoutElements, layoutElement); + Clay__LayoutElementPointerArray_Add(&Clay__openLayoutElementStack, Clay__openLayoutElement); + Clay__AddHashMapItem(id, Clay__openLayoutElement); + return Clay__openLayoutElement; +} + +Clay_LayoutElement *Clay__OpenElement(uint32_t id, Clay__LayoutElementType commandType, Clay_LayoutConfig *layoutConfig, Clay_ElementConfigUnion elementConfig) { + Clay__openLayoutElement->children.length++; + Clay_LayoutElement *element = Clay__OpenElementWithParent(id, commandType, layoutConfig, elementConfig); + Clay__LayoutElementPointerArray_Add(&Clay__layoutElementChildrenBuffer, element); + return element; +} + +void Clay__OpenContainerElement(int id, Clay_LayoutConfig *layoutConfig) { + Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_CONTAINER, layoutConfig, (Clay_ElementConfigUnion){ CLAY__NULL }); +} + +void Clay__OpenRectangleElement(int id, Clay_LayoutConfig *layoutConfig, Clay_RectangleElementConfig *rectangleConfig) { + Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_RECTANGLE, layoutConfig, (Clay_ElementConfigUnion) { .rectangleElementConfig = rectangleConfig }); +} + +void Clay__OpenImageContainerElement(int id, Clay_LayoutConfig *layoutConfig, Clay_ImageElementConfig *imageConfig) { + Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_IMAGE, layoutConfig, (Clay_ElementConfigUnion) { .imageElementConfig = imageConfig }); + Clay__LayoutElementPointerArray_Add(&Clay__imageElementPointers, Clay__openLayoutElement); +} + +void Clay__OpenBorderContainerElement(int id, Clay_LayoutConfig *layoutConfig, Clay_BorderContainerElementConfig *borderConfig) { + Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_BORDER_CONTAINER, layoutConfig, (Clay_ElementConfigUnion){ .borderElementConfig = borderConfig }); +} + +void Clay__OpenCustomElement(uint32_t id, Clay_LayoutConfig *layoutConfig, Clay_CustomElementConfig *customElementConfig) { + Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_CUSTOM, layoutConfig, (Clay_ElementConfigUnion) { .customElementConfig = customElementConfig }); +} + +Clay_LayoutElement *Clay__OpenScrollElement(uint32_t id, Clay_LayoutConfig *layoutConfig, Clay_ScrollContainerElementConfig *scrollConfig) { + Clay_LayoutElement *scrollElement = Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER, layoutConfig, (Clay_ElementConfigUnion){ .scrollElementConfig = scrollConfig }); + Clay__int32_tArray_Add(&Clay__openClipElementStack, (int)scrollElement->id); + Clay__ScrollContainerData *scrollOffset = CLAY__NULL; + for (int i = 0; i < Clay__scrollContainerOffsets.length; i++) { + Clay__ScrollContainerData *mapping = Clay__ScrollContainerDataArray_Get(&Clay__scrollContainerOffsets, i); + if (id == mapping->elementId) { + scrollOffset = mapping; + scrollOffset->layoutElement = scrollElement; + scrollOffset->openThisFrame = true; + } + } + if (!scrollOffset) { + Clay__ScrollContainerDataArray_Add(&Clay__scrollContainerOffsets, (Clay__ScrollContainerData){.elementId = id, .layoutElement = scrollElement, .scrollOrigin = {-1,-1}, .openThisFrame = true}); + } + return scrollElement; +} + +Clay_LayoutElement *Clay__OpenFloatingContainerElement(uint32_t id, Clay_LayoutConfig *layoutConfig, Clay_FloatingElementConfig *floatingElementConfig) { + Clay_LayoutElement *parent = Clay__openLayoutElement; + if (floatingElementConfig->parentId > 0) { + Clay_LayoutElementHashMapItem *parentItem = Clay__GetHashMapItem(floatingElementConfig->parentId); + if (!parentItem) { + Clay_StringArray_Add(&Clay_warnings, CLAY_STRING("Clay Warning: Couldn't find parent container to attach floating container to.")); + } else { + parent = parentItem->layoutElement; + } + } + Clay__OpenElementWithParent(id, CLAY__LAYOUT_ELEMENT_TYPE_FLOATING_CONTAINER, layoutConfig, (Clay_ElementConfigUnion) { .floatingElementConfig = floatingElementConfig }); + Clay__LayoutElementTreeRootArray_Add(&Clay__layoutElementTreeRoots, (Clay__LayoutElementTreeRoot) { + .layoutElement = Clay__openLayoutElement, + .parentId = parent->id, + .zIndex = floatingElementConfig->zIndex, + .clipElementId = Clay__openClipElementStack.length > 0 ? (uint32_t)*Clay__int32_tArray_Get(&Clay__openClipElementStack, (int)Clay__openClipElementStack.length - 1) : 0, + }); + return Clay__openLayoutElement; +} + +void Clay__AttachContainerChildren() { + Clay_LayoutConfig *layoutConfig = Clay__openLayoutElement->layoutConfig; + Clay__openLayoutElement->children.elements = &Clay__layoutElementChildren.internalArray[Clay__layoutElementChildren.length]; + + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + for (int i = 0; i < Clay__openLayoutElement->children.length; i++) { + Clay_LayoutElement *child = *Clay__LayoutElementPointerArray_Get(&Clay__layoutElementChildrenBuffer, (int)Clay__layoutElementChildrenBuffer.length - Clay__openLayoutElement->children.length + i); + Clay__openLayoutElement->dimensions.width += child->dimensions.width; + Clay__openLayoutElement->dimensions.height = CLAY__MAX(Clay__openLayoutElement->dimensions.height, child->dimensions.height + layoutConfig->padding.y * 2); + // Minimum size of child elements doesn't matter to scroll containers as they can shrink and hide their contents + if (Clay__openLayoutElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER || !Clay__openLayoutElement->elementConfig.scrollElementConfig->horizontal) { + Clay__openLayoutElement->minDimensions.width += child->minDimensions.width; + } + if (Clay__openLayoutElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER || !Clay__openLayoutElement->elementConfig.scrollElementConfig->vertical) { + Clay__openLayoutElement->minDimensions.height = CLAY__MAX(Clay__openLayoutElement->minDimensions.height, child->minDimensions.height + layoutConfig->padding.y * 2); + } + Clay__LayoutElementPointerArray_Add(&Clay__layoutElementChildren, child); + } + float childGap = (float)(CLAY__MAX(Clay__openLayoutElement->children.length - 1, 0) * layoutConfig->childGap); + Clay__openLayoutElement->dimensions.width += childGap; + Clay__openLayoutElement->minDimensions.width += childGap; + } + else if (layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM) { + for (int i = 0; i < Clay__openLayoutElement->children.length; i++) { + Clay_LayoutElement *child = *Clay__LayoutElementPointerArray_Get(&Clay__layoutElementChildrenBuffer, (int)Clay__layoutElementChildrenBuffer.length - Clay__openLayoutElement->children.length + i); + Clay__openLayoutElement->dimensions.height += child->dimensions.height; + Clay__openLayoutElement->dimensions.width = CLAY__MAX(Clay__openLayoutElement->dimensions.width, child->dimensions.width + layoutConfig->padding.x * 2); + // Minimum size of child elements doesn't matter to scroll containers as they can shrink and hide their contents + if (Clay__openLayoutElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER || !Clay__openLayoutElement->elementConfig.scrollElementConfig->vertical) { + Clay__openLayoutElement->minDimensions.height += child->minDimensions.height; + } + if (Clay__openLayoutElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER || !Clay__openLayoutElement->elementConfig.scrollElementConfig->horizontal) { + Clay__openLayoutElement->minDimensions.width = CLAY__MAX(Clay__openLayoutElement->minDimensions.width, child->minDimensions.width + layoutConfig->padding.x * 2); + } + Clay__LayoutElementPointerArray_Add(&Clay__layoutElementChildren, child); + } + float childGap = (float)(CLAY__MAX(Clay__openLayoutElement->children.length - 1, 0) * layoutConfig->childGap); + Clay__openLayoutElement->dimensions.height += childGap; + Clay__openLayoutElement->minDimensions.height += childGap; + } + + Clay__layoutElementChildrenBuffer.length -= Clay__openLayoutElement->children.length; +} + +void Clay__CloseElement() { + Clay_LayoutConfig *layoutConfig = Clay__openLayoutElement->layoutConfig; + + if (layoutConfig->sizing.width.type != CLAY__SIZING_TYPE_PERCENT) { + // TODO I think minsize has already been applied by this point so no need to do it again + Clay__openLayoutElement->dimensions.width = CLAY__MIN(CLAY__MAX(Clay__openLayoutElement->dimensions.width, layoutConfig->sizing.width.sizeMinMax.min), layoutConfig->sizing.width.sizeMinMax.max); + } else { + Clay__openLayoutElement->dimensions.width = 0; + } + if (layoutConfig->sizing.height.type != CLAY__SIZING_TYPE_PERCENT) { + Clay__openLayoutElement->dimensions.height = CLAY__MIN(CLAY__MAX(Clay__openLayoutElement->dimensions.height, layoutConfig->sizing.height.sizeMinMax.min), layoutConfig->sizing.height.sizeMinMax.max); + } else { + Clay__openLayoutElement->dimensions.height = 0; + } + + Clay__LayoutElementPointerArray_RemoveSwapback(&Clay__openLayoutElementStack, (int)Clay__openLayoutElementStack.length - 1); + Clay__openLayoutElement = *Clay__LayoutElementPointerArray_Get(&Clay__openLayoutElementStack, (int)Clay__openLayoutElementStack.length - 1); +} + +void Clay__OpenTextElement(int id, Clay_String text, Clay_TextElementConfig *textConfig) { + Clay_LayoutElement *internalElement = Clay__OpenElement(id, CLAY__LAYOUT_ELEMENT_TYPE_TEXT, &CLAY_LAYOUT_DEFAULT, (Clay_ElementConfigUnion) { .textElementConfig = textConfig }); + Clay_Dimensions textMeasured = Clay__MeasureTextCached(&text, textConfig); + internalElement->dimensions.width = textMeasured.width; + internalElement->dimensions.height = textMeasured.height; + internalElement->text = text; + internalElement->minDimensions = (Clay_Dimensions) { .width = textMeasured.height, .height = textMeasured.height }; // TODO not sure this is the best way to decide min width for text + Clay__LayoutElementPointerArray_Add(&Clay__textElementPointers, internalElement); + Clay__CloseElement(); +} + +void Clay__CloseContainerElement() { + Clay__AttachContainerChildren(); + Clay__CloseElement(); +} + +void Clay__CloseScrollContainerElement() { + Clay__openClipElementStack.length--; + Clay__CloseContainerElement(); +} + +void Clay__CloseFloatingContainer() { + Clay__AttachContainerChildren(); + Clay__CloseElement(); +} + +void Clay__InitializeEphemeralMemory(Clay_Arena *arena) { + // Ephemeral Memory - reset every frame + Clay__internalArena.nextAllocation = Clay__arenaResetOffset; + + Clay__layoutElementChildrenBuffer = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__layoutElements = Clay_LayoutElementArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay_warnings = Clay_StringArray_Allocate_Arena(100, arena); + + Clay__layoutConfigs = Clay_LayoutConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__rectangleElementConfigs = Clay_RectangleElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__textElementConfigs = Clay_TextElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__imageElementConfigs = Clay_ImageElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__floatingElementConfigs = Clay_FloatingElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__scrollElementConfigs = Clay_ScrollContainerElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__customElementConfigs = Clay_CustomElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__borderElementConfigs = Clay_BorderContainerElementConfigArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + + Clay__layoutElementTreeNodeArray1 = Clay__LayoutElementTreeNodeArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__layoutElementTreeRoots = Clay__LayoutElementTreeRootArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__layoutElementChildren = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__openLayoutElementStack = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__textElementPointers = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__imageElementPointers = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__layoutElementReusableBuffer = Clay__LayoutElementPointerArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__renderCommands = Clay_RenderCommandArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__treeNodeVisited = Clay__BoolArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__treeNodeVisited.length = Clay__treeNodeVisited.capacity; // This array is accessed directly rather than behaving as a list + Clay__openClipElementStack = Clay__int32_tArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); +} + +void Clay__InitializePersistentMemory(Clay_Arena *arena) { + Clay__scrollContainerOffsets = Clay__ScrollContainerDataArray_Allocate_Arena(10, arena); + Clay__layoutElementsHashMapInternal = Clay__LayoutElementHashMapItemArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__layoutElementsHashMap = Clay__int32_tArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__measureTextHashMapInternal = Clay__MeasureTextCacheItemArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__measureTextHashMap = Clay__int32_tArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__pointerOverIds = Clay__int32_tArray_Allocate_Arena(CLAY_MAX_ELEMENT_COUNT, arena); + Clay__arenaResetOffset = arena->nextAllocation; +} + + +typedef enum +{ + CLAY__SIZE_DISTRIBUTION_TYPE_SCROLL_CONTAINER, + CLAY__SIZE_DISTRIBUTION_TYPE_RESIZEABLE_CONTAINER, + CLAY__SIZE_DISTRIBUTION_TYPE_GROW_CONTAINER, +} Clay__SizeDistributionType; + +// Because of the max and min sizing properties, we can't predict ahead of time how (or if) all the excess width +// will actually be distributed. So we keep looping until either all the excess width is distributed or +// we have exhausted all our containers that can change size along this axis +float Clay__DistributeSizeAmongChildren(bool xAxis, float sizeToDistribute, Clay__LayoutElementPointerArray resizableContainerBuffer, Clay__SizeDistributionType distributionType) { + Clay__LayoutElementPointerArray backBuffer = Clay__layoutElementReusableBuffer; + backBuffer.length = 0; + + Clay__LayoutElementPointerArray remainingElements = resizableContainerBuffer; + float totalDistributedSize; + while (sizeToDistribute != 0 && remainingElements.length > 0) { + totalDistributedSize = 0; + for (int childOffset = 0; childOffset < remainingElements.length; childOffset++) { + Clay_LayoutElement *childElement = *Clay__LayoutElementPointerArray_Get(&remainingElements, childOffset); + Clay_SizingAxis childSizing = xAxis ? childElement->layoutConfig->sizing.width : childElement->layoutConfig->sizing.height; + float *childSize = xAxis ? &childElement->dimensions.width : &childElement->dimensions.height; + float childMinSize = xAxis ? childElement->minDimensions.width : childElement->minDimensions.height; + + if ((sizeToDistribute < 0 && *childSize == childSizing.sizeMinMax.min) || (sizeToDistribute > 0 && *childSize == childSizing.sizeMinMax.max)) { + continue; + } + + if (!xAxis && childElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_IMAGE) { + continue; // Currently, we don't support squishing aspect ratio images on their Y axis as it would break ratio + } + + switch (distributionType) { + case CLAY__SIZE_DISTRIBUTION_TYPE_RESIZEABLE_CONTAINER: break; + case CLAY__SIZE_DISTRIBUTION_TYPE_GROW_CONTAINER: if (childSizing.type != CLAY__SIZING_TYPE_GROW) { continue; } break; + case CLAY__SIZE_DISTRIBUTION_TYPE_SCROLL_CONTAINER: if ((childElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER || (xAxis && !childElement->elementConfig.scrollElementConfig->horizontal) || (!xAxis && !childElement->elementConfig.scrollElementConfig->vertical))) { continue; } break; + } + + float dividedSize = sizeToDistribute / (float)(remainingElements.length - childOffset); + float oldChildSize = *childSize; + *childSize = CLAY__MAX(CLAY__MAX(CLAY__MIN(childSizing.sizeMinMax.max, *childSize + dividedSize), childSizing.sizeMinMax.min), childMinSize); + float diff = *childSize - oldChildSize; + if (diff != 0) { + Clay__LayoutElementPointerArray_Add(&backBuffer, childElement); + } + sizeToDistribute -= diff; + totalDistributedSize += diff; + } + if (totalDistributedSize == 0) { + break; + } + // Flip the buffers + Clay__LayoutElementPointerArray temp = remainingElements; + remainingElements = backBuffer; + backBuffer = temp; + } + return sizeToDistribute; +} + +void Clay__SizeContainersAlongAxis(bool xAxis) { + Clay__LayoutElementPointerArray bfsBuffer = Clay__layoutElementChildrenBuffer; + Clay__LayoutElementPointerArray resizableContainerBuffer = Clay__openLayoutElementStack; + for (int rootIndex = 0; rootIndex < Clay__layoutElementTreeRoots.length; ++rootIndex) { + bfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&Clay__layoutElementTreeRoots, rootIndex); + Clay_LayoutElement *rootElement = root->layoutElement; + Clay__LayoutElementPointerArray_Add(&bfsBuffer, root->layoutElement); + rootElement->dimensions.width = CLAY__MIN(CLAY__MAX(rootElement->dimensions.width, rootElement->layoutConfig->sizing.width.sizeMinMax.min), rootElement->layoutConfig->sizing.width.sizeMinMax.max); + rootElement->dimensions.height = CLAY__MIN(CLAY__MAX(rootElement->dimensions.height, rootElement->layoutConfig->sizing.height.sizeMinMax.min), rootElement->layoutConfig->sizing.height.sizeMinMax.max); + + for (int i = 0; i < bfsBuffer.length; ++i) { + Clay_LayoutElement *parent = *Clay__LayoutElementPointerArray_Get(&bfsBuffer, i); + Clay_LayoutConfig *parentStyleConfig = parent->layoutConfig; + float parentSize = xAxis ? parent->dimensions.width : parent->dimensions.height; + float parentPadding = (float)(xAxis ? parent->layoutConfig->padding.x : parent->layoutConfig->padding.y); + float innerContentSize = 0, totalPaddingAndChildGaps = parentPadding * 2; + bool sizingAlongAxis = (xAxis && parentStyleConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) || (!xAxis && parentStyleConfig->layoutDirection == CLAY_TOP_TO_BOTTOM); + resizableContainerBuffer.length = 0; + float parentChildGap = parentStyleConfig->childGap; + + for (int childOffset = 0; childOffset < parent->children.length; childOffset++) { + Clay_LayoutElement *childElement = parent->children.elements[childOffset]; + Clay_SizingAxis childSizing = xAxis ? childElement->layoutConfig->sizing.width : childElement->layoutConfig->sizing.height; + float childSize = xAxis ? childElement->dimensions.width : childElement->dimensions.height; + + if (childElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_TEXT && childElement->children.length > 0) { + Clay__LayoutElementPointerArray_Add(&bfsBuffer, childElement); + } + + if (childSizing.type != CLAY__SIZING_TYPE_PERCENT) { + Clay__LayoutElementPointerArray_Add(&resizableContainerBuffer, childElement); + } + + if (sizingAlongAxis) { + innerContentSize += (childSizing.type == CLAY__SIZING_TYPE_PERCENT ? 0 : childSize); + if (childOffset > 0) { + innerContentSize += parentChildGap; // For children after index 0, the childAxisOffset is the gap from the previous child + totalPaddingAndChildGaps += parentChildGap; + } + } else { + innerContentSize = CLAY__MAX(childSize, innerContentSize); + } + } + + // Expand percentage containers to size + for (int childOffset = 0; childOffset < parent->children.length; childOffset++) { + Clay_LayoutElement *childElement = parent->children.elements[childOffset]; + Clay_SizingAxis childSizing = xAxis ? childElement->layoutConfig->sizing.width : childElement->layoutConfig->sizing.height; + float *childSize = xAxis ? &childElement->dimensions.width : &childElement->dimensions.height; + if (childSizing.type == CLAY__SIZING_TYPE_PERCENT) { + *childSize = (parentSize - totalPaddingAndChildGaps) * childSizing.sizePercent; + if (sizingAlongAxis) { + innerContentSize += *childSize; + if (childOffset > 0) { + innerContentSize += parentChildGap; // For children after index 0, the childAxisOffset is the gap from the previous child + totalPaddingAndChildGaps += parentChildGap; + } + } else { + innerContentSize = CLAY__MAX(*childSize, innerContentSize); + } + } + } + + if (sizingAlongAxis) { + float sizeToDistribute = parentSize - parentPadding * 2 - innerContentSize; + // If the content is too large, compress the children as much as possible + if (sizeToDistribute < 0) { + // If the parent can scroll in the axis direction in this direction, just leave the children alone + if (parent->elementType == CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER) { + if (((xAxis && parent->elementConfig.scrollElementConfig->horizontal) || (!xAxis && parent->elementConfig.scrollElementConfig->vertical))) { + continue; + } + } + // Scrolling containers preferentially compress before others + sizeToDistribute = Clay__DistributeSizeAmongChildren(xAxis, sizeToDistribute, resizableContainerBuffer, CLAY__SIZE_DISTRIBUTION_TYPE_SCROLL_CONTAINER); + + // If there is still height to make up, remove it from all containers that haven't hit their minimum size + if (sizeToDistribute < 0) { + Clay__DistributeSizeAmongChildren(xAxis, sizeToDistribute, resizableContainerBuffer, CLAY__SIZE_DISTRIBUTION_TYPE_RESIZEABLE_CONTAINER); + } + // The content is too small, allow SIZING_GROW containers to expand + } else { + Clay__DistributeSizeAmongChildren(xAxis, sizeToDistribute, resizableContainerBuffer, CLAY__SIZE_DISTRIBUTION_TYPE_GROW_CONTAINER); + } + // Sizing along the non layout axis ("off axis") + } else { + for (int childOffset = 0; childOffset < resizableContainerBuffer.length; childOffset++) { + Clay_LayoutElement *childElement = *Clay__LayoutElementPointerArray_Get(&resizableContainerBuffer, childOffset); + Clay_SizingAxis childSizing = xAxis ? childElement->layoutConfig->sizing.width : childElement->layoutConfig->sizing.height; + float *childSize = xAxis ? &childElement->dimensions.width : &childElement->dimensions.height; + + if (!xAxis && childElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_IMAGE) { + continue; // Currently we don't support resizing aspect ratio images on the Y axis because it would break the ratio + } + + // If we're laying out the children of a scroll panel, grow containers expand to the height of the inner content, not the outer container + float maxSize = parentSize - parentPadding * 2; + if (parent->elementType == CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER && ((xAxis && parent->elementConfig.scrollElementConfig->horizontal) || (!xAxis && parent->elementConfig.scrollElementConfig->vertical))) { + maxSize = CLAY__MAX(maxSize, innerContentSize); + } + if (childSizing.type == CLAY__SIZING_TYPE_FIT) { + *childSize = CLAY__MAX(childSizing.sizeMinMax.min, CLAY__MIN(*childSize, maxSize)); + } else if (childSizing.type == CLAY__SIZING_TYPE_GROW) { + *childSize = CLAY__MIN(maxSize, childSizing.sizeMinMax.max); + } + } + } + } + } +} + +void Clay__CalculateFinalLayout(int screenWidth, int screenHeight) { + // layoutElementsHashMap has non-linear access pattern so just resetting .length won't zero out the data. + // Need to zero it all out here + for (int i = 0; i < Clay__layoutElementsHashMap.capacity; ++i) { + Clay__layoutElementsHashMap.internalArray[i] = -1; + } + Clay__layoutElementsHashMapInternal.length = 0; + + // Calculate sizing along the X axis + Clay__SizeContainersAlongAxis(true); + + // Wrap text + uint32_t originalTextLayoutElementDataLength = Clay__textElementPointers.length; + for (int i = 0; i < originalTextLayoutElementDataLength; ++i) { + Clay_LayoutElement *containerElement = *Clay__LayoutElementPointerArray_Get(&Clay__textElementPointers, i); + Clay_String text = containerElement->text; + Clay_TextElementConfig *textConfig = containerElement->elementConfig.textElementConfig; + containerElement->elementType = CLAY__LAYOUT_ELEMENT_TYPE_CONTAINER; + // Clone the style config to prevent pollution of other elements that share this config + containerElement->layoutConfig = Clay_LayoutConfigArray_Add(&Clay__layoutConfigs, *containerElement->layoutConfig); + containerElement->layoutConfig->layoutDirection = CLAY_TOP_TO_BOTTOM; + containerElement->layoutConfig->childGap = textConfig->lineSpacing; + containerElement->dimensions.height = 0; + float fontSize = containerElement->elementConfig.textElementConfig->fontSize; + int lineStartIndex = 0; + int wordStartIndex = 0; + int wordEndIndex = 0; + containerElement->children = (Clay__LayoutElementChildren) { // Note: this overwrites the text property + .length = 0, + .elements = &Clay__layoutElementChildren.internalArray[Clay__layoutElementChildren.length] + }; + Clay_Dimensions lineDimensions = (Clay_Dimensions){}; + float spaceWidth = Clay__MeasureText(&CLAY__SPACECHAR, textConfig).width; // todo may as well cache it somewhere + while (wordStartIndex < text.length) { + if (text.chars[wordEndIndex] == ' ' || text.chars[wordEndIndex] == '\n' || wordEndIndex == text.length) { + Clay_String stringToRender = (Clay_String) { .length = wordEndIndex - lineStartIndex, .chars = text.chars + lineStartIndex }; + Clay_String wordToMeasure = (Clay_String) { .length = wordEndIndex - wordStartIndex, .chars = text.chars + wordStartIndex }; + // Clip off trailing spaces and newline characters + Clay_Dimensions wordDimensions = Clay__MeasureTextCached(&wordToMeasure, textConfig); + lineDimensions.width = lineDimensions.width + wordDimensions.width + spaceWidth; + lineDimensions.height = wordDimensions.height; + bool isOverlappingBoundaries = (lineDimensions.width - spaceWidth) > containerElement->dimensions.width + 0.01f; // Epsilon for floating point inaccuracy of adding components + // Need to wrap + if (isOverlappingBoundaries) { + lineDimensions.width -= spaceWidth; + // We can wrap at the most recent word start + if (wordStartIndex != lineStartIndex) { + stringToRender = (Clay_String) { .length = wordStartIndex - lineStartIndex - 1, .chars = text.chars + lineStartIndex }; + lineDimensions.width -= (wordDimensions.width + spaceWidth); + lineStartIndex = wordStartIndex; + wordStartIndex = lineStartIndex; + wordEndIndex = lineStartIndex; + containerElement->dimensions.width = CLAY__MAX(containerElement->dimensions.width, lineDimensions.width); + // The single word is larger than the entire container - just render it in place + } else { + lineStartIndex = wordEndIndex + 1; + wordStartIndex = lineStartIndex; + wordEndIndex = lineStartIndex; + containerElement->dimensions.width = CLAY__MAX(containerElement->dimensions.width, lineDimensions.width); + } + // If we're at a space character and the current phrase fits, just keep going + } else if (text.chars[wordEndIndex] == ' ') { + wordStartIndex = wordEndIndex + 1; + wordEndIndex = wordStartIndex; + continue; + // Newline or end of string + } else { + lineStartIndex = wordEndIndex + 1; + wordStartIndex = lineStartIndex; + wordEndIndex = lineStartIndex; + } + Clay_LayoutElement *newTextLayoutElement = Clay_LayoutElementArray_Add(&Clay__layoutElements, (Clay_LayoutElement) { + .id = Clay__RehashWithNumber(containerElement->id, containerElement->children.length), + .elementType = CLAY__LAYOUT_ELEMENT_TYPE_TEXT, + .text = stringToRender, + .layoutConfig = &CLAY_LAYOUT_DEFAULT, + .elementConfig.textElementConfig = containerElement->elementConfig.textElementConfig, + .dimensions = { lineDimensions.width, lineDimensions.height }, + }); + containerElement->dimensions.height += lineDimensions.height + (float)(containerElement->children.length > 0 ? textConfig->lineSpacing : 0); + containerElement->children.length++; + lineDimensions = (Clay_Dimensions) {}; + Clay__LayoutElementPointerArray_Add(&Clay__layoutElementChildren, newTextLayoutElement); + } else { + // In the middle of a word + wordEndIndex++; + } + } + } + + // Scale vertical image heights according to aspect ratio + for (int i = 0; i < Clay__imageElementPointers.length; ++i) { + Clay_LayoutElement* imageElement = *Clay__LayoutElementPointerArray_Get(&Clay__imageElementPointers, i); + Clay_ImageElementConfig *config = imageElement->elementConfig.imageElementConfig; + imageElement->dimensions.height = (config->sourceDimensions.height / CLAY__MAX(config->sourceDimensions.width, 1)) * imageElement->dimensions.width; + } + + // Propagate effect of text wrapping, image aspect scaling etc. on height of parents + Clay__LayoutElementTreeNodeArray dfsBuffer = Clay__layoutElementTreeNodeArray1; + dfsBuffer.length = 0; + for (int i = 0; i < Clay__layoutElementTreeRoots.length; ++i) { + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&Clay__layoutElementTreeRoots, i); + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, (Clay__LayoutElementTreeNode) { .layoutElement = root->layoutElement }); + } + Clay__treeNodeVisited.internalArray[0] = false; + while (dfsBuffer.length > 0) { + Clay__LayoutElementTreeNode *currentElementTreeNode = Clay__LayoutElementTreeNodeArray_Get(&dfsBuffer, (int)dfsBuffer.length - 1); + Clay_LayoutElement *currentElement = currentElementTreeNode->layoutElement; + if (!Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + Clay__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->children.length == 0 || (currentElement->children.length > 0 && currentElement->children.elements[0]->elementType == CLAY__LAYOUT_ELEMENT_TYPE_TEXT)) { + 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 (int i = 0; i < currentElement->children.length; i++) { + Clay__treeNodeVisited.internalArray[dfsBuffer.length] = false; + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, (Clay__LayoutElementTreeNode) { .layoutElement = 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 = currentElement->layoutConfig; + if (layoutConfig->sizing.height.type == CLAY__SIZING_TYPE_PERCENT) { + continue; + } + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + // Resize any parent containers that have grown in height along their non layout axis + for (int j = 0; j < currentElement->children.length; ++j) { + Clay_LayoutElement *childElement = currentElement->children.elements[j]; + float childHeightWithPadding = CLAY__MAX(childElement->dimensions.height + layoutConfig->padding.y * 2, currentElement->dimensions.height); + currentElement->dimensions.height = CLAY__MIN(CLAY__MAX(childHeightWithPadding, layoutConfig->sizing.height.sizeMinMax.min), layoutConfig->sizing.height.sizeMinMax.max); + } + } else if (layoutConfig->layoutDirection == CLAY_TOP_TO_BOTTOM) { + // Resizing along the layout axis + float contentHeight = (float)layoutConfig->padding.y * 2; + for (int j = 0; j < currentElement->children.length; ++j) { + Clay_LayoutElement *childElement = 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.sizeMinMax.min), layoutConfig->sizing.height.sizeMinMax.max); + } + } + + // Calculate sizing along the Y axis + Clay__SizeContainersAlongAxis(false); + + // Calculate final positions and generate render commands + Clay__renderCommands.length = 0; + dfsBuffer.length = 0; + for (int rootIndex = 0; rootIndex < Clay__layoutElementTreeRoots.length; ++rootIndex) { + dfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&Clay__layoutElementTreeRoots, rootIndex); + Clay_Vector2 rootPosition = (Clay_Vector2) {}; + Clay_LayoutElementHashMapItem *parentHashMapItem = Clay__GetHashMapItem(root->parentId); + // Position root floating containers + if (parentHashMapItem) { + Clay_FloatingElementConfig *config = root->layoutElement->elementConfig.floatingElementConfig; + Clay_Dimensions rootDimensions = root->layoutElement->dimensions; + Clay_Rectangle parentBoundingBox = parentHashMapItem->boundingBox; + // Set X position + Clay_Vector2 targetAttachPosition = (Clay_Vector2){}; + switch (config->attachment.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->attachment.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->attachment.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->attachment.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_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = Clay__RehashWithNumber(root->layoutElement->id, 10), // TODO need a better strategy for managing derived ids + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + .boundingBox = clipHashMapItem->boundingBox, + }); + } + } + Clay__LayoutElementTreeNodeArray_Add(&dfsBuffer, (Clay__LayoutElementTreeNode) { .layoutElement = root->layoutElement, .position = rootPosition, .nextChildOffset = (Clay_Vector2) { .x = (float)root->layoutElement->layoutConfig->padding.x, .y = (float)root->layoutElement->layoutConfig->padding.y } }); + + Clay__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->layoutConfig; + Clay_Vector2 scrollOffset = {0}; + + // This will only be run a single time for each element in downwards DFS order + if (!Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + + Clay_Rectangle currentElementBoundingBox = (Clay_Rectangle) { currentElementTreeNode->position.x, currentElementTreeNode->position.y, currentElement->dimensions.width, currentElement->dimensions.height }; + if (currentElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_FLOATING_CONTAINER) { + Clay_FloatingElementConfig *floatingElementConfig = currentElement->elementConfig.floatingElementConfig; + Clay_Dimensions expand = floatingElementConfig->expand; + currentElementBoundingBox.x -= expand.width; + currentElementBoundingBox.width += expand.width * 2; + currentElementBoundingBox.y -= expand.height; + currentElementBoundingBox.height += expand.height * 2; + } + + Clay__ScrollContainerData *scrollContainerData = CLAY__NULL; + // Apply scroll offsets to container + if (currentElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER) { + Clay_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = Clay__RehashWithNumber(currentElement->id, 10), + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_START, + .boundingBox = currentElementBoundingBox, + }); + + // 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 (int i = 0; i < Clay__scrollContainerOffsets.length; i++) { + Clay__ScrollContainerData *mapping = Clay__ScrollContainerDataArray_Get(&Clay__scrollContainerOffsets, i); + if (mapping->layoutElement == currentElement) { + scrollContainerData = mapping; + mapping->boundingBox = currentElementBoundingBox; + Clay_ScrollContainerElementConfig *config = mapping->layoutElement->elementConfig.scrollElementConfig; + if (config->horizontal) { + scrollOffset.x = mapping->scrollPosition.x; + } + if (config->vertical) { + scrollOffset.y = mapping->scrollPosition.y; + } + break; + } + } + } + + // Create the render command for this element + Clay_RenderCommand renderCommand = (Clay_RenderCommand) { + .id = currentElement->id, + .commandType = Clay__LayoutElementTypeToRenderCommandType[currentElement->elementType], + .boundingBox = currentElementBoundingBox, + .config = currentElement->elementConfig + }; + + Clay_LayoutElementHashMapItem *hashMapItem = Clay__AddHashMapItem(currentElement->id, currentElement); + if (hashMapItem) { + hashMapItem->boundingBox = renderCommand.boundingBox; + } + + // Don't bother to generate render commands for rectangles entirely outside the screen - this won't stop their children from being rendered if they overflow + bool offscreen = currentElementBoundingBox.x > (float)screenWidth || currentElementBoundingBox.y > (float)screenHeight || currentElementBoundingBox.x + currentElementBoundingBox.width < 0 || currentElementBoundingBox.y + currentElementBoundingBox.height < 0; + bool shouldRender = !offscreen; + switch (renderCommand.commandType) { + case CLAY_RENDER_COMMAND_TYPE_NONE: { + shouldRender = false; + break; + } + case CLAY_RENDER_COMMAND_TYPE_TEXT: { + renderCommand.text = currentElement->text; + break; + } + case CLAY_RENDER_COMMAND_TYPE_BORDER: { // We render borders on close because they need to render above children + shouldRender = false; + break; + } + default: break; + } + if (shouldRender) { + Clay_RenderCommandArray_Add(&Clay__renderCommands, renderCommand); + } + if (offscreen) { + // NOTE: You may be tempted to try an early return / continue if an element is off screen. Why bother calculating layout for its children, right? + // Unfortunately, a FLOATING_CONTAINER may be defined that attaches to a child or grandchild of this element, which is large enough to still + // be on screen, even if this element isn't. That depends on this element and it's children being laid out correctly (even if they are entirely off screen) + } + + // Handle child alignment along the layout axis + if (currentElementTreeNode->layoutElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_TEXT) { + dfsBuffer.length += currentElement->children.length; + + Clay_Dimensions contentSize = (Clay_Dimensions) {0,0}; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + for (int i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = currentElement->children.elements[i]; + contentSize.width += childElement->dimensions.width; + contentSize.height = CLAY__MAX(contentSize.height, childElement->dimensions.height); + } + contentSize.width += (float)(CLAY__MAX(currentElement->children.length - 1, 0) * layoutConfig->childGap); + float extraSpace = currentElement->dimensions.width - (float)layoutConfig->padding.x * 2 - contentSize.width; + switch (layoutConfig->childAlignment.x) { + case CLAY_ALIGN_X_LEFT: extraSpace = 0; break; + case CLAY_ALIGN_X_CENTER: extraSpace /= 2; break; + default: break; + } + currentElementTreeNode->nextChildOffset.x += extraSpace; + } else { + for (int i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = currentElement->children.elements[i]; + contentSize.width = CLAY__MAX(contentSize.width, childElement->dimensions.width); + contentSize.height += childElement->dimensions.height; + } + contentSize.height += (float)(CLAY__MAX(currentElement->children.length - 1, 0) * layoutConfig->childGap); + float extraSpace = currentElement->dimensions.height - (float)layoutConfig->padding.y * 2 - contentSize.height; + switch (layoutConfig->childAlignment.y) { + case CLAY_ALIGN_Y_TOP: extraSpace = 0; break; + case CLAY_ALIGN_Y_CENTER: extraSpace /= 2; break; + default: break; + } + currentElementTreeNode->nextChildOffset.y += extraSpace; + } + + if (scrollContainerData) { + scrollContainerData->contentSize = contentSize; + } + } + } else { + // DFS is returning upwards backwards + if (currentElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_SCROLL_CONTAINER) { + Clay_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = Clay__RehashWithNumber(currentElement->id, 11), + .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_END, + }); + // Borders between elements are expressed as additional rectangle render commands + } else if (currentElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_BORDER_CONTAINER) { + Clay_Rectangle currentElementBoundingBox = (Clay_Rectangle) { currentElementTreeNode->position.x, currentElementTreeNode->position.y, currentElement->dimensions.width, currentElement->dimensions.height }; + Clay_BorderContainerElementConfig *borderConfig = currentElement->elementConfig.borderElementConfig; + + Clay_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = currentElement->id, + .commandType = CLAY_RENDER_COMMAND_TYPE_BORDER, + .boundingBox = currentElementBoundingBox, + .config = currentElement->elementConfig + }); + + // Render border elements between children + if (borderConfig->betweenChildren.width > 0 && borderConfig->betweenChildren.color.a > 0) { + Clay_Vector2 borderOffset = { (float)layoutConfig->padding.x, (float)layoutConfig->padding.y }; + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + for (int i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = currentElement->children.elements[i]; + if (i > 0) { + Clay_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = Clay__RehashWithNumber(currentElement->id, 5 + i), + .commandType = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + .boundingBox = { currentElementBoundingBox.x + borderOffset.x, currentElementBoundingBox.y, (float)borderConfig->betweenChildren.width, currentElement->dimensions.height }, + .config = CLAY_RECTANGLE_CONFIG(.color = borderConfig->betweenChildren.color) + }); + } + borderOffset.x += (childElement->dimensions.width + (float)layoutConfig->childGap / 2); + } + } else { + for (int i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = currentElement->children.elements[i]; + if (i > 0) { + Clay_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { + .id = Clay__RehashWithNumber(currentElement->id, 5 + i), + .commandType = CLAY_RENDER_COMMAND_TYPE_RECTANGLE, + .boundingBox = { currentElementBoundingBox.x, currentElementBoundingBox.y + borderOffset.y, currentElement->dimensions.width, (float)borderConfig->betweenChildren.width }, + .config = CLAY_RECTANGLE_CONFIG(.color = borderConfig->betweenChildren.color) + }); + } + borderOffset.y += (childElement->dimensions.height + (float)layoutConfig->childGap / 2); + } + } + } + } + dfsBuffer.length--; + continue; + } + + // Add children to the DFS buffer + if (currentElement->elementType != CLAY__LAYOUT_ELEMENT_TYPE_TEXT) { + for (int i = 0; i < currentElement->children.length; ++i) { + Clay_LayoutElement *childElement = currentElement->children.elements[i]; + // Alignment along non layout axis + if (layoutConfig->layoutDirection == CLAY_LEFT_TO_RIGHT) { + currentElementTreeNode->nextChildOffset.y = currentElement->layoutConfig->padding.y; + float whiteSpaceAroundChild = currentElement->dimensions.height - (float)currentElement->layoutConfig->padding.y * 2 - 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->layoutConfig->padding.x; + float whiteSpaceAroundChild = currentElement->dimensions.width - (float)currentElement->layoutConfig->padding.x * 2 - 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 = (Clay_Vector2) { + currentElementTreeNode->position.x + currentElementTreeNode->nextChildOffset.x + scrollOffset.x, + currentElementTreeNode->position.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__LayoutElementTreeNode) { + .layoutElement = childElement, + .position = (Clay_Vector2) { childPosition.x, childPosition.y }, + .nextChildOffset = (Clay_Vector2) { .x = (float)childElement->layoutConfig->padding.x, .y = (float)childElement->layoutConfig->padding.y }, + }; + Clay__treeNodeVisited.internalArray[newNodeIndex] = false; + + // Update parent offsets + 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_RenderCommandArray_Add(&Clay__renderCommands, (Clay_RenderCommand) { .id = Clay__RehashWithNumber(root->layoutElement->id, 11), .commandType = CLAY_RENDER_COMMAND_TYPE_SCISSOR_END }); + } + } +} + +// PUBLIC API FROM HERE --------------------------------------- + +CLAY_WASM_EXPORT("Clay_MinMemorySize") +uint32_t Clay_MinMemorySize() { + Clay_Arena fakeArena = (Clay_Arena) { .capacity = INT64_MAX }; + Clay__InitializePersistentMemory(&fakeArena); + Clay__InitializeEphemeralMemory(&fakeArena); + return fakeArena.nextAllocation; +} + +CLAY_WASM_EXPORT("Clay_CreateArenaWithCapacityAndMemory") +Clay_Arena Clay_CreateArenaWithCapacityAndMemory(uint32_t capacity, void *offset) { + Clay_Arena arena = (Clay_Arena) { + .capacity = capacity, + .memory = (char *)offset + }; + return arena; +} + +#ifndef CLAY_WASM +void Clay_SetMeasureTextFunction(Clay_Dimensions (*measureTextFunction)(Clay_String *text, Clay_TextElementConfig *config)) { + Clay__MeasureText = measureTextFunction; +} +#endif + +CLAY_WASM_EXPORT("Clay_SetPointerPosition") +void Clay_SetPointerPosition(Clay_Vector2 position) { + Clay__pointerPosition = position; + Clay__pointerOverIds.length = 0; + Clay__LayoutElementPointerArray dfsBuffer = Clay__layoutElementChildrenBuffer; + for (int rootIndex = 0; rootIndex < Clay__layoutElementTreeRoots.length; ++rootIndex) { + dfsBuffer.length = 0; + Clay__LayoutElementTreeRoot *root = Clay__LayoutElementTreeRootArray_Get(&Clay__layoutElementTreeRoots, rootIndex); + Clay__LayoutElementPointerArray_Add(&dfsBuffer, root->layoutElement); + Clay__treeNodeVisited.internalArray[0] = false; + while (dfsBuffer.length > 0) { + if (Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1]) { + dfsBuffer.length--; + continue; + } + Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1] = true; + Clay_LayoutElement *currentElement = *Clay__LayoutElementPointerArray_Get(&dfsBuffer, (int)dfsBuffer.length - 1); + Clay_LayoutElementHashMapItem *mapItem = Clay__GetHashMapItem(currentElement->id); // TODO I wish there was a way around this, maybe the fact that it's essentially a binary tree limits the cost, have to measure + if ((mapItem && Clay__PointIsInsideRect(position, mapItem->boundingBox)) || (!mapItem && Clay__PointIsInsideRect(position, (Clay_Rectangle) {0,0, currentElement->dimensions.width, currentElement->dimensions.height}))) { + Clay__int32_tArray_Add(&Clay__pointerOverIds, (int)currentElement->id); + if (currentElement->elementType == CLAY__LAYOUT_ELEMENT_TYPE_TEXT) { + dfsBuffer.length--; + continue; + } + for (int i = currentElement->children.length - 1; i >= 0; --i) { + Clay__LayoutElementPointerArray_Add(&dfsBuffer, currentElement->children.elements[i]); + Clay__treeNodeVisited.internalArray[dfsBuffer.length - 1] = false; // TODO needs to be ranged checked + } + } else { + dfsBuffer.length--; + } + } + } +} + +CLAY_WASM_EXPORT("Clay_Initialize") +void Clay_Initialize(Clay_Arena arena) { + Clay__internalArena = arena; + Clay__InitializePersistentMemory(&Clay__internalArena); + Clay__InitializeEphemeralMemory(&Clay__internalArena); + for (int i = 0; i < Clay__layoutElementsHashMap.capacity; ++i) { + Clay__layoutElementsHashMap.internalArray[i] = -1; + } + Clay__measureTextHashMapInternal.length = 1; // Reserve the 0 value to mean "no next element" +} + +CLAY_WASM_EXPORT("Clay_UpdateScrollContainers") +void Clay_UpdateScrollContainers(bool isPointerActive, Clay_Vector2 scrollDelta, float deltaTime) { + // Don't apply scroll events to ancestors of the inner element + int32_t highestPriorityElementIndex = -1; + Clay__ScrollContainerData *highestPriorityScrollData = CLAY__NULL; + for (int i = 0; i < Clay__scrollContainerOffsets.length; i++) { + Clay__ScrollContainerData *scrollData = Clay__ScrollContainerDataArray_Get(&Clay__scrollContainerOffsets, i); + if (!scrollData->openThisFrame) { + Clay__ScrollContainerDataArray_RemoveSwapback(&Clay__scrollContainerOffsets, 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__ScrollContainerDataArray_RemoveSwapback(&Clay__scrollContainerOffsets, 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_Vector2){0,0}; + scrollData->scrollOrigin = (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__MAX(CLAY__MIN(scrollData->scrollPosition.x, 0), -(scrollData->contentSize.width - scrollData->layoutElement->dimensions.width)); + + 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__MAX(CLAY__MIN(scrollData->scrollPosition.y, 0), -(scrollData->contentSize.height - scrollData->layoutElement->dimensions.height)); + + for (int j = 0; j < Clay__pointerOverIds.length; ++j) { // TODO n & m are small here but this being n*m gives me the creeps + if (scrollData->layoutElement->id == *Clay__int32_tArray_Get(&Clay__pointerOverIds, j)) { + highestPriorityElementIndex = j; + highestPriorityScrollData = scrollData; + } + } + } + + if (highestPriorityElementIndex > -1 && highestPriorityScrollData) { + Clay_LayoutElement *scrollElement = highestPriorityScrollData->layoutElement; + bool canScrollVertically = scrollElement->elementConfig.scrollElementConfig->vertical && highestPriorityScrollData->contentSize.height > scrollElement->dimensions.height; + bool canScrollHorizontally = scrollElement->elementConfig.scrollElementConfig->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_Vector2){0}; + if (!highestPriorityScrollData->pointerScrollActive) { + highestPriorityScrollData->pointerOrigin = Clay__pointerPosition; + 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 + (Clay__pointerPosition.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 + (Clay__pointerPosition.y - highestPriorityScrollData->pointerOrigin.y); + highestPriorityScrollData->scrollPosition.y = CLAY__MAX(CLAY__MIN(highestPriorityScrollData->scrollPosition.y, 0), -(highestPriorityScrollData->contentSize.height - highestPriorityScrollData->boundingBox.height)); + scrollDeltaX = highestPriorityScrollData->scrollPosition.x - oldYScrollPosition; + } + if (scrollDeltaX > -0.1f && scrollDeltaX < 0.1f && scrollDeltaY > -0.1f && scrollDeltaY < 0.1f && highestPriorityScrollData->momentumTime > 0.5f) { + highestPriorityScrollData->momentumTime = 0; + highestPriorityScrollData->pointerOrigin = Clay__pointerPosition; + 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(int screenWidth, int screenHeight) { + Clay__InitializeEphemeralMemory(&Clay__internalArena); + // Set up the root container that covers the entire window + Clay_LayoutElement rootLayoutElement = (Clay_LayoutElement){.layoutConfig = CLAY_LAYOUT(.sizing = {CLAY_SIZING_FIXED((float)screenWidth), CLAY_SIZING_FIXED((float)screenHeight)})}; + Clay__openLayoutElement = Clay_LayoutElementArray_Add(&Clay__layoutElements, rootLayoutElement); + Clay__LayoutElementPointerArray_Add(&Clay__openLayoutElementStack, Clay__openLayoutElement); + Clay__LayoutElementTreeRootArray_Add(&Clay__layoutElementTreeRoots, (Clay__LayoutElementTreeRoot) { .layoutElement = Clay__openLayoutElement }); +} + +CLAY_WASM_EXPORT("Clay_EndLayout") +Clay_RenderCommandArray Clay_EndLayout(int screenWidth, int screenHeight) +{ + Clay__AttachContainerChildren(); + Clay__CalculateFinalLayout(screenWidth, screenHeight); + return Clay__renderCommands; +} + +CLAY_WASM_EXPORT("Clay_PointerOver") +bool Clay_PointerOver(uint32_t id) { // TODO return priority for separating multiple results + for (int i = 0; i < Clay__pointerOverIds.length; ++i) { + if (*Clay__int32_tArray_Get(&Clay__pointerOverIds, i) == id) { + return true; + } + } + return false; +} + +#endif //CLAY_IMPLEMENTATION diff --git a/examples/clay-official-website/CMakeLists.txt b/examples/clay-official-website/CMakeLists.txt new file mode 100644 index 0000000..be7aa21 --- /dev/null +++ b/examples/clay-official-website/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 3.28) +project(clay_official_website C) + +set(CMAKE_C_STANDARD 99) + +add_executable(clay_official_website main.c) + +target_compile_options(clay_official_website PUBLIC -DCLAY_OVERFLOW_TRAP -Wno-initializer-overrides) +target_include_directories(clay_official_website PUBLIC .) + +set(CMAKE_CXX_FLAGS_RELEASE "-O3") + +add_custom_command( + TARGET clay_official_website POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/resources + ${CMAKE_CURRENT_BINARY_DIR}/resources) \ No newline at end of file diff --git a/examples/clay-official-website/build.sh b/examples/clay-official-website/build.sh new file mode 100755 index 0000000..e10fc68 --- /dev/null +++ b/examples/clay-official-website/build.sh @@ -0,0 +1,17 @@ +mkdir -p build/clay \ +&& clang \ +-Os \ +-DCLAY_WASM \ +-mbulk-memory \ +--target=wasm32 \ +-nostdlib \ +-Wl,--strip-all \ +-Wl,--export-dynamic \ +-Wl,--no-entry \ +-Wl,--export=__heap_base \ +-Wl,--export=ACTIVE_RENDERER_INDEX \ +-Wl,--initial-memory=6553600 \ +-o build/clay/index.wasm \ +main.c \ +&& cp index.html build/clay/index.html && cp -r fonts/ build/clay/fonts \ +&& cp index.html build/clay/index.html && cp -r images/ build/clay/images \ No newline at end of file diff --git a/examples/clay-official-website/fonts/Calistoga-Regular.ttf b/examples/clay-official-website/fonts/Calistoga-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..3fc1c1ed0372080295db8308cbdef61945cb039b GIT binary patch literal 47144 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�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 >$`2U?t54;T${pbFSqEl# z26U_*crxj+h}YuXLZ2lRTe>p#{`ApHa9uK{2FL7Q!;aDXxkU(8pDHx0*?d!_;^`Pw zeo=V>RQX|TuF9{$*Lwg9yjwgf{|@-S#qXyKNBmV`GP__=sPb#8H(L?jz6whG^32s$ zd%OmDU2>qOiFx(y)8`&lo2S}q0Rpg{uK|NRzESxjB-=b{oLhKn_5*G&t*=*J zuiT8j*aKRegVBg_)x0v=zHCB6QMh(g%xKzrf~35BI#p}E&b#gcR`|`KD`fn0>tM{m~0+M zGk#B^c|jT~|6Cp805&g!bB-EBwENM|q$BQaY&3&`AN0P~%N(`9y(+9fb2*!0XSXaJ zUbzL_yt#rLr}7hqHP-!L<$m;t<7sgfkC|_7seFuKhW;;CZpPgoAWg4To~prv6#t>} z9bmpNj=eEg^9NiPtdhCL*8$_TMGJw|&of(fjgf>vpPrB@ob$jJzW=p@>2B4Nu*{`) z^drV8n18hv>&k-zETe!=0Ht1p=9qM4XGFd^fWse?lf}?X_zS!r51> zum%Gb4o8F4r&4C^f6|Bk+M-u&EUrw}YKIwbSnrndxVqk#YNM(%v9Z-zSqnH^U75Mw znteV8AI$YH&dSDCdoR5^{ob1MtTT(@X;m-S|F^`2+(CftP9sju;xBII3<)z^$RqCF zj;x5~3)`VbZa{M)^7OFk9}XYJS=#JG1n)$RPl1;b@LjHsZ_ph0muM`H2%-APqskh? zTvl9}Kx-25e$6hYFnb0W3yW}bm>*veGw{^|+4O(&VE^jaS^>k~I;<;O(c&{}V{5Zl zS0-Xr)XaJC4+PA$)nrsdPY3?k3J_hJbPQspJihmjV66h%ll}j87_52(`=Xa_uP28`rPH8UM4LB>BM1 z#x+S+T|rD{2W$?w+W?yOd z;NX6;@sh){yU6B!d-u$eo%nzB>?3pL`G9#oYM!q#&(|F|w*N5lPKzp5

X0hln!| z&afHSGm}&+-?gNk;w@`onoF^Ab{4?zIC9O}-!)`2a?NYV-;zi1_dHg`dNI9W+zyy> z&7nTPvg#ycmz^8&w$_W)RN0&?53jW~VC>?P0R3e>b}wy%?yzwK$aq;@maWQ#3I{4j zn3E#MWUvUdkd553(B4#S_n4z6P}{NkSs1gK7}P1$&6qD_t6)F21L81sS%ti&pmn`~ x$X2t=yf&h0z}D4=bJ|=fTOmaYJ2MEZKF7{c!dk44ofvPP)Tsw@I14-?iy0XB zj({-ZRBb+Kpn|CZJ|V6^$rVmAqi9ftfL`80Ibg)Jmjw9*GpJ?FKXCKSkAL4^UEez= zRe{NO#nb=y7dbOZPI&&HRZwcd=c&wJ-j5oRhkj=fu0y`g8u z6M?e7>HH11{hk?btzWKwI@{=v``yB8C+s;?yMlf{`X+Md1zSyiPKuMf=sBJ9EwMW` zPsuF~+$53UHo0_dxbo4ePkFa4#MK?XU6Te(NX((0E{-7;bLLKu^$-aZX*j>}+Sl~! zVcNxK?~0ZLM(YZ>bX=LBB;>2T>CB2L8>%`cG;zGTs1FTE%-wIRZ(V%u?>@)$cYB{JonT>W-u*+_yl>i;AD$~O ztoBWCjag);!&Mj)`{025#*jI@#_Kvnl^kzvD)bXeSC(6Tl5vSbvQm^_dh+4)`D+wj z&yJj${_p6-#U+i|T29R8++?aWnsVk`I>D^+n7vb>`swmCIfbLgB`q4Yoqm75x#4WJ zhvT|0!hw9p6%9D%@{-e9>f#<4RZd|KR<1pEm@}t4@dHEWV#mhA z3;z5)-CA5^qj2M+s?NNbRR zHgRT>OSx#(&-1P`+e>eKUKACLUSwv(TH?hAUqJN}fv z^kYERG7Y2Pj}H9&-Wg_HK_bmI{OlXn#m<>5AyQ${l73sobE0Es`(Y00+DSTz0Z+7N zPu!)=!P8~)q(mtvYN<#?vk|}hI|Y@sUjNzdEjT2fn>?-5;{TMe)3?r?dEN6yFRHgc z+4s%4l=#on!{*qxYfrwrg-ib9F~R@OqVBJ<@Uio|!}aD|+2fpuJ+H5OY&f{%hS0PJ zSA03RbXxanC1(a+e)W_k;A>oc|0A6pjC&aLE>CA%YH^o?i7{s9`pN6F8Js4h{aw=C z|J&A`Yr(ZYF6{QRPnvo!e74|PmH+S0i+`qhUx;0z+MoHPxXnqwH^YD3uC04~(*qYj z=zEjDE^)I~{O1`KksVShr)QQut$gV9QsMmiNqnc{nzyHZ{PFm_n~SDb_qN;NS6q(j zFNp3rEwgX(w)Z&#^BuIUyXR-y)UY3_`t;gi(&qDg_r+hWkI%BJ2v56HZ@&4w%bwy3 RQouaV;OXk;vd$@?2>{)Oj8gyr literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/check_2.png b/examples/clay-official-website/images/check_2.png new file mode 100644 index 0000000000000000000000000000000000000000..7972581fd17ed3b85d120451130652f2ea3f4f06 GIT binary patch literal 1508 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I3?%1nZ+ru!7>k44ofvPP)Tsw@I14-?iy0XB zj({-ZRBb+Kpn|CZJ|V6^$5oRhkj=fu0y`g8u z6M?e7>HH11{hk?btzWKwI@{=v``yB8C+s;?yMlf{`X+Md1zSyiPKuMf=sBJ9EwMW` zPsuF~+$53UHo0_dxbo4ePkFa4#MK?XU6Te(NX((0E{-7;bLLKu^$-aZX*j>}+Sl~! zVcNxK?~0ZLM(YZ>bX=LBB;>2T>CB2L8>%`cG;zGTs1FTE%-wIRZ(V%u?>@)$cYB{JonT>W-u*+_yl>i;AD$~O ztoBWCjag);!&Mj)`{025#*jI@#_Kvnl^kzvD)bXeSC(6Tl5vSbvQm^_dh+4)`D+wj z&yJj${_p6-#U+i|T29R8++?aWnsVk`I>D^+n7vb>`swmCIfbLgB`q4Yoqm75x#4WJ zhvT|0!hw9p6%9D%@{-e9>f#<4RZd|KR<1pEm@}t4@dHEWV#mhA z3;z5)-CA5^qj2M+s?NNbRR zHgRT>OSx#(&-1P`+e>eKUKACLUSwv(TH?hAUqJN}fv z^kYERG7Y2Pj}H9&-Wg_HK_bmI{OlXn#m<>5AyQ${l73sobE0Es`(Y00+DSTz0Z+7N zPu!)=!P8~)q(mtvYN<#?vk|}hI|Y@sUjNzdEjT2fn>?-5;{TMe)3?r?dEN6yFRHgc z+4s%4l=#on!{*qxYfrwrg-ib9F~R@OqVBJ<@Uio|!}aD|+2fpuJ+H5OY&f{%hS0PJ zSA03RbXxanC1(a+e)W_k;A>oc|0A6pjC&aLE>CA%YH^o?i7{s9`pN6F8Js4h{aw=C z|J&A`Yr(ZYF6{QRPnvo!e74|PmH+S0i+`qhUx;0z+MoHPxXnqwH^YD3uC04~(*qYj z=zEjDE^)I~{O1`KksVShr)QQut$gV9QsMmiNqnc{nzyHZ{PFm_n~SDb_qN;NS6q(j zFNp3rEwgX(w)Z&#^BuIUyXR-y)UY3_`t;gi(&qDg_r+hWkI%BJ2v56HZ@&4w%bwy3 RQouaV;OXk;vd$@?2>|1&xgh`m literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/check_3.png b/examples/clay-official-website/images/check_3.png new file mode 100644 index 0000000000000000000000000000000000000000..fb60187df0b0958a62ac52ac15a568c88431c085 GIT binary patch literal 1508 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I3?%1nZ+ru!7>k44ofvPP)Tsw@I14-?iy0XB zj({-ZRBb+Kpn|CZJ|V6^$%kD=qi9ftz>e!jb$}7mUJ~RN%%GMv|G>>RKmL7xb$#!g zR0SsA6;J=)U*yavIpO((Rzax+pQkc^d0S$7raX~_`^ZN2o$FTiMwqGGIQDK~^@g4q zPXx;Trt>%4_IqZ$wSKw!>1?Av?sp5Xov`On?F#z+=$pu)7i=~8IVn!^qUUtZx5Vz) zJSDd{aFaxW+vL)<;mSv=KIPrI5Lb8jc1;>EAu)$~x;TbZ%$Ykq)&jEP32#V8#5F?>%LMn6gKsl zcx1~WU4f&%+GlwJr{t!UrU0H7VNya4#$x2az>B)!F=dV$C zJv(x0`oE(S7nd|)UNWA;vk>Zi-o*7h~C43w#m4~D5$xBXasf&AHR5^t`Sh@DtVa}ZH#19Oeiya#e zFZlEKbZc>ujlzwOsyg##TG`e$mipEG6PkE(ji!7n=jO+}+8%M&T9)@4uAZeW*v`5$ zSGMPXkav9jkv%WB{x3g2L1Cu#8`m4wE85wo=Q>O{SKT>bL8{Pa8wbz*3iJOnCEAuI zPJ6oW%iIMUe(<0E_2uJ+{oxTt36=eJ`RsQ=Up9-^kT9v9(`UuDO6bM z+QgYjF6E+CKhL|)Y%l5QQ5M?9WBxn1cfHBS4g9@Ff`XcK8@m@c_NIS(s4@A2UDB-G zpQJ-7Z)gdrw4|9O2RvWMu()&Qo~OAlcHJ^qc*^*9sZY;`eLV6P+fIJ+xi9Gb?)X#w z(vJaM%QTFFKRWR9duNz+1&K7<@Uw4N7dvONgh+)&OZsgU&xwwm?T0y}YbWU>20YQ8 zJ#m*d2TzyHlMnE?zW^kI2_IF8l z|8HA&t_9crxUk#LK56Q`@Y#ZERsO#}FaDY4eIa&-5UvW9A zzaYBjw9LNA+ur90%y-bX?w+4*Q^S6!>eFk7Nt@5}-4}ngK0eE?B0TL*z4_+zE_;eE RNCERagQu&X%Q~loCIC36+=2iA literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/check_4.png b/examples/clay-official-website/images/check_4.png new file mode 100644 index 0000000000000000000000000000000000000000..a938f812bc2ae2f66437fc721a4f2a70ad3d08dd GIT binary patch literal 1508 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I3?%1nZ+ru!7>k44ofvPP)Tsw@I14-?iy0XB zj({-ZRBb+Kpn|CZJ|V6^$v5-eM$w=O0X?nX^1z5`FA4GsW>CwTf8geuAOF6;y1sW# zssfYmil_hYFLGv-obdcXtDw|^&r_Mdye%<3Q=Z7eePkp1&UGt$Bg|B89DBF0dPC2Q zCjw=E)A<{2`#m$>TEATVbhgnS_q&DHPS|s(b_M-@^iAZ@3$~j4oD?T{(Q`WITVi)? zo|0P}xJe?xZF1?_aOI;_pYm>9h^sq%yCw~okeEX~T^vIy=FFWQ>md>-(r|v`wXf;d z!?cUf-W4qgjMf!$>9{gMNyt}w)0q`hHdJ*?XySNvRb>&ort&YwjTwrcbzdnO3Y+>& zJhEkxuE0@W?Xx_AQ*zVF)63qSnY-Us-@5qR-+hkh@Af`dI>Ex$y!(f;dEc}xKRj1n zSnZqO8nehwhpR9q_Q3)9jUjV*jn{REDmmWTROly`t}M6wB;yi=WThy<^yI_o^VcZ6 zo*g+g{om1vi%S}_wVasGxye*%H08{>bb?vsF?**%_0#2PatcR}OIkE)JN^EAbHmwc z565+1gai4GD=40rb@3$g5 zE8BBG$UDCN$ex#5|CgVipfJ<=jq45T747WPa~&p}tL~hzAXVtIjf3ZYh57%P5^YNp zr#)TxW$uCvKlo4o`totZ{_qH+gvx%qeN4Msw>tU6UO0OD^RA9ZdNJ7-k3KJ-6e=ur zZQ{%%mvYgnpXXg?wwLtuC<|@lG5;OhyWZsE2L9e7K|xKrjok|zd(*!?)R_FiE@{^8 zPtqZkH?)LQTGGst1D-ErSlqdD&(qu&yKWgQJZ1d5)TigeJ|6jtZ6`nZ+!yqIcl;@T z>BoSsWg14oA07Dly)(?Zf<&5a_}MqCi=8uBLZrf?CH=OF=S0WO_QM>~wUcxb1D9p?EO3n*Me(*T-fbrpEUJe_-w(oD*xY~7ynH2z7V@awLkMoahsEVZ-)Q6U0e6~rUx#5 z(Dx>PUE*e~_|G#eB0Hp1PR}fRTKUlHrNa63llV@@HE&P-_~Y?;Hy2H>?rpcjueco5 zUl84MT4vwmZSQjg<~wLxchAqZsbN1<_35?4q|N8~?u)-#AD?Ac5uSFZ-hA_Ump#Q7 Rq=0#z!PC{xWt~$(69BmP_N)K^ literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/check_5.png b/examples/clay-official-website/images/check_5.png new file mode 100644 index 0000000000000000000000000000000000000000..ea6cfca384eac7dbd5f12d62f63cf7088429bce5 GIT binary patch literal 1508 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I3?%1nZ+ru!7>k44ofvPP)Tsw@I14-?iy0XB zj({-ZRBb+Kpn|CZJ|V6^$q#!|M$w=O0h@9iA7I3^mjw9*GpJ?FKXCKSkAL4^UEez= zRe{NO#nb=y7dbOZPI&&HRZwcd=c&wJ-j5oRhkj=fu0y`g8u z6M?e7>HH11{hk?btzWKwI@{=v``yB8C+s;?yMlf{`X+Md1zSyiPKuMf=sBJ9EwMW` zPsuF~+$53UHo0_dxbo4ePkFa4#MK?XU6Te(NX((0E{-7;bLLKu^$-aZX*j>}+Sl~! zVcNxK?~0ZLM(YZ>bX=LBB;>2T>CB2L8>%`cG;zGTs1FTE%-wIRZ(V%u?>@)$cYB{JonT>W-u*+_yl>i;AD$~O ztoBWCjag);!&Mj)`{025#*jI@#_Kvnl^kzvD)bXeSC(6Tl5vSbvQm^_dh+4)`D+wj z&yJj${_p6-#U+i|T29R8++?aWnsVk`I>D^+n7vb>`swmCIfbLgB`q4Yoqm75x#4WJ zhvT|0!hw9p6%9D%@{-e9>f#<4RZd|KR<1pEm@}t4@dHEWV#mhA z3;z5)-CA5^qj2M+s?NNbRR zHgRT>OSx#(&-1P`+e>eKUKACLUSwv(TH?hAUqJN}fv z^kYERG7Y2Pj}H9&-Wg_HK_bmI{OlXn#m<>5AyQ${l73sobE0Es`(Y00+DSTz0Z+7N zPu!)=!P8~)q(mtvYN<#?vk|}hI|Y@sUjNzdEjT2fn>?-5;{TMe)3?r?dEN6yFRHgc z+4s%4l=#on!{*qxYfrwrg-ib9F~R@OqVBJ<@Uio|!}aD|+2fpuJ+H5OY&f{%hS0PJ zSA03RbXxanC1(a+e)W_k;A>oc|0A6pjC&aLE>CA%YH^o?i7{s9`pN6F8Js4h{aw=C z|J&A`Yr(ZYF6{QRPnvo!e74|PmH+S0i+`qhUx;0z+MoHPxXnqwH^YD3uC04~(*qYj z=zEjDE^)I~{O1`KksVShr)QQut$gV9QsMmiNqnc{nzyHZ{PFm_n~SDb_qN;NS6q(j zFNp3rEwgX(w)Z&#^BuIUyXR-y)UY3_`t;gi(&qDg_r+hWkI%BJ2v56HZ@&4w%bwy3 RQouaV;OXk;vd$@?2>^Vl7xVxC literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/declarative.png b/examples/clay-official-website/images/declarative.png new file mode 100644 index 0000000000000000000000000000000000000000..5cd4abbeb5c75ca2646a803e14a1f8f41dbe6418 GIT binary patch literal 197794 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�s$2qA0kuCk1wUlGz0;U52@?3S9E#&63rDCDD# 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¬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 J9&4Nn`7d4QOU(cP literal 0 HcmV?d00001 diff --git a/examples/clay-official-website/images/renderer.png b/examples/clay-official-website/images/renderer.png new file mode 100644 index 0000000000000000000000000000000000000000..92537c3ef882925cb9627dcbfc1205b0370a277d GIT binary patch literal 317532 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�Z+hZ!^AJPp(^^)+w2T{|z~{(8 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

PxM5*PCXOnX6e)l1gU4| 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%0Djd7*8qe6b+Ea#V(AHYIl!MP-u?VjE;ux^%L)e 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 + + + + + + Clay - UI Layout Library + + + + + + \ No newline at end of file diff --git a/examples/clay-official-website/main.c b/examples/clay-official-website/main.c new file mode 100644 index 0000000..ed959a3 --- /dev/null +++ b/examples/clay-official-website/main.c @@ -0,0 +1,349 @@ +#define CLAY_EXTEND_CONFIG_RECTANGLE Clay_String link; bool cursorPointer; +#define CLAY_EXTEND_CONFIG_IMAGE Clay_String sourceURL; +#define CLAY_EXTEND_CONFIG_TEXT bool disablePointerEvents; +#include "../../clay.h" + +double windowWidth = 1024, windowHeight = 768; +float modelPageOneZRotation = 0; +int ACTIVE_RENDERER_INDEX = 0; + +const uint32_t FONT_ID_TITLE_56 = 0; +const uint32_t FONT_ID_BODY_24 = 1; +const uint32_t FONT_ID_BODY_16 = 2; +const uint32_t FONT_ID_BODY_36 = 3; +const uint32_t FONT_ID_TITLE_36 = 4; +const uint32_t FONT_ID_MONOSPACE_24 = 5; + +const Clay_Color COLOR_LIGHT = (Clay_Color) {244, 235, 230, 255}; +Clay_Color COLOR_LIGHT_HOVER = (Clay_Color) {224, 215, 210, 255}; +Clay_Color COLOR_BUTTON_HOVER = (Clay_Color) {238, 227, 225, 255}; +Clay_Color COLOR_BROWN = (Clay_Color) {61, 26, 5, 255}; +//Clay_Color COLOR_RED = (Clay_Color) {252, 67, 27, 255}; +Clay_Color COLOR_RED = (Clay_Color) {168, 66, 28, 255}; +Clay_Color COLOR_RED_HOVER = (Clay_Color) {148, 46, 8, 255}; +Clay_Color COLOR_ORANGE = (Clay_Color) {225, 138, 50, 255}; +Clay_Color COLOR_BLUE = (Clay_Color) {111, 173, 162, 255}; +Clay_Color COLOR_TEAL = (Clay_Color) {111, 173, 162, 255}; +Clay_Color COLOR_BLUE_DARK = (Clay_Color) {2, 32, 82, 255}; + +// Colors for top stripe +Clay_Color COLOR_TOP_BORDER_1 = (Clay_Color) {168, 66, 28, 255}; +Clay_Color COLOR_TOP_BORDER_2 = (Clay_Color) {223, 110, 44, 255}; +Clay_Color COLOR_TOP_BORDER_3 = (Clay_Color) {225, 138, 50, 255}; +Clay_Color COLOR_TOP_BORDER_4 = (Clay_Color) {236, 189, 80, 255}; +Clay_Color COLOR_TOP_BORDER_5 = (Clay_Color) {240, 213, 137, 255}; + +Clay_Color COLOR_BLOB_BORDER_1 = (Clay_Color) {168, 66, 28, 255}; +Clay_Color COLOR_BLOB_BORDER_2 = (Clay_Color) {203, 100, 44, 255}; +Clay_Color COLOR_BLOB_BORDER_3 = (Clay_Color) {225, 138, 50, 255}; +Clay_Color COLOR_BLOB_BORDER_4 = (Clay_Color) {236, 159, 70, 255}; +Clay_Color COLOR_BLOB_BORDER_5 = (Clay_Color) {240, 189, 100, 255}; + +#define RAYLIB_VECTOR2_TO_CLAY_VECTOR2(vector) (Clay_Vector2) { .x = vector.x, .y = vector.y } + +Clay_TextElementConfig headerTextConfig = (Clay_TextElementConfig) { .fontId = FONT_ID_BODY_24, .fontSize = 24, .textColor = {61, 26, 5, 255} }; +Clay_TextElementConfig blobTextConfig = (Clay_TextElementConfig) { .fontId = FONT_ID_BODY_24, .fontSize = 30, .textColor = COLOR_LIGHT }; + +void LandingPageBlob(int index, int fontSize, Clay_Color color, Clay_String text, Clay_String imageURL) { + CLAY_BORDER_CONTAINER(CLAY_IDI("HeroBlob", index), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 480) }, .padding = {16, 16}, .childGap = 16, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}), CLAY_BORDER_CONFIG_OUTSIDE_RADIUS(2, color, 10), { + CLAY_IMAGE(CLAY_IDI("CheckImage", index), CLAY_LAYOUT(.sizing = { CLAY_SIZING_FIXED(32) }), CLAY_IMAGE_CONFIG(.sourceDimensions = { 128, 128 }, .sourceURL = imageURL), {}); + CLAY_TEXT(CLAY_IDI("HeroBlobText", index), text, CLAY_TEXT_CONFIG(.fontSize = fontSize, .fontId = FONT_ID_BODY_24, .textColor = color)); + }); +} + +void LandingPageDesktop() { + CLAY_CONTAINER(CLAY_ID("LandingPage1Desktop"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIT(.min = windowHeight - 70) }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = { .x = 50 }), { + CLAY_BORDER_CONTAINER(CLAY_ID("LandingPage1"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = { 32, 32 }, .childGap = 32), CLAY_BORDER_CONFIG(.left = { 2, COLOR_RED }, .right = { 2, COLOR_RED }), { + CLAY_CONTAINER(CLAY_ID("LeftText"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_PERCENT(0.55f) }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("LeftTextTitle"), CLAY_STRING("Clay is a flex-box style UI auto layout library in C, with declarative syntax and microsecond performance."), CLAY_TEXT_CONFIG(.fontSize = 56, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(32) }), {}); + CLAY_TEXT(CLAY_ID("LeftTextTagline"), CLAY_STRING("Clay is laying out this webpage right now!"), CLAY_TEXT_CONFIG(.fontSize = 36, .fontId = FONT_ID_TITLE_36, .textColor = COLOR_ORANGE)); + }); + CLAY_CONTAINER(CLAY_ID("HeroImageOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_PERCENT(0.45f) }, .childAlignment = { CLAY_ALIGN_X_CENTER }, .childGap = 16), { + LandingPageBlob(1, 32, COLOR_BLOB_BORDER_5, CLAY_STRING("High performance"), CLAY_STRING("/clay/images/check_5.png")); + LandingPageBlob(2, 32, COLOR_BLOB_BORDER_4, CLAY_STRING("Flexbox-style responsive layout"), CLAY_STRING("/clay/images/check_4.png")); + LandingPageBlob(3, 32, COLOR_BLOB_BORDER_3, CLAY_STRING("Declarative syntax"), CLAY_STRING("/clay/images/check_3.png")); + LandingPageBlob(4, 32, COLOR_BLOB_BORDER_2, CLAY_STRING("Single .h file for C/C++"), CLAY_STRING("/clay/images/check_2.png")); + LandingPageBlob(5, 32, COLOR_BLOB_BORDER_1, CLAY_STRING("Compile to 15kb .wasm"), CLAY_STRING("/clay/images/check_1.png")); + }); + }); + }); +} + +void LandingPageMobile() { + CLAY_CONTAINER(CLAY_ID("LandingPage1Mobile"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIT(.min = windowHeight - 70) }, .childAlignment = {CLAY_ALIGN_X_CENTER, .y = CLAY_ALIGN_Y_CENTER}, .padding = { 16, 32 }, .childGap = 32), { + CLAY_CONTAINER(CLAY_ID("LeftText"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("LeftTextTitle"), CLAY_STRING("Clay is a flex-box style UI auto layout library in C, with declarative syntax and microsecond performance."), CLAY_TEXT_CONFIG(.fontSize = 48, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(32) }), {}); + CLAY_TEXT(CLAY_ID("LeftTextTagline"), CLAY_STRING("Clay is laying out this webpage right now!"), CLAY_TEXT_CONFIG(.fontSize = 32, .fontId = FONT_ID_TITLE_36, .textColor = COLOR_ORANGE)); + }); + CLAY_CONTAINER(CLAY_ID("HeroImageOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_GROW() }, .childAlignment = { CLAY_ALIGN_X_CENTER }, .childGap = 16), { + LandingPageBlob(1, 28, COLOR_BLOB_BORDER_5, CLAY_STRING("High performance"), CLAY_STRING("/clay/images/check_5.png")); + LandingPageBlob(2, 28, COLOR_BLOB_BORDER_4, CLAY_STRING("Flexbox-style responsive layout"), CLAY_STRING("/clay/images/check_4.png")); + LandingPageBlob(3, 28, COLOR_BLOB_BORDER_3, CLAY_STRING("Declarative syntax"), CLAY_STRING("/clay/images/check_3.png")); + LandingPageBlob(4, 28, COLOR_BLOB_BORDER_2, CLAY_STRING("Single .h file for C/C++"), CLAY_STRING("/clay/images/check_2.png")); + LandingPageBlob(5, 28, COLOR_BLOB_BORDER_1, CLAY_STRING("Compile to 15kb .wasm"), CLAY_STRING("/clay/images/check_1.png")); + }); + }); +} + +void FeatureBlocksDesktop() { + CLAY_CONTAINER(CLAY_ID("FeatureBlocksOuter"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }), { + CLAY_BORDER_CONTAINER(CLAY_ID("FeatureBlocksInner"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .childAlignment = { .y = CLAY_ALIGN_Y_CENTER } ), CLAY_BORDER_CONFIG(.betweenChildren = { .width = 2, .color = COLOR_RED }), { + Clay_TextElementConfig *textConfig = CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_BODY_24, .textColor = COLOR_RED ); + CLAY_CONTAINER(CLAY_ID("HFileBoxOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_PERCENT(0.5f) }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {50, 32}, .childGap = 8), { + CLAY_RECTANGLE(CLAY_ID("HFileIncludeOuter"), CLAY_LAYOUT(.padding = {8, 4}), CLAY_RECTANGLE_CONFIG(.color = COLOR_RED, .cornerRadius = CLAY_CORNER_RADIUS(8)), { + CLAY_TEXT(CLAY_IDI("HFileBoxText", 2), CLAY_STRING("#include clay.h"), CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_BODY_24, .textColor = COLOR_LIGHT)); + }); + CLAY_TEXT(CLAY_ID("HFileSecondLine"), CLAY_STRING("~2000 lines of C99."), textConfig); + CLAY_TEXT(CLAY_IDI("HFileBoxText", 5), CLAY_STRING("Zero dependencies, including no C standard library."), textConfig); + }); + CLAY_CONTAINER(CLAY_ID("BringYourOwnRendererOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_PERCENT(0.5f) }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 50, .y = 32}, .childGap = 8), { + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 1), CLAY_STRING("Renderer agnostic."), CLAY_TEXT_CONFIG(.fontId = FONT_ID_BODY_24, .fontSize = 24, .textColor = COLOR_ORANGE)); + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 2), CLAY_STRING("Layout with clay, then render with Raylib, WebGL Canvas or even as HTML."), textConfig); + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 3), CLAY_STRING("Flexible output for easy compositing in your custom engine or environment."), textConfig); + }); + }); + }); +} + +void FeatureBlocksMobile() { + CLAY_BORDER_CONTAINER(CLAY_ID("FeatureBlocksInner"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW() }, ), CLAY_BORDER_CONFIG(.betweenChildren = { .width = 2, .color = COLOR_RED }), { + Clay_TextElementConfig *textConfig = CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_BODY_24, .textColor = COLOR_RED ); + CLAY_CONTAINER(CLAY_ID("HFileBoxOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW() }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {16, 32}, .childGap = 8), { + CLAY_RECTANGLE(CLAY_ID("HFileIncludeOuter"), CLAY_LAYOUT(.padding = {8, 4}), CLAY_RECTANGLE_CONFIG(.color = COLOR_RED, .cornerRadius = CLAY_CORNER_RADIUS(8)), { + CLAY_TEXT(CLAY_IDI("HFileBoxText", 2), CLAY_STRING("#include clay.h"), CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_BODY_24, .textColor = COLOR_LIGHT)); + }); + CLAY_TEXT(CLAY_ID("HFileSecondLine"), CLAY_STRING("~2000 lines of C99."), textConfig); + CLAY_TEXT(CLAY_IDI("HFileBoxText", 5), CLAY_STRING("Zero dependencies, including no C standard library."), textConfig); + }); + CLAY_CONTAINER(CLAY_ID("BringYourOwnRendererOuter"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW() }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 16, .y = 32}, .childGap = 8), { + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 1), CLAY_STRING("Renderer agnostic."), CLAY_TEXT_CONFIG(.fontId = FONT_ID_BODY_24, .fontSize = 24, .textColor = COLOR_ORANGE)); + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 2), CLAY_STRING("Layout with clay, then render with Raylib, WebGL Canvas or even as HTML."), textConfig); + CLAY_TEXT(CLAY_IDI("ZeroDependenciesText", 3), CLAY_STRING("Flexible output for easy compositing in your custom engine or environment."), textConfig); + }); + }); +} + +void DeclarativeSyntaxPageDesktop() { + CLAY_CONTAINER(CLAY_ID("SyntaxPageDesktop"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 50}), { + CLAY_BORDER_CONTAINER(CLAY_ID("SyntaxPage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }, .childAlignment = { 0, CLAY_ALIGN_Y_CENTER }, .padding = { 32, 32 }, .childGap = 32), CLAY_BORDER_CONFIG(.left = { 2, COLOR_RED }, .right = { 2, COLOR_RED }), { + CLAY_CONTAINER(CLAY_ID("SyntaxPageLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.5) }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("SyntaxPageTextTitle"), CLAY_STRING("Declarative Syntax"), CLAY_TEXT_CONFIG(.fontSize = 52, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("SyntaxSpacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle1"), CLAY_STRING("Flexible and readable declarative syntax with nested UI element hierarchies."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle2"), CLAY_STRING("Mix elements with standard C code like loops, conditionals and functions."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle3"), CLAY_STRING("Create your own library of re-usable components from UI primitives like text, images and rectangles."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + }); + CLAY_CONTAINER(CLAY_ID("SyntaxPageRightImage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.50) }, .childAlignment = {.x = CLAY_ALIGN_X_CENTER}), { + CLAY_IMAGE(CLAY_ID("SyntaxPageRightImage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 568) }), CLAY_IMAGE_CONFIG(.sourceDimensions = {1136, 1194}, .sourceURL = CLAY_STRING("/clay/images/declarative.png")), {}); + }); + }); + }); +} + +void DeclarativeSyntaxPageMobile() { + CLAY_CONTAINER(CLAY_ID("SyntaxPageDesktop"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER}, .padding = {16, 32}, .childGap = 16), { + CLAY_CONTAINER(CLAY_ID("SyntaxPageLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("SyntaxPageTextTitle"), CLAY_STRING("Declarative Syntax"), CLAY_TEXT_CONFIG(.fontSize = 48, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("SyntaxSpacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle1"), CLAY_STRING("Flexible and readable declarative syntax with nested UI element hierarchies."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle2"), CLAY_STRING("Mix elements with standard C code like loops, conditionals and functions."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_ID("SyntaxPageTextSubTitle3"), CLAY_STRING("Create your own library of re-usable components from UI primitives like text, images and rectangles."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + }); + CLAY_CONTAINER(CLAY_ID("SyntaxPageRightImage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .childAlignment = {.x = CLAY_ALIGN_X_CENTER}), { + CLAY_IMAGE(CLAY_ID("SyntaxPageRightImage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 568) }), CLAY_IMAGE_CONFIG(.sourceDimensions = {1136, 1194}, .sourceURL = CLAY_STRING("/clay/images/declarative.png")), {}); + }); + }); +} + +Clay_Color ColorLerp(Clay_Color a, Clay_Color b, float amount) { + return (Clay_Color) { + .r = a.r + (b.r - a.r) * amount, + .g = a.g + (b.g - a.g) * amount, + .b = a.b + (b.b - a.b) * amount, + .a = a.a + (b.a - a.a) * amount, + }; +} + +Clay_String LOREM_IPSUM_TEXT = CLAY_STRING("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."); + +void HighPerformancePageDesktop(float lerpValue) { + CLAY_RECTANGLE(CLAY_ID("PerformanceDesktop"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 82, 32}, .childGap = 64), CLAY_RECTANGLE_CONFIG(.color = COLOR_RED), { + CLAY_CONTAINER(CLAY_ID("PerformanceLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.5) }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("PerformanceTextTitle"), CLAY_STRING("High Performance"), CLAY_TEXT_CONFIG(.fontSize = 52, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + CLAY_CONTAINER(CLAY_ID("SyntaxSpacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 1), CLAY_STRING("Fast enough to recompute your entire UI every frame."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 2), CLAY_STRING("Small memory footprint (3.5mb default) with static allocation & reuse. No malloc / free."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 3), CLAY_STRING("Simplify animations and reactive UI design by avoiding the standard performance hacks."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + }); + CLAY_CONTAINER(CLAY_ID("PerformanceRightImageOuter"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.50) }, .childAlignment = {CLAY_ALIGN_X_CENTER}), { + CLAY_BORDER_CONTAINER(CLAY_ID(""), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(400) }), CLAY_BORDER_CONFIG_ALL(.width = 2, .color = COLOR_LIGHT), { + CLAY_RECTANGLE(CLAY_ID("AnimationDemoContainerLeft"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.3f + 0.4f * lerpValue), CLAY_SIZING_GROW() }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = {32, 32}), CLAY_RECTANGLE_CONFIG(.color = ColorLerp(COLOR_RED, COLOR_ORANGE, lerpValue)), { + CLAY_TEXT(CLAY_ID("AnimationDemoTextLeft"), LOREM_IPSUM_TEXT, CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + }); + CLAY_RECTANGLE(CLAY_ID("AnimationDemoContainerRight"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = {32, 32}), CLAY_RECTANGLE_CONFIG(.color = ColorLerp(COLOR_ORANGE, COLOR_RED, lerpValue)), { + CLAY_TEXT(CLAY_ID("AnimationDemoTextRight"), LOREM_IPSUM_TEXT, CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + }); + }); + }); + }); +} + +void HighPerformancePageMobile(float lerpValue) { + CLAY_RECTANGLE(CLAY_ID("PerformanceMobile"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 16, 32}, .childGap = 32), CLAY_RECTANGLE_CONFIG(.color = COLOR_RED), { + CLAY_CONTAINER(CLAY_ID("PerformanceLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("PerformanceTextTitle"), CLAY_STRING("High Performance"), CLAY_TEXT_CONFIG(.fontSize = 48, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + CLAY_CONTAINER(CLAY_ID("SyntaxSpacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 1), CLAY_STRING("Fast enough to recompute your entire UI every frame."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 2), CLAY_STRING("Small memory footprint (3.5mb default) with static allocation & reuse. No malloc / free."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + CLAY_TEXT(CLAY_IDI("PerformanceTextSubTitle", 3), CLAY_STRING("Simplify animations and reactive UI design by avoiding the standard performance hacks."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + }); + CLAY_CONTAINER(CLAY_ID("PerformanceRightImageOuter"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .childAlignment = {CLAY_ALIGN_X_CENTER}), { + CLAY_BORDER_CONTAINER(CLAY_ID(""), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(400) }), CLAY_BORDER_CONFIG_ALL(.width = 2, .color = COLOR_LIGHT), { + CLAY_RECTANGLE(CLAY_ID("AnimationDemoContainerLeft"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.35f + 0.3f * lerpValue), CLAY_SIZING_GROW() }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = ColorLerp(COLOR_RED, COLOR_ORANGE, lerpValue)), { + CLAY_TEXT(CLAY_ID("AnimationDemoTextLeft"), LOREM_IPSUM_TEXT, CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + }); + CLAY_RECTANGLE(CLAY_ID("AnimationDemoContainerRight"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }, .childAlignment = {.y = CLAY_ALIGN_Y_CENTER}, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = ColorLerp(COLOR_ORANGE, COLOR_RED, lerpValue)), { + CLAY_TEXT(CLAY_ID("AnimationDemoTextRight"), LOREM_IPSUM_TEXT, CLAY_TEXT_CONFIG(.fontSize = 24, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_LIGHT)); + }); + }); + }); + }); +} + +void RendererButtonActive(uint32_t id, int index, Clay_String text) { + CLAY_RECTANGLE(id, CLAY_LAYOUT(.sizing = {CLAY_SIZING_FIXED(300) }, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = Clay_PointerOver(id) ? COLOR_RED_HOVER : COLOR_RED, .cornerRadius = CLAY_CORNER_RADIUS(10)), { + CLAY_TEXT(CLAY_ID("RendererButtonActiveText"), text, CLAY_TEXT_CONFIG(.disablePointerEvents = true, .fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_LIGHT)); + }); +} + +void RendererButtonInactive(uint32_t id, int index, Clay_String text) { + CLAY_BORDER_CONTAINER(id, CLAY_LAYOUT(), CLAY_BORDER_CONFIG_OUTSIDE_RADIUS(2, COLOR_RED, 10), { + CLAY_RECTANGLE(CLAY_IDI("RendererButtonInactiveInner", index), CLAY_LAYOUT(.sizing = {CLAY_SIZING_FIXED(300) }, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = Clay_PointerOver(id) ? COLOR_LIGHT_HOVER : COLOR_LIGHT, .cornerRadius = CLAY_CORNER_RADIUS(10), .cursorPointer = true), { + CLAY_TEXT(CLAY_IDI("RendererButtonInactiveText", index), text, CLAY_TEXT_CONFIG(.disablePointerEvents = true, .fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + }); + }); +} + +void RendererPageDesktop() { + CLAY_CONTAINER(CLAY_ID("RendererPageDesktop"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {0, CLAY_ALIGN_Y_CENTER}, .padding = {.x = 50}), { + CLAY_BORDER_CONTAINER(CLAY_ID("RendererPage"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }, .childAlignment = { 0, CLAY_ALIGN_Y_CENTER }, .padding = { 32, 32 }, .childGap = 32), CLAY_BORDER_CONFIG(.left = { 2, COLOR_RED }, .right = { 2, COLOR_RED }), { + CLAY_CONTAINER(CLAY_ID("RendererLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.5) }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("RendererTextTitle"), CLAY_STRING("Renderer & Platform Agnostic"), CLAY_TEXT_CONFIG(.fontSize = 52, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 1), CLAY_STRING("Clay outputs a sorted array of primitive render commands, such as RECTANGLE, TEXT or IMAGE."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 2), CLAY_STRING("Write your own renderer in a few hundred lines of code, or use the provided examples for Raylib, WebGL canvas and more."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 3), CLAY_STRING("There's even an HTML renderer - you're looking at it right now!"), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + }); + CLAY_CONTAINER(CLAY_ID("RendererRightText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_PERCENT(0.5) }, .childAlignment = {CLAY_ALIGN_X_CENTER}, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 16), { + CLAY_TEXT(CLAY_ID("RendererTextRightTitle"), CLAY_STRING("Try changing renderer!"), CLAY_TEXT_CONFIG(.fontSize = 36, .fontId = FONT_ID_BODY_36, .textColor = COLOR_ORANGE)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 32) }), {}); + if (ACTIVE_RENDERER_INDEX == 0) { + RendererButtonActive(CLAY_IDI("RendererSelectButtonActive", 0), 0, CLAY_STRING("HTML Renderer")); + RendererButtonInactive(CLAY_ID("RendererSelectButtonCanvas"), 1, CLAY_STRING("Canvas Renderer")); + } else { + RendererButtonInactive(CLAY_ID("RendererSelectButtonHTML"), 0, CLAY_STRING("HTML Renderer")); + RendererButtonActive(CLAY_IDI("RendererSelectButtonActive", 0), 1, CLAY_STRING("Canvas Renderer")); + } + }); + }); + }); +} + +void RendererPageMobile() { + CLAY_RECTANGLE(CLAY_ID("RendererMobile"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIT(.min = windowHeight - 50) }, .childAlignment = {.x = CLAY_ALIGN_X_CENTER, .y = CLAY_ALIGN_Y_CENTER}, .padding = {.x = 16, 32}, .childGap = 32), CLAY_RECTANGLE_CONFIG(.color = COLOR_LIGHT), { + CLAY_CONTAINER(CLAY_ID("RendererLeftText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 8), { + CLAY_TEXT(CLAY_ID("RendererTextTitle"), CLAY_STRING("Renderer & Platform Agnostic"), CLAY_TEXT_CONFIG(.fontSize = 48, .fontId = FONT_ID_TITLE_56, .textColor = COLOR_RED)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 16) }), {}); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 1), CLAY_STRING("Clay outputs a sorted array of primitive render commands, such as RECTANGLE, TEXT or IMAGE."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 2), CLAY_STRING("Write your own renderer in a few hundred lines of code, or use the provided examples for Raylib, WebGL canvas and more."), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + CLAY_TEXT(CLAY_IDI("RendererTextSubTitle", 3), CLAY_STRING("There's even an HTML renderer - you're looking at it right now!"), CLAY_TEXT_CONFIG(.fontSize = 28, .fontId = FONT_ID_BODY_36, .textColor = COLOR_RED)); + }); + CLAY_CONTAINER(CLAY_ID("RendererRightText"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW() }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .childGap = 16), { + CLAY_TEXT(CLAY_ID("RendererTextRightTitle"), CLAY_STRING("Try changing renderer!"), CLAY_TEXT_CONFIG(.fontSize = 36, .fontId = FONT_ID_BODY_36, .textColor = COLOR_ORANGE)); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(.max = 32) }), {}); + if (ACTIVE_RENDERER_INDEX == 0) { + RendererButtonActive(CLAY_IDI("RendererSelectButtonActive", 0), 0, CLAY_STRING("HTML Renderer")); + RendererButtonInactive(CLAY_ID("RendererSelectButtonCanvas"), 1, CLAY_STRING("Canvas Renderer")); + } else { + RendererButtonInactive(CLAY_ID("RendererSelectButtonHTML"), 0, CLAY_STRING("HTML Renderer")); + RendererButtonActive(CLAY_IDI("RendererSelectButtonActive", 0), 1, CLAY_STRING("Canvas Renderer")); + } + }); + }); +} + +Clay_RenderCommandArray CreateLayout(float lerpValue) { + bool mobileScreen = windowWidth < 750; + Clay_BeginLayout((int)windowWidth, (int)windowHeight); + CLAY_RECTANGLE(CLAY_ID("OuterContainer"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }), CLAY_RECTANGLE_CONFIG(.color = COLOR_LIGHT), { + CLAY_CONTAINER(CLAY_ID("Header"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(50) }, .childAlignment = { 0, CLAY_ALIGN_Y_CENTER }, .childGap = 24, .padding = { 32 }), { + CLAY_TEXT(CLAY_ID("Logo"), CLAY_STRING("Clay"), &headerTextConfig); + CLAY_CONTAINER(CLAY_ID("Spacer"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }), {}); + + if (!mobileScreen) { + CLAY_TEXT(CLAY_ID("LinkFeatures"), CLAY_STRING("Features"), &headerTextConfig); + CLAY_TEXT(CLAY_ID("LinkDocs"), CLAY_STRING("Docs"), &headerTextConfig); + } + uint32_t githubButtonId = CLAY_ID("HeaderButtonGithub"); + CLAY_BORDER_CONTAINER(CLAY_ID("LinkGithubOuter"), CLAY_LAYOUT(), CLAY_BORDER_CONFIG_OUTSIDE_RADIUS(2, COLOR_RED, 10), { + CLAY_RECTANGLE(githubButtonId, CLAY_LAYOUT(.padding = {16, 6}), CLAY_RECTANGLE_CONFIG(.cornerRadius = CLAY_CORNER_RADIUS(10), .link = CLAY_STRING("https://github.com/nicbarker/clay"), .color = Clay_PointerOver(githubButtonId) ? COLOR_LIGHT_HOVER : COLOR_LIGHT), { + CLAY_TEXT(CLAY_ID("LinkGithubText"), CLAY_STRING("Github"), CLAY_TEXT_CONFIG(.disablePointerEvents = true, .fontId = FONT_ID_BODY_24, .fontSize = 24, .textColor = {61, 26, 5, 255})); + }); + }); + }); + CLAY_RECTANGLE(CLAY_ID("TopBorder1"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(4) }), CLAY_RECTANGLE_CONFIG(.color = COLOR_TOP_BORDER_5), {}); + CLAY_RECTANGLE(CLAY_ID("TopBorder2"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(4) }), CLAY_RECTANGLE_CONFIG(.color = COLOR_TOP_BORDER_4), {}); + CLAY_RECTANGLE(CLAY_ID("TopBorder3"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(4) }), CLAY_RECTANGLE_CONFIG(.color = COLOR_TOP_BORDER_3), {}); + CLAY_RECTANGLE(CLAY_ID("TopBorder4"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(4) }), CLAY_RECTANGLE_CONFIG(.color = COLOR_TOP_BORDER_2), {}); + CLAY_RECTANGLE(CLAY_ID("TopBorder5"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_FIXED(4) }), CLAY_RECTANGLE_CONFIG(.color = COLOR_TOP_BORDER_1), {}); + CLAY_RECTANGLE(CLAY_ID("ScrollContainerBackgroundRectangle"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }), CLAY_RECTANGLE_CONFIG(.color = COLOR_LIGHT), { + CLAY_SCROLL_CONTAINER(CLAY_ID("OuterScrollContainer"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }), CLAY_SCROLL_CONFIG(.vertical = true), { + CLAY_BORDER_CONTAINER(CLAY_ID("ScrollContainerInner"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { CLAY_SIZING_GROW() }), CLAY_BORDER_CONFIG(.betweenChildren = {2, COLOR_RED}), { + if (mobileScreen) { + LandingPageMobile(); + FeatureBlocksMobile(); + DeclarativeSyntaxPageMobile(); + HighPerformancePageMobile(lerpValue); + RendererPageMobile(); + } else { + LandingPageDesktop(); + FeatureBlocksDesktop(); + DeclarativeSyntaxPageDesktop(); + HighPerformancePageDesktop(lerpValue); + RendererPageDesktop(); + } + }); + }); + }); + }); + return Clay_EndLayout((int)windowWidth, (int)windowHeight); +} + +float animationLerpValue = -1.0f; + +CLAY_WASM_EXPORT("UpdateDrawFrame") Clay_RenderCommandArray UpdateDrawFrame(float width, float height, float mouseWheelX, float mouseWheelY, float mousePositionX, float mousePositionY, bool isTouchDown, bool isMouseDown, float deltaTime) { + windowWidth = width; + windowHeight = height; + if (deltaTime == deltaTime) { // NaN propagation can cause pain here + animationLerpValue += deltaTime; + if (animationLerpValue > 1) { + animationLerpValue -= 2; + } + } + + if (isTouchDown || isMouseDown) { + if (Clay_PointerOver(CLAY_ID("RendererSelectButtonHTML"))) { + ACTIVE_RENDERER_INDEX = 0; + } else if (Clay_PointerOver(CLAY_ID("RendererSelectButtonCanvas"))) { + ACTIVE_RENDERER_INDEX = 1; + } + } + //---------------------------------------------------------------------------------- + // Handle scroll containers + Clay_SetPointerPosition((Clay_Vector2) {mousePositionX, mousePositionY}); + Clay_UpdateScrollContainers(isTouchDown, (Clay_Vector2) {mouseWheelX, mouseWheelY}, deltaTime); + return CreateLayout(animationLerpValue < 0 ? (animationLerpValue + 1) : (1 - animationLerpValue)); + //---------------------------------------------------------------------------------- +} \ No newline at end of file diff --git a/examples/raylib-sidebar-scrolling-container/CMakeLists.txt b/examples/raylib-sidebar-scrolling-container/CMakeLists.txt new file mode 100644 index 0000000..1a6e2ee --- /dev/null +++ b/examples/raylib-sidebar-scrolling-container/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.28) +project(clay_examples_raylib_sidebar_scrolling_container C) + +# Adding Raylib +include(FetchContent) +set(FETCHCONTENT_QUIET FALSE) +set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) # don't build the supplied examples +set(BUILD_GAMES OFF CACHE BOOL "" FORCE) # don't build the supplied example games + +FetchContent_Declare( + raylib + GIT_REPOSITORY "https://github.com/raysan5/raylib.git" + GIT_TAG "master" + GIT_PROGRESS TRUE +) + +FetchContent_MakeAvailable(raylib) + +set(CMAKE_C_STANDARD 99) + +add_executable(clay_examples_raylib_sidebar_scrolling_container main.c) + +target_compile_options(clay_examples_raylib_sidebar_scrolling_container PUBLIC -DCLAY_OVERFLOW_TRAP -Wno-initializer-overrides) +target_include_directories(clay_examples_raylib_sidebar_scrolling_container PUBLIC .) + +target_link_libraries(clay_examples_raylib_sidebar_scrolling_container PUBLIC raylib) +set(CMAKE_CXX_FLAGS_RELEASE "-O3") + +add_custom_command( + TARGET clay_examples_raylib_sidebar_scrolling_container POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/resources + ${CMAKE_CURRENT_BINARY_DIR}/resources) \ No newline at end of file diff --git a/examples/raylib-sidebar-scrolling-container/main.c b/examples/raylib-sidebar-scrolling-container/main.c new file mode 100644 index 0000000..9ac1349 --- /dev/null +++ b/examples/raylib-sidebar-scrolling-container/main.c @@ -0,0 +1,168 @@ +#include "../../clay.h" +#include "../../renderers/raylib/clay_renderer_raylib.c" + +double windowWidth = 1024, windowHeight = 768; + +const uint32_t FONT_ID_BODY_24 = 0; +const uint32_t FONT_ID_BODY_16 = 1; +Clay_Color COLOR_ORANGE = (Clay_Color) {225, 138, 50, 255}; +Clay_Color COLOR_BLUE = (Clay_Color) {111, 173, 162, 255}; + +Texture2D profilePicture; +#define RAYLIB_VECTOR2_TO_CLAY_VECTOR2(vector) (Clay_Vector2) { .x = vector.x, .y = vector.y } + +Clay_String profileText = CLAY_STRING("Profile Page one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen"); +Clay_TextElementConfig headerTextConfig = (Clay_TextElementConfig) { .fontId = FONT_ID_BODY_16, .fontSize = 16, .textColor = {0,0,0,255} }; + +// Examples of re-usable "Components" +void RenderHeaderButton(uint16_t index, Clay_String text) { + uint32_t buttonId = CLAY_IDI("HeaderButton", index); + CLAY_RECTANGLE(buttonId, CLAY_LAYOUT(.padding = {16, 8}), CLAY_RECTANGLE_CONFIG(.color = Clay_PointerOver(buttonId) ? COLOR_BLUE : COLOR_ORANGE), { + CLAY_TEXT(CLAY_IDI("Button", index), text, &headerTextConfig); + }); +} + +Clay_LayoutConfig dropdownTextItemLayout = (Clay_LayoutConfig) { .padding = {8, 4} }; +Clay_RectangleElementConfig dropdownRectangleConfig = (Clay_RectangleElementConfig) { .color = {180, 180, 180, 255} }; +Clay_TextElementConfig dropdownTextElementConfig = (Clay_TextElementConfig) { .fontSize = 24, .textColor = {255,255,255,255} }; + +void RenderDropdownTextItem() { + CLAY_RECTANGLE(CLAY_ID("ScrollContainerItem"), &dropdownTextItemLayout, &dropdownRectangleConfig, { // We can save a lot of memory by re-using configs in loops rather than redefining them + CLAY_TEXT(CLAY_ID("ScrollContainerText"), CLAY_STRING("I'm a text field in a scroll container."), &dropdownTextElementConfig); + }); +} + +Clay_RenderCommandArray CreateLayout() { + Clay_BeginLayout((int)windowWidth, (int)windowHeight); + CLAY_RECTANGLE(CLAY_ID("OuterContainer"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_GROW() }, .padding = { 16, 16 }, .childGap = 16), CLAY_RECTANGLE_CONFIG(.color = {200, 200, 200, 255}), { + CLAY_RECTANGLE(CLAY_ID("SideBar"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_GROW() }, .padding = {16, 16}, .childGap = 16), CLAY_RECTANGLE_CONFIG(.color = {150, 150, 255, 255}), { + CLAY_RECTANGLE(CLAY_ID("ProfilePictureOuter"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }, .padding = { 8, 8 }, .childGap = 8, .childAlignment = { .y = CLAY_ALIGN_Y_CENTER }), CLAY_RECTANGLE_CONFIG(.color = {130, 130, 255, 255}), { + CLAY_IMAGE(CLAY_ID("ProfilePicture"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(60), .height = CLAY_SIZING_FIXED(60) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {60, 60}), {}); + CLAY_TEXT(CLAY_ID("ProfileTitle"), profileText, CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {0, 0, 0, 255})); + }); + CLAY_RECTANGLE(CLAY_ID("SidebarBlob1"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(50) }), CLAY_RECTANGLE_CONFIG(.color = {110, 110, 255, 255}), {}); + CLAY_RECTANGLE(CLAY_ID("SidebarBlob2"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(50) }), CLAY_RECTANGLE_CONFIG(.color = {110, 110, 255, 255}), {}); + CLAY_RECTANGLE(CLAY_ID("SidebarBlob3"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(50) }), CLAY_RECTANGLE_CONFIG(.color = {110, 110, 255, 255}), {}); + CLAY_RECTANGLE(CLAY_ID("SidebarBlob4"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_FIXED(50) }), CLAY_RECTANGLE_CONFIG(.color = {110, 110, 255, 255}), {}); + }); +// + CLAY_CONTAINER(CLAY_ID("RightPanel"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .sizing = { .width = CLAY_SIZING_GROW() }, .childGap = 16), { + CLAY_RECTANGLE(CLAY_ID("HeaderBar"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }, .childAlignment = { .x = CLAY_ALIGN_X_RIGHT }, .padding = {8, 8}, .childGap = 8), CLAY_RECTANGLE_CONFIG(.color = {180, 180, 180, 255}), { + RenderHeaderButton(1, CLAY_STRING("Header Item 1")); + RenderHeaderButton(2, CLAY_STRING("Header Item 2")); + RenderHeaderButton(3, CLAY_STRING("Header Item 3")); + }); + CLAY_SCROLL_CONTAINER(CLAY_ID("MainContent"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW(), .height = CLAY_SIZING_GROW() }), CLAY_SCROLL_CONFIG(.vertical = true), { + CLAY_RECTANGLE(CLAY_ID("MainContentInner"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM, .padding = {16, 16}, .childGap = 16), CLAY_RECTANGLE_CONFIG(.color = {200, 200, 255, 255}), { + CLAY_FLOATING_CONTAINER(CLAY_ID("FloatingContainer"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_FIXED(300) }, .padding = {16, 16}), CLAY_FLOATING_CONFIG(.zIndex = 1, .attachment = { CLAY_ATTACH_POINT_CENTER_TOP, CLAY_ATTACH_POINT_CENTER_TOP }, .offset = {0, -16}), { + CLAY_RECTANGLE(CLAY_ID("FloatingContainerBackground"), CLAY_LAYOUT(.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() }), CLAY_RECTANGLE_CONFIG(.color = {140,80, 200, 200}), { + CLAY_TEXT(CLAY_ID("FloatingContainerText"), CLAY_STRING("I'm an inline floating container."), CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {255,255,255,255})); + }); + }); + + CLAY_TEXT(CLAY_ID("BodyText1"), + CLAY_STRING("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt."), + CLAY_TEXT_CONFIG(.fontId = FONT_ID_BODY_24, .fontSize = 24, .textColor = {0,0,0,255})); + + CLAY_RECTANGLE(CLAY_ID("Photos"), CLAY_LAYOUT(.childGap = 16, .padding = { 16, 16 }), CLAY_RECTANGLE_CONFIG(.color = {180, 180, 220, 255}), { + CLAY_IMAGE(CLAY_ID("Picture1"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(120), .height = CLAY_SIZING_FIXED(120) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {120, 120}), {}); + CLAY_IMAGE(CLAY_ID("Picture2"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(120), .height = CLAY_SIZING_FIXED(120) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {120, 120}), {}); + CLAY_IMAGE(CLAY_ID("Picture3"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(120), .height = CLAY_SIZING_FIXED(120) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {120, 120}), {}); + }); + + CLAY_TEXT(CLAY_ID("BodyText2"), + CLAY_STRING("Faucibus purus in massa tempor nec. Nec ullamcorper sit amet risus nullam eget felis eget nunc. Diam vulputate ut pharetra sit amet aliquam id diam. Lacus suspendisse faucibus interdum posuere lorem. A diam sollicitudin tempor id. Amet massa vitae tortor condimentum lacinia. Aliquet nibh praesent tristique magna."), + CLAY_TEXT_CONFIG(.fontSize = 24, .lineSpacing = 20, .textColor = {0,0,0,255})); + + CLAY_TEXT(CLAY_ID("BodyText3"), + CLAY_STRING("Suspendisse in est ante in nibh. Amet venenatis urna cursus eget nunc scelerisque viverra. Elementum sagittis vitae et leo duis ut diam quam nulla. Enim nulla aliquet porttitor lacus. Pellentesque habitant morbi tristique senectus et. Facilisi nullam vehicula ipsum a arcu cursus vitae.\nSem fringilla ut morbi tincidunt. Euismod quis viverra nibh cras pulvinar mattis nunc sed. Velit sed ullamcorper morbi tincidunt ornare massa. Varius quam quisque id diam vel quam. Nulla pellentesque dignissim enim sit amet venenatis. Enim lobortis scelerisque fermentum dui faucibus in. Pretium viverra suspendisse potenti nullam ac tortor vitae. Lectus vestibulum mattis ullamcorper velit sed. Eget mauris pharetra et ultrices neque ornare aenean euismod elementum. Habitant morbi tristique senectus et. Integer vitae justo eget magna fermentum iaculis eu. Semper quis lectus nulla at volutpat diam. Enim praesent elementum facilisis leo. Massa vitae tortor condimentum lacinia quis vel."), + CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {0,0,0,255})); + + CLAY_RECTANGLE(CLAY_ID("Photos"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_GROW() }, .childAlignment = { .x = CLAY_ALIGN_X_CENTER, .y = CLAY_ALIGN_Y_CENTER }, .childGap = 16, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = {180, 180, 220, 255}), { + CLAY_IMAGE(CLAY_ID("Picture2"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(120), .height = CLAY_SIZING_FIXED(120) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {120, 120}), {}); + CLAY_RECTANGLE(CLAY_ID("Picture1"), CLAY_LAYOUT(.childAlignment = { .x = CLAY_ALIGN_X_CENTER }, .layoutDirection = CLAY_TOP_TO_BOTTOM, .padding = {8, 8}), CLAY_RECTANGLE_CONFIG(.color = {170, 170, 220, 255}), { + CLAY_IMAGE(CLAY_ID("ProfilePicture"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(60), .height = CLAY_SIZING_FIXED(60) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {60, 60}), {}); + CLAY_TEXT(CLAY_ID("ProfileTitle"), CLAY_STRING("Image caption below"), CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {0,0,0,255})); + }); + CLAY_IMAGE(CLAY_ID("Picture3"), CLAY_LAYOUT( .sizing = { .width = CLAY_SIZING_FIXED(120), .height = CLAY_SIZING_FIXED(120) }), CLAY_IMAGE_CONFIG(.imageData = &profilePicture, .sourceDimensions = {120, 120}), {}); + }); +// + CLAY_TEXT(CLAY_ID("BodyText4"), + CLAY_STRING("Amet cursus sit amet dictum sit amet justo donec. Et malesuada fames ac turpis egestas maecenas. A lacus vestibulum sed arcu non odio euismod lacinia. Gravida neque convallis a cras. Dui nunc mattis enim ut tellus elementum sagittis vitae et. Orci sagittis eu volutpat odio facilisis mauris. Neque gravida in fermentum et sollicitudin ac orci. Ultrices dui sapien eget mi proin sed libero. Euismod quis viverra nibh cras pulvinar mattis. Diam volutpat commodo sed egestas egestas. In fermentum posuere urna nec tincidunt praesent semper. Integer eget aliquet nibh praesent tristique magna.\nId cursus metus aliquam eleifend mi in. Sed pulvinar proin gravida hendrerit lectus a. Etiam tempor orci eu lobortis elementum nibh tellus. Nullam vehicula ipsum a arcu cursus vitae. Elit scelerisque mauris pellentesque pulvinar pellentesque habitant morbi tristique senectus. Condimentum lacinia quis vel eros donec ac odio. Mattis pellentesque id nibh tortor id aliquet lectus. Turpis egestas integer eget aliquet nibh praesent tristique. Porttitor massa id neque aliquam vestibulum morbi. Mauris commodo quis imperdiet massa tincidunt nunc pulvinar sapien et. Nunc scelerisque viverra mauris in aliquam sem fringilla. Suspendisse ultrices gravida dictum fusce ut placerat orci nulla.\nLacus laoreet non curabitur gravida arcu ac tortor dignissim. Urna nec tincidunt praesent semper feugiat nibh sed pulvinar. Tristique senectus et netus et malesuada fames ac. Nunc aliquet bibendum enim facilisis gravida. Egestas maecenas pharetra convallis posuere morbi leo urna molestie. Sapien nec sagittis aliquam malesuada bibendum arcu vitae elementum curabitur. Ac turpis egestas maecenas pharetra convallis posuere morbi leo urna. Viverra vitae congue eu consequat. Aliquet enim tortor at auctor urna. Ornare massa eget egestas purus viverra accumsan in nisl nisi. Elit pellentesque habitant morbi tristique senectus et netus et malesuada.\nSuspendisse ultrices gravida dictum fusce ut placerat orci nulla pellentesque. Lobortis feugiat vivamus at augue eget arcu. Vitae justo eget magna fermentum iaculis eu. Gravida rutrum quisque non tellus orci. Ipsum faucibus vitae aliquet nec. Nullam non nisi est sit amet. Nunc consequat interdum varius sit amet mattis vulputate enim. Sem fringilla ut morbi tincidunt augue interdum. Vitae purus faucibus ornare suspendisse. Massa tincidunt nunc pulvinar sapien et. Fringilla ut morbi tincidunt augue interdum velit euismod in. Donec massa sapien faucibus et. Est placerat in egestas erat imperdiet. Gravida rutrum quisque non tellus. Morbi non arcu risus quis varius quam quisque id diam. Habitant morbi tristique senectus et netus et malesuada fames ac. Eget lorem dolor sed viverra.\nOrnare massa eget egestas purus viverra. Varius vel pharetra vel turpis nunc eget lorem. Consectetur purus ut faucibus pulvinar elementum. Placerat in egestas erat imperdiet sed euismod nisi. Interdum velit euismod in pellentesque massa placerat duis ultricies lacus. Aliquam nulla facilisi cras fermentum odio eu. Est pellentesque elit ullamcorper dignissim cras tincidunt. Nunc sed id semper risus in hendrerit gravida rutrum. A pellentesque sit amet porttitor eget dolor morbi. Pellentesque habitant morbi tristique senectus et netus et malesuada fames. Nisl nunc mi ipsum faucibus vitae aliquet nec ullamcorper. Sed id semper risus in hendrerit gravida. Tincidunt praesent semper feugiat nibh. Aliquet lectus proin nibh nisl condimentum id venenatis a. Enim sit amet venenatis urna cursus eget. In egestas erat imperdiet sed euismod nisi porta lorem mollis. Lacinia quis vel eros donec ac odio tempor orci. Donec pretium vulputate sapien nec sagittis aliquam malesuada bibendum arcu. Erat pellentesque adipiscing commodo elit at.\nEgestas sed sed risus pretium quam vulputate. Vitae congue mauris rhoncus aenean vel elit scelerisque mauris pellentesque. Aliquam malesuada bibendum arcu vitae elementum. Congue mauris rhoncus aenean vel elit scelerisque mauris. Pellentesque dignissim enim sit amet venenatis urna cursus. Et malesuada fames ac turpis egestas sed tempus urna. Vel fringilla est ullamcorper eget nulla facilisi etiam dignissim. Nibh cras pulvinar mattis nunc sed blandit libero. Fringilla est ullamcorper eget nulla facilisi etiam dignissim. Aenean euismod elementum nisi quis eleifend quam adipiscing vitae proin. Mauris pharetra et ultrices neque ornare aenean euismod elementum. Ornare quam viverra orci sagittis eu. Odio ut sem nulla pharetra diam sit amet nisl suscipit. Ornare lectus sit amet est. Ullamcorper sit amet risus nullam eget. Tincidunt lobortis feugiat vivamus at augue eget arcu dictum.\nUrna nec tincidunt praesent semper feugiat nibh. Ut venenatis tellus in metus vulputate eu scelerisque felis. Cursus risus at ultrices mi tempus. In pellentesque massa placerat duis ultricies lacus sed turpis. Platea dictumst quisque sagittis purus. Cras adipiscing enim eu turpis egestas. Egestas sed tempus urna et pharetra pharetra. Netus et malesuada fames ac turpis egestas integer eget aliquet. Ac turpis egestas sed tempus. Sed lectus vestibulum mattis ullamcorper velit sed. Ante metus dictum at tempor commodo ullamcorper a. Augue neque gravida in fermentum et sollicitudin ac. Praesent semper feugiat nibh sed pulvinar proin gravida. Metus aliquam eleifend mi in nulla posuere sollicitudin aliquam ultrices. Neque gravida in fermentum et sollicitudin ac orci phasellus egestas.\nRidiculus mus mauris vitae ultricies. Morbi quis commodo odio aenean. Duis ultricies lacus sed turpis. Non pulvinar neque laoreet suspendisse interdum consectetur. Scelerisque eleifend donec pretium vulputate sapien nec sagittis aliquam. Volutpat est velit egestas dui id ornare arcu odio ut. Viverra tellus in hac habitasse platea dictumst vestibulum rhoncus est. Vestibulum lectus mauris ultrices eros. Sed blandit libero volutpat sed cras ornare. Id leo in vitae turpis massa sed elementum tempus. Gravida dictum fusce ut placerat orci nulla pellentesque. Pretium quam vulputate dignissim suspendisse in. Nisl suscipit adipiscing bibendum est ultricies integer quis auctor. Risus viverra adipiscing at in tellus. Turpis nunc eget lorem dolor sed viverra ipsum. Senectus et netus et malesuada fames ac. Habitasse platea dictumst vestibulum rhoncus est. Nunc sed id semper risus in hendrerit gravida. Felis eget velit aliquet sagittis id. Eget felis eget nunc lobortis.\nMaecenas pharetra convallis posuere morbi leo. Maecenas volutpat blandit aliquam etiam. A condimentum vitae sapien pellentesque habitant morbi tristique senectus et. Pulvinar mattis nunc sed blandit libero volutpat sed. Feugiat in ante metus dictum at tempor commodo ullamcorper. Vel pharetra vel turpis nunc eget lorem dolor. Est placerat in egestas erat imperdiet sed euismod. Quisque non tellus orci ac auctor augue mauris augue. Placerat vestibulum lectus mauris ultrices eros in cursus turpis. Enim nunc faucibus a pellentesque sit. Adipiscing vitae proin sagittis nisl. Iaculis at erat pellentesque adipiscing commodo elit at imperdiet. Aliquam sem fringilla ut morbi.\nArcu odio ut sem nulla pharetra diam sit amet nisl. Non diam phasellus vestibulum lorem sed. At erat pellentesque adipiscing commodo elit at. Lacus luctus accumsan tortor posuere ac ut consequat. Et malesuada fames ac turpis egestas integer. Tristique magna sit amet purus. A condimentum vitae sapien pellentesque habitant. Quis varius quam quisque id diam vel quam. Est ullamcorper eget nulla facilisi etiam dignissim diam quis. Augue interdum velit euismod in pellentesque massa. Elit scelerisque mauris pellentesque pulvinar pellentesque habitant. Vulputate eu scelerisque felis imperdiet. Nibh tellus molestie nunc non blandit massa. Velit euismod in pellentesque massa placerat. Sed cras ornare arcu dui. Ut sem viverra aliquet eget sit. Eu lobortis elementum nibh tellus molestie nunc non. Blandit libero volutpat sed cras ornare arcu dui vivamus.\nSit amet aliquam id diam maecenas. Amet risus nullam eget felis eget nunc lobortis mattis aliquam. Magna sit amet purus gravida. Egestas purus viverra accumsan in nisl nisi. Leo duis ut diam quam. Ante metus dictum at tempor commodo ullamcorper. Ac turpis egestas integer eget. Fames ac turpis egestas integer eget aliquet nibh. Sem integer vitae justo eget magna fermentum. Semper auctor neque vitae tempus quam pellentesque nec nam aliquam. Vestibulum mattis ullamcorper velit sed. Consectetur adipiscing elit duis tristique sollicitudin nibh. Massa id neque aliquam vestibulum morbi blandit cursus risus.\nCursus sit amet dictum sit amet justo donec enim diam. Egestas erat imperdiet sed euismod. Nullam vehicula ipsum a arcu cursus vitae congue mauris. Habitasse platea dictumst vestibulum rhoncus est pellentesque elit. Duis ultricies lacus sed turpis tincidunt id aliquet risus feugiat. Faucibus ornare suspendisse sed nisi lacus sed viverra. Pretium fusce id velit ut tortor pretium viverra. Fermentum odio eu feugiat pretium nibh ipsum consequat nisl vel. Senectus et netus et malesuada. Tellus pellentesque eu tincidunt tortor aliquam. Aenean sed adipiscing diam donec adipiscing tristique risus nec feugiat. Quis vel eros donec ac odio. Id interdum velit laoreet id donec ultrices tincidunt.\nMassa id neque aliquam vestibulum morbi blandit cursus risus at. Enim tortor at auctor urna nunc id cursus metus. Lorem ipsum dolor sit amet consectetur. At quis risus sed vulputate odio. Facilisis mauris sit amet massa vitae tortor condimentum lacinia quis. Et malesuada fames ac turpis egestas maecenas. Bibendum arcu vitae elementum curabitur vitae nunc sed velit dignissim. Viverra orci sagittis eu volutpat odio facilisis mauris. Adipiscing bibendum est ultricies integer quis auctor elit sed. Neque viverra justo nec ultrices dui sapien. Elementum nibh tellus molestie nunc non blandit massa enim. Euismod elementum nisi quis eleifend quam adipiscing vitae proin sagittis. Faucibus ornare suspendisse sed nisi. Quis viverra nibh cras pulvinar mattis nunc sed blandit. Tristique senectus et netus et. Magnis dis parturient montes nascetur ridiculus mus.\nDolor magna eget est lorem ipsum dolor. Nibh sit amet commodo nulla. Donec pretium vulputate sapien nec sagittis aliquam malesuada. Cras adipiscing enim eu turpis egestas pretium. Cras ornare arcu dui vivamus arcu felis bibendum ut tristique. Mus mauris vitae ultricies leo integer. In nulla posuere sollicitudin aliquam ultrices sagittis orci. Quis hendrerit dolor magna eget. Nisl tincidunt eget nullam non. Vitae congue eu consequat ac felis donec et odio. Vivamus at augue eget arcu dictum varius duis at. Ornare quam viverra orci sagittis.\nErat nam at lectus urna duis convallis. Massa placerat duis ultricies lacus sed turpis tincidunt id aliquet. Est ullamcorper eget nulla facilisi etiam dignissim diam. Arcu vitae elementum curabitur vitae nunc sed velit dignissim sodales. Tortor vitae purus faucibus ornare suspendisse sed nisi lacus. Neque viverra justo nec ultrices dui sapien eget mi proin. Viverra accumsan in nisl nisi scelerisque eu ultrices. Consequat interdum varius sit amet mattis. In aliquam sem fringilla ut morbi. Eget arcu dictum varius duis at. Nulla aliquet porttitor lacus luctus accumsan tortor posuere. Arcu bibendum at varius vel pharetra vel turpis. Hac habitasse platea dictumst quisque sagittis purus sit amet. Sapien eget mi proin sed libero enim sed. Quam elementum pulvinar etiam non quam lacus suspendisse faucibus interdum. Semper viverra nam libero justo. Fusce ut placerat orci nulla pellentesque dignissim enim sit amet. Et malesuada fames ac turpis egestas maecenas pharetra convallis posuere.\nTurpis egestas sed tempus urna et pharetra pharetra massa. Gravida in fermentum et sollicitudin ac orci phasellus. Ornare suspendisse sed nisi lacus sed viverra tellus in. Fames ac turpis egestas maecenas pharetra convallis posuere. Mi proin sed libero enim sed faucibus turpis. Sit amet mauris commodo quis imperdiet massa tincidunt nunc. Ut etiam sit amet nisl purus in mollis nunc. Habitasse platea dictumst quisque sagittis purus sit amet volutpat consequat. Eget aliquet nibh praesent tristique magna. Sit amet est placerat in egestas erat. Commodo sed egestas egestas fringilla. Enim nulla aliquet porttitor lacus luctus accumsan tortor posuere ac. Et molestie ac feugiat sed lectus vestibulum mattis ullamcorper. Dignissim convallis aenean et tortor at risus viverra. Morbi blandit cursus risus at ultrices mi. Ac turpis egestas integer eget aliquet nibh praesent tristique magna.\nVolutpat sed cras ornare arcu dui. Egestas erat imperdiet sed euismod nisi porta lorem mollis aliquam. Viverra justo nec ultrices dui sapien. Amet risus nullam eget felis eget nunc lobortis. Metus aliquam eleifend mi in. Ut eu sem integer vitae. Auctor elit sed vulputate mi sit amet. Nisl nisi scelerisque eu ultrices. Dictum fusce ut placerat orci nulla. Pellentesque habitant morbi tristique senectus et. Auctor elit sed vulputate mi sit. Tincidunt arcu non sodales neque. Mi in nulla posuere sollicitudin aliquam. Morbi non arcu risus quis varius quam quisque id diam. Cras adipiscing enim eu turpis egestas pretium aenean pharetra magna. At auctor urna nunc id cursus metus aliquam. Mauris a diam maecenas sed enim ut sem viverra. Nunc scelerisque viverra mauris in. In iaculis nunc sed augue lacus viverra vitae congue eu. Volutpat blandit aliquam etiam erat velit scelerisque in dictum non."), + CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {0,0,0,255})); + }); + }); + }); +// + CLAY_FLOATING_CONTAINER(CLAY_ID("Blob4Floating"), &CLAY_LAYOUT_DEFAULT, CLAY_FLOATING_CONFIG(.zIndex = 1, .parentId = CLAY_ID("SidebarBlob4")), { + CLAY_SCROLL_CONTAINER(CLAY_ID("ScrollContainer"), CLAY_LAYOUT(.sizing = { .height = CLAY_SIZING_FIXED(200) }, .childGap = 2), CLAY_SCROLL_CONFIG(.vertical = true), { + CLAY_FLOATING_CONTAINER(CLAY_ID("FloatingContainer"), CLAY_LAYOUT(), CLAY_FLOATING_CONFIG(.zIndex = 1), { + CLAY_RECTANGLE(CLAY_ID("FLoatingContainerInner"), CLAY_LAYOUT(.sizing = { .width = CLAY_SIZING_FIXED(300), .height = CLAY_SIZING_FIXED(300) }, .padding = {16, 16}), CLAY_RECTANGLE_CONFIG(.color = {140,80, 200, 200}), { + CLAY_TEXT(CLAY_ID("FloatingContainerText"), CLAY_STRING("I'm an inline floating container."), CLAY_TEXT_CONFIG(.fontSize = 24, .textColor = {255,255,255,255})); + }); + }); + CLAY_RECTANGLE(CLAY_ID("ScrollContainerInner"), CLAY_LAYOUT(.layoutDirection = CLAY_TOP_TO_BOTTOM), CLAY_RECTANGLE_CONFIG(.color = {160, 160, 160, 255}), { + for (int i = 0; i < 100; i++) { + RenderDropdownTextItem(); + } + }); + }); + }); + }); + return Clay_EndLayout(GetScreenWidth(), GetScreenHeight()); +} + +int display_size_changed = 0; + +void UpdateDrawFrame(void) +{ + float mouseWheelX = 0, mouseWheelY = 0; + Vector2 mouseWheelDelta = GetMouseWheelMoveV(); + mouseWheelX = mouseWheelDelta.x; + mouseWheelY = mouseWheelDelta.y; + //---------------------------------------------------------------------------------- + // Handle scroll containers + Clay_SetPointerPosition(RAYLIB_VECTOR2_TO_CLAY_VECTOR2(GetMousePosition())); + Clay_UpdateScrollContainers(IsMouseButtonDown(0), (Clay_Vector2) {mouseWheelX, mouseWheelY}, GetFrameTime()); + // Generate the auto layout for rendering + double currentTime = GetTime(); + Clay_RenderCommandArray renderCommands = CreateLayout(); + printf("layout time: %f microseconds\n", (GetTime() - currentTime) * 1000 * 1000); + // RENDERING --------------------------------- +// currentTime = GetTime(); + BeginDrawing(); + Clay_Raylib_Render(renderCommands); + EndDrawing(); +// printf("render time: %f ms\n", (GetTime() - currentTime) * 1000); + + //---------------------------------------------------------------------------------- +} + +int main(void) { + uint64_t totalMemorySize = Clay_MinMemorySize(); + Clay_Arena clayMemory = (Clay_Arena) { .label = CLAY_STRING("Clay Memory Arena"), .memory = malloc(totalMemorySize), .capacity = totalMemorySize }; + Clay_SetMeasureTextFunction(Raylib_MeasureText); + Clay_Initialize(clayMemory); + Clay_Raylib_Initialize(FLAG_VSYNC_HINT | FLAG_WINDOW_RESIZABLE | FLAG_WINDOW_HIGHDPI | FLAG_MSAA_4X_HINT); + profilePicture = LoadTextureFromImage(LoadImage("resources/profile-picture.png")); + Raylib_fonts[FONT_ID_BODY_24] = (Raylib_Font) { + .font = LoadFontEx("resources/Roboto-Regular.ttf", 48, 0, 400), + .fontId = FONT_ID_BODY_24, + }; + SetTextureFilter(Raylib_fonts[FONT_ID_BODY_24].font.texture, TEXTURE_FILTER_TRILINEAR); + + Raylib_fonts[FONT_ID_BODY_16] = (Raylib_Font) { + .font = LoadFontEx("resources/Roboto-Regular.ttf", 32, 0, 400), + .fontId = FONT_ID_BODY_16, + }; + SetTextureFilter(Raylib_fonts[FONT_ID_BODY_16].font.texture, TEXTURE_FILTER_TRILINEAR); + + //-------------------------------------------------------------------------------------- + + // Main game loop + while (!WindowShouldClose()) // Detect window close button or ESC key + { + UpdateDrawFrame(); + } + return 0; +} diff --git a/examples/raylib-sidebar-scrolling-container/resources/Roboto-Regular.ttf b/examples/raylib-sidebar-scrolling-container/resources/Roboto-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ddf4bfacb396e97546364ccfeeb9c31dfaea4c25 GIT binary patch literal 168260 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

S&jh1n&JeeMOkU4{=4@cYr6k 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≤FHXCuU9Qce=@vmZ{%9^5??OaVQJ8!4u8-w;yt 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