RayClay cheatsheet

Window + frame#

void rcInitWindow(int width, int height, const char *title);

# Open a GLFW window + GL context (the runner does this for you)

void rcCloseWindow(void);

# Tear down the backends + window - the SPLIT-LOOP host's teardown See api notes: rcCloseWindow

Not how an rcRunApp app quits itself - a Quit button calls rcAppRequestClose(app). Calling this from a callback is safe but the teardown's TIMING is not yours to predict.

void rcRender(RC_RenderCommandArray commands);

# Translate one frame of render commands into draw calls (after the layout pass)

RC_Dimensions rcGetWindowDimensions(void);

# Window size in real logical px (zoom never scales it)

float rcGetContentScale(void);

# Display device-pixel-ratio; read-only, independent of zoom See api notes: rcGetContentScale / rcGetWindowDimensions

void rcSyncLayoutDimensions(void);

# Push the layout size - floor(window / zoom) - into the layout engine (once per frame before layout)

RC_String rcStringFromCStr(const char *cstr);

# Wrap a C string as a RC_String without copying (you keep it alive)

Diagnostics#

void rcSetLogSink(RC_LogCallback sink, void *user);

# Route warnings/errors to your callback (NULL restores stderr)

size_t rcProcessMemoryBytes(void);

# This process's resident memory (0 = platform offers no reading)

float rcProcessCpuPercent(void);

# CPU since the PREVIOUS call, as % of ONE core (like top) See api notes: rcProcessMemoryBytes / rcProcessCpuPercent

Fonts#

uint16_t rcLoadFont(const char *path, float size);

# Bake a TTF/OTF at size px into the atlas; returns its fontId.

bool rcUnloadFont(uint16_t font);

# Release a fontId's slot so a later load can reuse it. See api notes: rcUnloadFont

uint16_t rcRegisterFont(const char *family, RC_FontWeight weight, const char *path, float size);

# Bake AND index by (family, weight, size)

uint16_t rcFont(const char *family, RC_FontWeight weight, float size);

# Resolve a registered (family, weight, size) to its fontId

See api notes: RC_FONT_LAST_CODEPOINT - widening the baked range

RC_Dimensions rcMeasureText(RC_StringSlice text, RC_TextElementConfig *config, void *userData);

# The UTF-8 text-measure callback the runner registers for you

Images#

(compile out with RC_NO_IMAGE)

RC_Image rcLoadImage(const char *path);

# Load a PNG/JPG/BMP file into a GPU texture (check .handle != NULL).

RC_Image rcLoadImageFromMemory(const unsigned char *bytes, int len);

# Like rcLoadImage but decode an encoded image already in memory

void rcUnloadImage(RC_Image *img);

# Free the GPU texture behind an image and zero its handle See api notes: rcUnloadImage

SVG#

(compile out with RC_NO_SVG)

void rcSvg(const char *path, float size, RC_Color color);

# Draw an SVG BY PATH straight in the layout - parsed once, cached, freed for you. START HERE

RC_Svg * rcLoadSvg(const char *path);

# Parse an .svg at runtime into a handle YOU own; NULL on failure (reason logged)

RC_Svg * rcLoadSvgFromMemory(const char *bytes, int len);

# Like rcLoadSvg but parse SVG text already in memory (a baked asset, or markup built this frame)

void rcSvgHandle(const RC_Svg *svg, float size, RC_Color color);

# Draw from a handle you loaded - for markup with no file behind it, or swapping handles

void rcUnloadSvg(RC_Svg **svg);

# Free a parsed SVG and NULL the caller's pointer; safe to call twice See api notes: Loading an SVG at runtime

Per-frame arena + formatting#

RC_Arena rcArenaInit(size_t size);

# Create a bump allocator for per-frame allocations

void *rcArenaAlloc(RC_Arena *arena, size_t size);

# Allocate size bytes from the arena

void rcArenaReset(RC_Arena *arena);

# Reclaim every arena allocation at once (no per-item free)

void rcArenaFree(RC_Arena *arena);

# Release the arena's backing buffer

RC_String rcFormat(RC_Arena *arena, const char *fmt, ...);

# printf into arena memory; the RC_String lives until rcArenaReset

The one-call entry point#

(blocks until the window closes)

int rcRunApp(const RC_AppOptions *options);

# Run the full app loop from an options struct (desktop + web)

Split lifecycle#

(for a host that owns its own frame loop)

RC_App *rcAppCreate(const RC_AppOptions *options);

# Open the window + init backends; NULL on failure

bool rcRunFrame(RC_App *app);

# Render exactly one frame; false => time to stop

void rcAppDestroy(RC_App *app);

# Normal teardown + free the RC_App See api notes: rcAppDestroy

Accessors#

(use inside the update/layout callbacks)

RC_Arena *rcAppArena(RC_App *app);

# The runner's per-frame scratch arena (for rcFormat) See api notes: rcAppArena

Needs RC_AppOptions.scratchArenaBytes > 0; at the 0 default rcFormat returns a visible marker

void rcAppRequestClose(RC_App *app);

# Ask the runner to exit its loop after the current frame

bool rcAppIsDebugEnabled(const RC_App *app);

# Whether the layout inspector is currently on

float rcAppFrameTime(const RC_App *app);

# Smoothed seconds BETWEEN frames (0 before the first timed frame)

float rcAppFPS(const RC_App *app);

# Reciprocal of rcAppFrameTime - see the caveat below

double rcAppTime(const RC_App *app);

# Monotonic seconds since windowing start-up - the clock to drive animation from See api notes: rcAppTime

Only differences are meaningful. The origin is not a date, not process start, and not the same for a second app in one process.

RC_FrameCounts rcAppFrameCounts(const RC_App *app);

# What you DECLARED vs what actually DREW See api notes: rcAppFrameCounts

• .declared (before culling)
• .drawCommands (survived culling). Always compiled in - no build knob

Redraw scheduling#

void rcAppRequestFrame(RC_App *app);

# "my state changed, draw once more"

void rcAppRequestFrameAfter(RC_App *app, double s);

# Timed step: wake in s seconds, then draw

void rcAppSetContinuousRendering(RC_App *app, bool on);

# Flip the mode at runtime See api notes: rcAppRequestFrame / rcAppRequestFrameAfter

float rcAppZoom(const RC_App *app);

# Current zoom factor (1.0 = 100%; 1.0 for a NULL app)

void rcAppSetZoom(RC_App *app, float zoom);

# Set the zoom factor, clamped to [minZoom, maxZoom] (for a reset action or persisting the user's choice)

RC_ZoomMode rcAppZoomMode(const RC_App *app);

# Current zoom mode (RC_ZOOM_LAYOUT / RC_ZOOM_OPTICAL; LAYOUT for a NULL app)

void rcAppSetZoomMode(RC_App *app, RC_ZoomMode m);

# Switch layout<->optical at runtime (effect next frame; the zoom factor is preserved)

const float *rcAppZoomLadder(const RC_App *app, uint16_t *count);

# See api notes: rcAppZoomLadder

int rcAppTitlebarHeight(const RC_App *app);

# Caption-strip height in PHYSICAL px (0 for a NULL app)

void rcAppSetTitlebarHeight(RC_App *app, int h);

# Re-set the caption height when your bar folds/animates - only Windows reads it, as the drag region; never moves the window minimum; <=0 = none, unchanged = no-op

Windows reserves the top SM_CYSIZEFRAME + SM_CXPADDEDBORDER px as the RESIZE BORDER and it outranks the caption (4+4=8 at 96 DPI, more when scaled),

so a strip that thin keeps no draggable pixel there. Measured with WM_NCHITTEST. See api notes: rcAppTitlebarHeight / rcAppSetTitlebarHeight

RC_Color rcAppClearColor(const RC_App *app);

# The window background actually painted (ALWAYS opaque; opaque black for a NULL app)

void rcAppSetClearColor(RC_App *app, RC_Color color);

# Change it live - rcSetStyle cannot. alpha 0 = "the theme's background AT THIS MOMENT" See api notes: rcAppClearColor

Hold a subtree OUT of the zoom#

chrome, not content (a custom titlebar, a HUD, a status strip)

rcUnzoomed() { ... }

# Block: everything inside keeps a CONSTANT on-screen size at any zoom

void rcBeginUnzoomed(void);

# The scope's push/pop, for when a block will not fit (opens in one

void rcEndUnzoomed(void);

# helper, closes in another). Prefer rcUnzoomed() - it cannot unbalance

float rcUnzoomedScale(void);

# 1/zoom inside a scope, exactly 1.0 outside - for YOUR OWN pixel maths

Built-in titlebar#

void rcTitlebar(const RC_TitlebarOptions *options);

# The bundled bar at the current position; NULL = defaults

void rcWindowControlButton(RC_WindowControl c, RC_IconCallback icon, float iconSize);

# One control, as a Flat Slab

void rcWindowControls(void);

# The standard min/max/close cluster, in one call

bool rcIsWindowMaximized(void);

# True while maximised - swap your custom bar's maximise glyph for a restore glyph See api notes: The bundled titlebar (Flat Slab)

Fixed chrome: content zoom never resizes or moves the bundled band (opt in with .zoomWithContent)

Containers#

(open a brace body; configure with designated initialisers)

rcBox(...) { ... }

# Generic container, top-to-bottom by default

rcColumn(...) { ... }

# Explicit vertical container

rcRow(...) { ... }

# Horizontal container

rcSeparator(...) { ... }

# A stretchy spacer that grows to fill

rcMargin(...) { ... }

# A fit-sized spacer See api notes: Leaving a container body early

Typed sizing helpers (.wType / .hType)#

the 1:1 equivalent for a RUNTIME-COMPUTED size a string literal

can't hold (e.g. RC_PX(row.height)), and a parse-skipping fast path. A typed axis wins over its string.

RC_FIT

# Shrink to content

RC_GROW

# Grow to fill the parent

RC_PX(px)

# Fixed px pixels

RC_PCT(pct)

# pct percent of the parent

RC_VW(vw)

# vw percent of the viewport (window) width - like CSS vw; correct in both zoom modes

RC_VH(vh)

# vh percent of the viewport (window) height - like CSS vh; tracks window resize

Compose your own helpers#

RC_ElementDeclaration rcParseComponentOptions(RC_ComponentOptions opts, RC_ElementDeclaration base);

# Build one element declaration from flat RC_ options

void rcBeginComponent(RC_ComponentOptions opts, RC_ElementDeclaration defaults);

# Open + configure one element (handles the id)

void rcEndComponent(void);

# Close the element rcBeginComponent opened.

rcComponent(defaults, ...)

# The macro rcBox/rcRow/rcColumn/rcSeparator/rcMargin are each one line of: pairs Begin+End

rcExpand(x)

# Identity macro. Wrap a forwarded __VA_ARGS__ in it so MSVC's traditional preprocessor expands it See api notes: rcComponent - worked example in ex20_system_monitor (card)

Controls#

(each takes a unique string id; persistent state is yours, by pointer)

bool rcButton(const char *id, const char *label, RC_ButtonVariant variant);

# A clickable button; true on the RELEASE edge, like rcClicked (slide off before releasing and it cancels)

bool rcCheckbox(const char *id, const char *label, bool *value);

# A labelled checkbox bound to *value; true on change

bool rcToggle(const char *id, bool *value);

# An on/off switch bound to *value; true on change

bool rcSlider(const char *id, float *value, float min, float max);

# A horizontal slider clamped to [min, max]; true on change

void rcProgress(const char *id, float fraction);

# A determinate progress bar (fraction 0..1; visual only)

bool rcRadio(const char *id, const char *label, int *selected, int index);

# A radio option in a *selected group; true when it becomes selected

bool rcCombo(const char *id, int *selected, const char *const *items, int count);

# A dropdown of items; true on the frame the selection changes

Text input#

(native stb_textedit over YOUR buffer; TYPED input is ASCII in v1 - but a .placeholder or a value you PRE-FILL renders full Latin-1)

bool rcTextInput(const char *id, char *buf, int cap, ...);

# Single-line text field; true on a frame the buffer changed See api notes: rcTextInput - the caret settle

bool rcTextInputEx(const char *id, char *buf, int cap, RC_TextInputOptions opts);

# As rcTextInput but options by value (C-ABI stable)

bool rcTextArea(const char *id, char *buf, int cap, ...);

# Multiline area (Enter=newline, soft-wrap, .rows=N); true on a frame the buffer changed

Scrolling#

void rcScrollbar(const char *containerId);

# Draw a draggable VERTICAL scrollbar for a scroll container (v1: vertical only; horizontal overflow gets no bar) See api notes: Big tables: virtualize the row loop

void rcScrollBy(const char *containerId, float deltaX, float deltaY);

# Scroll a clip container by a delta, programmatically See api notes: rcScrollBy - the sign convention

void rcScrollToTop(const char *containerId);

# Scroll a clip container to the top

void rcScrollToBottom(const char *containerId);

# Scroll a clip container to the bottom

RC_ScrollInfo rcGetScrollInfo(const char *containerId);

# READ a container's position + travel, DOM-style See api notes: RC_ScrollInfo

bool rcIsScrolledToBottom(const char *containerId);

# At (or past) the bottom edge? ALSO true when the content fits and there is nothing to scroll; false for an unknown id See api notes: clip slots

rcVirtualList(var, containerId, count, rowHeight) { ... }

# Loop macro; var.index is the DATA index

RC_VirtualRow rcVirtualBegin(const char *containerId, int count, float rowHeight);

# What it desugars to

bool rcVirtualNext(RC_VirtualRow *row);

# ...the loop step See api notes: rcVirtualList - the three rules

rcColumn(.id = "Notes", .scroll = "v", .h = "grow") {
    rcVirtualList(row, "Notes", noteCount, 32) {                                // 32 = the REAL row height in px See api notes: Element ids are 32-bit hashes
        rcRow(.id = rcFormat(mem, "note%d", row.index).chars,                   // key by the DATA index; rcFormat's result is
               .w = "grow", .h = "32") { rcTextC(notes[row.index].title); }     // NUL-terminated, so .chars is a char *
    }
}  //  See api notes: rcVirtualList - the three rules

if (lineTotal != lastTotal) {                        // a NEW line arrived. Count from a MONOTONIC total, not a
    if (rcIsScrolledToBottom("log")) rcScrollToBottom("log");   // ring's saturating count - that stops firing once full
    lastTotal = lineTotal;
}

Menus#

(one open at a time; call End* only when the Begin returned true)

bool rcBeginMenu(const char *id, const char *label);

# Open a menu button + its floating item column; true while open

void rcEndMenu(void);

# Close the open menu

bool rcBeginContextMenu(const char *id, const char *targetId);

# Open a context menu on right-click/long-press of targetId; true while open

void rcEndContextMenu(void);

# Close the open context menu

bool rcMenuItem(const char *label);

# A row in the open menu; true on the frame it is activated

Popups: modal dialogs + non-modal panels#

(emit the body only while open; they STACK up to 8 deep - Esc dismisses the topmost first)

bool rcBeginModal(const char *id, bool *open);

# Open a scrim + centered panel; true while *open (Esc/scrim dismisses)

bool rcBeginModalEx(const char *id, bool *open, RC_ModalOptions opts);

# As rcBeginModal but options by value (C-ABI stable)

void rcEndModal(void);

# Close the popup body (call once when Begin returned true)

bool rcIsModalOpen(void);

# Is a MODAL dialog open right now? Flips on the same frame boundary the scrim does See api notes: rcIsModalOpen / RC_ModalOptions

if (rcBeginModalEx("inspector", &open,
        (RC_ModalOptions){ .modality = RC_MODALITY_NON_MODAL, .noBackdropDismiss = true })) {  // detached inspector: app live, panel persists
    rcEndModal();
}

Charts#

(native plotting, immediate-mode - pass this frame's data every frame)

void rcChart(const char *id, const RC_Series *series, int seriesCount, RC_ChartOptions options);

#

void rcSparkline(const char *id, const float *values, int count, RC_SparklineOptions options);

# See api notes: rcSparkline

float cpu[120]; /* your ring buffer - borrowed, must outlive rcRender() */
rcBox(.h = "40") { rcSparkline("cpu", cpu, 120, (RC_SparklineOptions){0}); }                    // inline strip: LINE, theme accent, auto-fit
rcBox(.h = "220") {
    RC_Series s[] = { { .y = rss, .count = 120, .kind = RC_SERIES_AREA, .label = "RSS" },
                      { .y = cpu, .count = 120, .kind = RC_SERIES_LINE, .label = "CPU %", .axis = 1 } };  // .axis=1 -> the right (y2) axis
    rcChart("res", s, 2, (RC_ChartOptions){ .legend = true, .y = { .grid = true }, .y2 = { .max = 100 },
                                             .tooltip = RC_CHART_TOOLTIP_NEAREST });                       // hover => "x 10 / RSS 41 / CPU % 78"
}

static float lo = 0.0f, hi = 500.0f;                                             // YOUR viewport over the data
if (rcIsHovered("res")) {
    float w = rcScrollDeltaY();                                                  // 0 when Ctrl+wheel zoom consumed it
    if (w != 0.0f) {
        float mid = (lo + hi) * 0.5f, half = (hi - lo) * 0.5f * (w > 0.0f ? 0.9f : 1.1f);
        lo = mid - half; hi = mid + half;
    }
}
rcChart("res", s, 2, (RC_ChartOptions){ .x = { .min = lo, .max = hi } });        // pan = add the same delta to both See api notes: rcChart

Split panes#

(a draggable divider between two resizable panes - the sidebar+content shell of IDEs/inspectors/dashboards; call SplitHandle BETWEEN them, End only when Begin returned true)

bool rcBeginSplitPane(const char *id, RC_SplitAxis axis, float *fraction, RC_SplitOptions opts);

#

void rcSplitHandle(void);

# Emit the draggable divider BETWEEN the two panes (grab cursor; keeps dragging if the pointer outruns it)

void rcEndSplitPane(void);

# Close the split container (call once, only when Begin returned true)

static float frac = 0.25f;                                                        // pane-1's share; yours to persist across frames
if (rcBeginSplitPane("shell", RC_SPLIT_ROW, &frac, (RC_SplitOptions){0})) {
    /* ... first pane ... */  rcSplitHandle();  /* ... second pane ... */
    rcEndSplitPane();
}

Table#

(a column-declared data grid; same Begin/Row/End discipline as the other containers)

bool rcBeginTable(const char *id, const RC_TableColumn *cols, int colCount, RC_TableOptions opts);

#

void rcTableRow(void);

# Close any open row; open the next row AND its first cell

void rcTableNext(void);

# Close the current cell; open the next column's cell (past the last column it warns once and content stays put)

void rcEndTable(void);

# Close the table (call once, only when Begin returned true) See api notes: rcEndTable

RC_TableColumn cols[] = { { .header = "Lvl", .w = "48px", .align = "cl" }, { .header = "Message", .w = "grow", .align = "cl" } };  // widths read as CSS strings
if (rcBeginTable("log", cols, 2, (RC_TableOptions){0})) {
    for (int i = 0; i < n; i++) { rcTableRow(); rcTextC(e[i].lvl); rcTableNext(); rcTextC(e[i].msg); }
    rcEndTable();
}
rcScrollbar("log");                                                              // the table's id IS the scroll body See api notes: Big tables: virtualize the row loop

enum { GRID_ROW_H = 28, GRID_PAD = 4, GRID_PITCH = GRID_ROW_H + 2 * GRID_PAD };
if (rcBeginTable("grid", cols, 2, (RC_TableOptions){ .cellPadding = RC_VAL(GRID_PAD) })) {
    rcVirtualList(row, "grid", rowCount, GRID_PITCH) {   // "grid" = the table body's id; the PITCH, not the height
        rcTableRow();  rcTextC(data[row.index].name);
        rcTableNext(); rcTextC(data[row.index].value);
    }
    rcEndTable();
}  //  See api notes: rcVirtualList - the three rules

Element reads#

(ask about ANY element you tagged with an .id; call inside the layout callback)

bool rcIsHovered(const char *id);

# True while the pointer is over the element with this id (this frame)

bool rcClicked(const char *id);

# True on the RELEASE edge - press it, then release still over it. Turns any rcBox into a button

bool rcPressed(const char *id);

# True on the PRESS edge - eager, for a nudge/step/jump control where latency is the point

RC_SchedStats rcAppSchedStats(const RC_App *app);

# Frame-admission counters; spurious/waits is the wake-loop metric

const RC_PerfFrame *rcAppPerfFrame(const RC_App *app);

# What the last DRAWN frame cost. Needs -DRC_PERF_COUNTERS=1 - the one public fn not compiled in by default; read it from a frameEndCallback See api notes: RC_PERF_COUNTERS

const char* rcFrameReasonName(RC_FrameReason r);

# "input", "window", … - a chart series label for byReason[]

bool rcIsFocused(const char *id);

# True while the rcTextInput with this id holds keyboard focus

void rcSetFocus(const char *id);

# Move keyboard focus to that text input (NULL/"" clears); call on an event, not every frame

void rcSetCursor(RC_Cursor cursor);

# This frame's cursor shape (last-writer-wins; CSS-style). See api notes: The gesture vocabulary

Pointer position + buttons#

the gesture vocabulary, for a gesture still in flight

RC_Vec2 rcPointer(void);

# Pointer position, in CONTENT space See api notes: RC_Vec2

bool rcPointerDown(RC_PointerButton button);

# True while the button is held - the LEVEL you track a drag with

bool rcPointerPressed(RC_PointerButton button);

# True on the frame it goes down - the edge that STARTS a gesture (fires once; does not repeat while held)

bool rcPointerReleased(RC_PointerButton button);

# True on the frame it goes up - the edge that COMMITS. See api notes: rcPointerReleased

Element geometry#

WHERE a box ended up, in the same CONTENT space rcPointer reports

RC_Box rcGetElementBox(const char *id);

# Where that element ended up, in CONTENT space

RC_Box rcChartPlotRect(const char *chartId);

# A chart's PLOT area (NOT its outer box) See api notes: RC_Box

Pointer wheel#

float rcScrollDeltaY(void);

# Mouse-wheel delta this frame, in lines (positive = up); 0 if none, or when Ctrl+wheel zoom consumed the wheel (zoom is on by default)

float rcScrollDeltaX(void);

# Horizontal wheel delta this frame, in lines; 0 when the wheel went to zoom See api notes: rcScrollBy - the sign convention

Keyboard#

(poll key + modifier state anywhere in the layout/update callback; RC_Key names the key, RC_Mod the modifier)

bool rcKeyDown(RC_Key key);

# True while the key is held this frame (a level, independent of auto-repeat) - for continuous input like hold-to-move

bool rcKeyPressed(RC_Key key);

# True on the frame the key goes down (a fresh edge; auto-repeat does NOT re-fire) - for one-shot actions.

bool rcKeyReleased(RC_Key key);

# True on the frame the key goes up

bool rcModDown(RC_Mod mod);

# See api notes: rcModDown and RC_MOD_PRIMARY

Clipboard#

(a read is request-then-poll, not a blocking pull)

const char *rcClipboardGet(void);

# Best-effort SYNC read: the answer if one is already in hand, else NULL.

void rcClipboardSet(const char *text);

# Replace the clipboard text (a NUL-terminated copy is taken); fire-and-forget, synchronous everywhere

RC_ClipboardToken rcClipboardRequest(void);

# Ask for the text without waiting; returns the token naming THIS read (0 = none).

const char *rcClipboardPoll(RC_ClipboardToken token);

# Collect that read's answer exactly once: the text, or NULL if still pending/denied/already taken.

void rcClipboardDeliver(RC_ClipboardToken token, const char *utf8);

#

void rcSetClipboardImpl(const RC_ClipboardImpl *impl);

# Install a clipboard backend (COPIED BY VALUE - a stack local is fine; NULL restores the platform default). See api notes: rcSetClipboardImpl

Value + string helpers#

(return RayClay value types - interchangeable with brace literals)

RC_Color rcAlpha(RC_Color color, uint8_t alpha);

# The same colour with a new alpha (0..255)

RC_Color rcRgb(r, g, b) / rcRgba(r, g, b, a);

# Compile-time colour builders (0-255 channels) - name a reusable palette shade at file scope, RayClay's theme.extend.colors

RC_Color rcHex(uint32_t rgb);

# An opaque colour from a 0xRRGGBB hex value, e.g. .bg = rcHex(0x1e293b)

RC_Color rcColor(const char *css);

# A colour from a CSS string, so it reads like inline CSS: .bg = rcColor("#1e293b").

void rcStrCopy(char *dst, const char *src, size_t dstsize);

# Safe always-NUL-terminating copy (pass the FULL buffer size); no <string.h> needed

Bundled titlebar artwork (the Flat Slab glyphs)#

void rcIconTitlebarMinimize(float size, RC_Color color);

# auto-included by rayclay.h on DESKTOP - nothing extra to add

void rcIconTitlebarMaximize(float size, RC_Color color);

#

void rcIconTitlebarClose(float size, RC_Color color);

#

Desktop-only, and not web no-ops like the widgets: rcTitlebar / rcWindowControls stay DECLARED on web,

but under __EMSCRIPTEN__ "icons/rc_icons.h" skips these three headers, so rayclay.h does not declare them

at all and a web build that names one FAILS TO COMPILE. (gcc -E -P: 3 declarations desktop, 0 on web.)

Packaged extra#

(opt-in: the logo is not compiled in until you include its generated header)

void rcIconRayClayLogo(float size);

# The full-colour RayClay logo (bakes its own palette; no color arg)

The artwork is a GENERATED header, not part of rayclay.h. Building the examples tree, #include "icons/rc_icons_rayclay_logo.h" resolves already.

Vendoring rayclay.h into your own project: copy BOTH rc_icons_rayclay_logo.h AND rc_icons_common.h out of examples/assets/icons/, and include rayclay.h FIRST.

Both parts are load-bearing: the generated header includes rc_icons_common.h by name, and that file includes rayclay.h back, so logo-header-first

gives "implicit declaration of rcIconDrawRoundLine". Every symbol the artwork needs (rcIconDraw*) is already in the amalgamated header.

Custom icon geometry#

(you name these only if you hand-write an icon instead of generating one)

RC_IconPoint

# One point in the SVG's viewBox space; the library scales it to the element's bounds

RC_ICON_MAX_PTS

# Most points one generated polyline or polygon may carry (128) See api notes: RC_IconPoint

A hand-written icon is TWO functions, and ex11 generates both for you#

an RC_CustomDrawCallback named rcDrawIcon<Name> that draws the geometry, and an entry point rcIcon<Name>(size, color) whose whole body is one rcIconEmit call.

You call rcIcon<Name>. rcDrawIcon<Name> is the callback it passes - static inline beside it in the same generated header, so it is yours to name only if you want the artwork somewhere else.

void rcIconEmit(float size, RC_Color color, RC_CustomDrawCallback draw, const void *userData);

# The entry point.

Emits a fixed square element (size x size) whose payload runs draw during rcRender. Header-inline.

size is multiplied by rcUnzoomedScale() FIRST, then clamped to >= 1.0

Every op below is called from INSIDE draw, never from your layout: bounds is the screen rect the callback is handed.

Geometry, radii and strokeWidth are all in the icon's own viewBox units. The scale applied is bounds.width / viewBoxSize - height never enters. Stroke ops draw a CENTRED stroke, as in SVG.

void rcIconDrawPolyline(RC_BoundingBox bounds, const RC_IconPoint *points, int pointCount, float viewBoxSize, float strokeWidth, bool closed, RC_Color color);

#

Stroked path: round join at every vertex, round caps; closed also strokes last→first. Needs >= 2 points

void rcIconDrawFilledPolygon(RC_BoundingBox bounds, const RC_IconPoint *points, int pointCount, float viewBoxSize, RC_Color color);

# Solid fill, convex OR concave (ear-clipped). Needs >= 3 points

void rcIconDrawFilledCircle(RC_BoundingBox bounds, float cx, float cy, float radius, float viewBoxSize, RC_Color color);

# Solid disc

void rcIconDrawFilledEllipse(RC_BoundingBox bounds, float cx, float cy, float rx, float ry, float viewBoxSize, RC_Color color);

# Solid AXIS-ALIGNED ellipse - rx and ry only, no rotation

void rcIconDrawRoundLine(RC_BoundingBox bounds, float x0, float y0, float x1, float y1, float viewBoxSize, float strokeWidth, RC_Color color);

# One round-capped segment

void rcIconDrawCircleStroke(RC_BoundingBox bounds, float cx, float cy, float radius, float viewBoxSize, float strokeWidth, RC_Color color);

# Stroked circle

void rcIconDrawRoundedRectStroke(RC_BoundingBox bounds, float x, float y, float width, float height, float radius, float viewBoxSize, float strokeWidth, RC_Color color);

# Stroked rounded rect; radius 0 keeps mitred corners

Both points ops keep the first RC_ICON_MAX_PTS (128) points and warn once; the rest are not drawn. Below the minimum point count the call draws nothing.