Created
January 1, 2025 13:55
-
-
Save keynmol/642af3a015d3aa05cefdadfb8635f5d3 to your computer and use it in GitHub Desktop.
Scala Native bindings for Clay - https://github.com/nicbarker/clay
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #include <string.h> | |
| void __sn_wrap_clay_Clay_CreateArenaWithCapacityAndMemory(uint32_t capacity, void * offset, Clay_Arena *____return) { | |
| Clay_Arena ____ret = Clay_CreateArenaWithCapacityAndMemory(capacity, offset); | |
| memcpy(____return, &____ret, sizeof(Clay_Arena)); | |
| } | |
| void __sn_wrap_clay_Clay_EndLayout(Clay_RenderCommandArray *____return) { | |
| Clay_RenderCommandArray ____ret = Clay_EndLayout(); | |
| memcpy(____return, &____ret, sizeof(Clay_RenderCommandArray)); | |
| } | |
| void __sn_wrap_clay_Clay_GetElementId(Clay_String *idString, Clay_ElementId *____return) { | |
| Clay_ElementId ____ret = Clay_GetElementId(*idString); | |
| memcpy(____return, &____ret, sizeof(Clay_ElementId)); | |
| } | |
| void __sn_wrap_clay_Clay_GetElementIdWithIndex(Clay_String *idString, uint32_t index, Clay_ElementId *____return) { | |
| Clay_ElementId ____ret = Clay_GetElementIdWithIndex(*idString, index); | |
| memcpy(____return, &____ret, sizeof(Clay_ElementId)); | |
| } | |
| void __sn_wrap_clay_Clay_GetScrollContainerData(Clay_ElementId *id, Clay_ScrollContainerData *____return) { | |
| Clay_ScrollContainerData ____ret = Clay_GetScrollContainerData(*id); | |
| memcpy(____return, &____ret, sizeof(Clay_ScrollContainerData)); | |
| } | |
| void __sn_wrap_clay_Clay_Initialize(Clay_Arena *arena, Clay_Dimensions *layoutDimensions, Clay_ErrorHandler *errorHandler) { | |
| Clay_Initialize(*arena, *layoutDimensions, *errorHandler); | |
| }; | |
| _Bool __sn_wrap_clay_Clay_PointerOver(Clay_ElementId *elementId) { | |
| return Clay_PointerOver(*elementId); | |
| }; | |
| void __sn_wrap_clay_Clay_SetLayoutDimensions(Clay_Dimensions *dimensions) { | |
| Clay_SetLayoutDimensions(*dimensions); | |
| }; | |
| void __sn_wrap_clay_Clay_SetPointerState(Clay_Vector2 *position, _Bool pointerDown) { | |
| Clay_SetPointerState(*position, pointerDown); | |
| }; | |
| void __sn_wrap_clay_Clay_UpdateScrollContainers(_Bool enableDragScrolling, Clay_Vector2 *scrollDelta, float deltaTime) { | |
| Clay_UpdateScrollContainers(enableDragScrolling, *scrollDelta, deltaTime); | |
| }; | |
| void __sn_wrap_clay_Clay__AttachId(Clay_ElementId *id) { | |
| Clay__AttachId(*id); | |
| }; | |
| void __sn_wrap_clay_Clay__HashString(Clay_String *key, uint32_t offset, uint32_t seed, Clay_ElementId *____return) { | |
| Clay_ElementId ____ret = Clay__HashString(*key, offset, seed); | |
| memcpy(____return, &____ret, sizeof(Clay_ElementId)); | |
| } | |
| void __sn_wrap_clay_Clay__OpenTextElement(Clay_String *text, Clay_TextElementConfig * textConfig) { | |
| Clay__OpenTextElement(*text, textConfig); | |
| }; | |
| Clay_BorderElementConfig * __sn_wrap_clay_Clay__StoreBorderElementConfig(Clay_BorderElementConfig *config) { | |
| return Clay__StoreBorderElementConfig(*config); | |
| }; | |
| Clay_CustomElementConfig * __sn_wrap_clay_Clay__StoreCustomElementConfig(Clay_CustomElementConfig *config) { | |
| return Clay__StoreCustomElementConfig(*config); | |
| }; | |
| Clay_FloatingElementConfig * __sn_wrap_clay_Clay__StoreFloatingElementConfig(Clay_FloatingElementConfig *config) { | |
| return Clay__StoreFloatingElementConfig(*config); | |
| }; | |
| Clay_ImageElementConfig * __sn_wrap_clay_Clay__StoreImageElementConfig(Clay_ImageElementConfig *config) { | |
| return Clay__StoreImageElementConfig(*config); | |
| }; | |
| Clay_LayoutConfig * __sn_wrap_clay_Clay__StoreLayoutConfig(Clay_LayoutConfig *config) { | |
| return Clay__StoreLayoutConfig(*config); | |
| }; | |
| Clay_RectangleElementConfig * __sn_wrap_clay_Clay__StoreRectangleElementConfig(Clay_RectangleElementConfig *config) { | |
| return Clay__StoreRectangleElementConfig(*config); | |
| }; | |
| Clay_ScrollElementConfig * __sn_wrap_clay_Clay__StoreScrollElementConfig(Clay_ScrollElementConfig *config) { | |
| return Clay__StoreScrollElementConfig(*config); | |
| }; | |
| Clay_TextElementConfig * __sn_wrap_clay_Clay__StoreTextElementConfig(Clay_TextElementConfig *config) { | |
| return Clay__StoreTextElementConfig(*config); | |
| }; | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| package clay | |
| import _root_.scala.scalanative.unsafe.* | |
| import _root_.scala.scalanative.unsigned.* | |
| import _root_.scala.scalanative.libc.* | |
| import _root_.scala.scalanative.* | |
| object predef: | |
| private[clay] trait _BindgenEnumCUnsignedChar[T](using eq: T =:= CUnsignedChar): | |
| given Tag[T] = Tag.UByte.asInstanceOf[Tag[T]] | |
| extension (inline t: T) | |
| inline def value: CUnsignedChar = eq.apply(t) | |
| private[clay] trait _BindgenEnumCUnsignedInt[T](using eq: T =:= CUnsignedInt): | |
| given Tag[T] = Tag.UInt.asInstanceOf[Tag[T]] | |
| extension (inline t: T) | |
| inline def value: CUnsignedInt = eq.apply(t) | |
| inline def int: CInt = eq.apply(t).toInt | |
| inline def uint: CUnsignedInt = eq.apply(t) | |
| object enumerations: | |
| import predef.* | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ErrorType = CUnsignedInt | |
| object Clay_ErrorType extends _BindgenEnumCUnsignedInt[Clay_ErrorType]: | |
| given _tag: Tag[Clay_ErrorType] = Tag.UInt | |
| inline def define(inline a: Long): Clay_ErrorType = a.toUInt | |
| val CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED = define(0) | |
| val CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED = define(1) | |
| val CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED = define(2) | |
| val CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED = define(3) | |
| val CLAY_ERROR_TYPE_DUPLICATE_ID = define(4) | |
| val CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND = define(5) | |
| val CLAY_ERROR_TYPE_INTERNAL_ERROR = define(6) | |
| inline def getName(inline value: Clay_ErrorType): Option[String] = | |
| inline value match | |
| case CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED => Some("CLAY_ERROR_TYPE_TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED") | |
| case CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED => Some("CLAY_ERROR_TYPE_ARENA_CAPACITY_EXCEEDED") | |
| case CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED => Some("CLAY_ERROR_TYPE_ELEMENTS_CAPACITY_EXCEEDED") | |
| case CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED => Some("CLAY_ERROR_TYPE_TEXT_MEASUREMENT_CAPACITY_EXCEEDED") | |
| case CLAY_ERROR_TYPE_DUPLICATE_ID => Some("CLAY_ERROR_TYPE_DUPLICATE_ID") | |
| case CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND => Some("CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND") | |
| case CLAY_ERROR_TYPE_INTERNAL_ERROR => Some("CLAY_ERROR_TYPE_INTERNAL_ERROR") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_ErrorType) | |
| inline def &(b: Clay_ErrorType): Clay_ErrorType = a & b | |
| inline def |(b: Clay_ErrorType): Clay_ErrorType = a | b | |
| inline def is(b: Clay_ErrorType): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_FloatingAttachPointType = CUnsignedChar | |
| object Clay_FloatingAttachPointType extends _BindgenEnumCUnsignedChar[Clay_FloatingAttachPointType]: | |
| given _tag: Tag[Clay_FloatingAttachPointType] = Tag.UByte | |
| inline def define(inline a: Long): Clay_FloatingAttachPointType = a.toUByte | |
| val CLAY_ATTACH_POINT_LEFT_TOP = define(0) | |
| val CLAY_ATTACH_POINT_LEFT_CENTER = define(1) | |
| val CLAY_ATTACH_POINT_LEFT_BOTTOM = define(2) | |
| val CLAY_ATTACH_POINT_CENTER_TOP = define(3) | |
| val CLAY_ATTACH_POINT_CENTER_CENTER = define(4) | |
| val CLAY_ATTACH_POINT_CENTER_BOTTOM = define(5) | |
| val CLAY_ATTACH_POINT_RIGHT_TOP = define(6) | |
| val CLAY_ATTACH_POINT_RIGHT_CENTER = define(7) | |
| val CLAY_ATTACH_POINT_RIGHT_BOTTOM = define(8) | |
| inline def getName(inline value: Clay_FloatingAttachPointType): Option[String] = | |
| inline value match | |
| case CLAY_ATTACH_POINT_LEFT_TOP => Some("CLAY_ATTACH_POINT_LEFT_TOP") | |
| case CLAY_ATTACH_POINT_LEFT_CENTER => Some("CLAY_ATTACH_POINT_LEFT_CENTER") | |
| case CLAY_ATTACH_POINT_LEFT_BOTTOM => Some("CLAY_ATTACH_POINT_LEFT_BOTTOM") | |
| case CLAY_ATTACH_POINT_CENTER_TOP => Some("CLAY_ATTACH_POINT_CENTER_TOP") | |
| case CLAY_ATTACH_POINT_CENTER_CENTER => Some("CLAY_ATTACH_POINT_CENTER_CENTER") | |
| case CLAY_ATTACH_POINT_CENTER_BOTTOM => Some("CLAY_ATTACH_POINT_CENTER_BOTTOM") | |
| case CLAY_ATTACH_POINT_RIGHT_TOP => Some("CLAY_ATTACH_POINT_RIGHT_TOP") | |
| case CLAY_ATTACH_POINT_RIGHT_CENTER => Some("CLAY_ATTACH_POINT_RIGHT_CENTER") | |
| case CLAY_ATTACH_POINT_RIGHT_BOTTOM => Some("CLAY_ATTACH_POINT_RIGHT_BOTTOM") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_FloatingAttachPointType) | |
| inline def &(b: Clay_FloatingAttachPointType): Clay_FloatingAttachPointType = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay_FloatingAttachPointType): Clay_FloatingAttachPointType = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay_FloatingAttachPointType): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_LayoutAlignmentX = CUnsignedChar | |
| object Clay_LayoutAlignmentX extends _BindgenEnumCUnsignedChar[Clay_LayoutAlignmentX]: | |
| given _tag: Tag[Clay_LayoutAlignmentX] = Tag.UByte | |
| inline def define(inline a: Long): Clay_LayoutAlignmentX = a.toUByte | |
| val CLAY_ALIGN_X_LEFT = define(0) | |
| val CLAY_ALIGN_X_RIGHT = define(1) | |
| val CLAY_ALIGN_X_CENTER = define(2) | |
| inline def getName(inline value: Clay_LayoutAlignmentX): Option[String] = | |
| inline value match | |
| case CLAY_ALIGN_X_LEFT => Some("CLAY_ALIGN_X_LEFT") | |
| case CLAY_ALIGN_X_RIGHT => Some("CLAY_ALIGN_X_RIGHT") | |
| case CLAY_ALIGN_X_CENTER => Some("CLAY_ALIGN_X_CENTER") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_LayoutAlignmentX) | |
| inline def &(b: Clay_LayoutAlignmentX): Clay_LayoutAlignmentX = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay_LayoutAlignmentX): Clay_LayoutAlignmentX = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay_LayoutAlignmentX): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_LayoutAlignmentY = CUnsignedChar | |
| object Clay_LayoutAlignmentY extends _BindgenEnumCUnsignedChar[Clay_LayoutAlignmentY]: | |
| given _tag: Tag[Clay_LayoutAlignmentY] = Tag.UByte | |
| inline def define(inline a: Long): Clay_LayoutAlignmentY = a.toUByte | |
| val CLAY_ALIGN_Y_TOP = define(0) | |
| val CLAY_ALIGN_Y_BOTTOM = define(1) | |
| val CLAY_ALIGN_Y_CENTER = define(2) | |
| inline def getName(inline value: Clay_LayoutAlignmentY): Option[String] = | |
| inline value match | |
| case CLAY_ALIGN_Y_TOP => Some("CLAY_ALIGN_Y_TOP") | |
| case CLAY_ALIGN_Y_BOTTOM => Some("CLAY_ALIGN_Y_BOTTOM") | |
| case CLAY_ALIGN_Y_CENTER => Some("CLAY_ALIGN_Y_CENTER") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_LayoutAlignmentY) | |
| inline def &(b: Clay_LayoutAlignmentY): Clay_LayoutAlignmentY = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay_LayoutAlignmentY): Clay_LayoutAlignmentY = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay_LayoutAlignmentY): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_LayoutDirection = CUnsignedChar | |
| object Clay_LayoutDirection extends _BindgenEnumCUnsignedChar[Clay_LayoutDirection]: | |
| given _tag: Tag[Clay_LayoutDirection] = Tag.UByte | |
| inline def define(inline a: Long): Clay_LayoutDirection = a.toUByte | |
| val CLAY_LEFT_TO_RIGHT = define(0) | |
| val CLAY_TOP_TO_BOTTOM = define(1) | |
| inline def getName(inline value: Clay_LayoutDirection): Option[String] = | |
| inline value match | |
| case CLAY_LEFT_TO_RIGHT => Some("CLAY_LEFT_TO_RIGHT") | |
| case CLAY_TOP_TO_BOTTOM => Some("CLAY_TOP_TO_BOTTOM") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_LayoutDirection) | |
| inline def &(b: Clay_LayoutDirection): Clay_LayoutDirection = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay_LayoutDirection): Clay_LayoutDirection = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay_LayoutDirection): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_PointerCaptureMode = CUnsignedInt | |
| object Clay_PointerCaptureMode extends _BindgenEnumCUnsignedInt[Clay_PointerCaptureMode]: | |
| given _tag: Tag[Clay_PointerCaptureMode] = Tag.UInt | |
| inline def define(inline a: Long): Clay_PointerCaptureMode = a.toUInt | |
| val CLAY_POINTER_CAPTURE_MODE_CAPTURE = define(0) | |
| val CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH = define(1) | |
| inline def getName(inline value: Clay_PointerCaptureMode): Option[String] = | |
| inline value match | |
| case CLAY_POINTER_CAPTURE_MODE_CAPTURE => Some("CLAY_POINTER_CAPTURE_MODE_CAPTURE") | |
| case CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH => Some("CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_PointerCaptureMode) | |
| inline def &(b: Clay_PointerCaptureMode): Clay_PointerCaptureMode = a & b | |
| inline def |(b: Clay_PointerCaptureMode): Clay_PointerCaptureMode = a | b | |
| inline def is(b: Clay_PointerCaptureMode): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_PointerDataInteractionState = CUnsignedInt | |
| object Clay_PointerDataInteractionState extends _BindgenEnumCUnsignedInt[Clay_PointerDataInteractionState]: | |
| given _tag: Tag[Clay_PointerDataInteractionState] = Tag.UInt | |
| inline def define(inline a: Long): Clay_PointerDataInteractionState = a.toUInt | |
| val CLAY_POINTER_DATA_PRESSED_THIS_FRAME = define(0) | |
| val CLAY_POINTER_DATA_PRESSED = define(1) | |
| val CLAY_POINTER_DATA_RELEASED_THIS_FRAME = define(2) | |
| val CLAY_POINTER_DATA_RELEASED = define(3) | |
| inline def getName(inline value: Clay_PointerDataInteractionState): Option[String] = | |
| inline value match | |
| case CLAY_POINTER_DATA_PRESSED_THIS_FRAME => Some("CLAY_POINTER_DATA_PRESSED_THIS_FRAME") | |
| case CLAY_POINTER_DATA_PRESSED => Some("CLAY_POINTER_DATA_PRESSED") | |
| case CLAY_POINTER_DATA_RELEASED_THIS_FRAME => Some("CLAY_POINTER_DATA_RELEASED_THIS_FRAME") | |
| case CLAY_POINTER_DATA_RELEASED => Some("CLAY_POINTER_DATA_RELEASED") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_PointerDataInteractionState) | |
| inline def &(b: Clay_PointerDataInteractionState): Clay_PointerDataInteractionState = a & b | |
| inline def |(b: Clay_PointerDataInteractionState): Clay_PointerDataInteractionState = a | b | |
| inline def is(b: Clay_PointerDataInteractionState): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_RenderCommandType = CUnsignedInt | |
| object Clay_RenderCommandType extends _BindgenEnumCUnsignedInt[Clay_RenderCommandType]: | |
| given _tag: Tag[Clay_RenderCommandType] = Tag.UInt | |
| inline def define(inline a: Long): Clay_RenderCommandType = a.toUInt | |
| val CLAY_RENDER_COMMAND_TYPE_NONE = define(0) | |
| val CLAY_RENDER_COMMAND_TYPE_RECTANGLE = define(1) | |
| val CLAY_RENDER_COMMAND_TYPE_BORDER = define(2) | |
| val CLAY_RENDER_COMMAND_TYPE_TEXT = define(3) | |
| val CLAY_RENDER_COMMAND_TYPE_IMAGE = define(4) | |
| val CLAY_RENDER_COMMAND_TYPE_SCISSOR_START = define(5) | |
| val CLAY_RENDER_COMMAND_TYPE_SCISSOR_END = define(6) | |
| val CLAY_RENDER_COMMAND_TYPE_CUSTOM = define(7) | |
| inline def getName(inline value: Clay_RenderCommandType): Option[String] = | |
| inline value match | |
| case CLAY_RENDER_COMMAND_TYPE_NONE => Some("CLAY_RENDER_COMMAND_TYPE_NONE") | |
| case CLAY_RENDER_COMMAND_TYPE_RECTANGLE => Some("CLAY_RENDER_COMMAND_TYPE_RECTANGLE") | |
| case CLAY_RENDER_COMMAND_TYPE_BORDER => Some("CLAY_RENDER_COMMAND_TYPE_BORDER") | |
| case CLAY_RENDER_COMMAND_TYPE_TEXT => Some("CLAY_RENDER_COMMAND_TYPE_TEXT") | |
| case CLAY_RENDER_COMMAND_TYPE_IMAGE => Some("CLAY_RENDER_COMMAND_TYPE_IMAGE") | |
| case CLAY_RENDER_COMMAND_TYPE_SCISSOR_START => Some("CLAY_RENDER_COMMAND_TYPE_SCISSOR_START") | |
| case CLAY_RENDER_COMMAND_TYPE_SCISSOR_END => Some("CLAY_RENDER_COMMAND_TYPE_SCISSOR_END") | |
| case CLAY_RENDER_COMMAND_TYPE_CUSTOM => Some("CLAY_RENDER_COMMAND_TYPE_CUSTOM") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_RenderCommandType) | |
| inline def &(b: Clay_RenderCommandType): Clay_RenderCommandType = a & b | |
| inline def |(b: Clay_RenderCommandType): Clay_RenderCommandType = a | b | |
| inline def is(b: Clay_RenderCommandType): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_TextElementConfigWrapMode = CUnsignedInt | |
| object Clay_TextElementConfigWrapMode extends _BindgenEnumCUnsignedInt[Clay_TextElementConfigWrapMode]: | |
| given _tag: Tag[Clay_TextElementConfigWrapMode] = Tag.UInt | |
| inline def define(inline a: Long): Clay_TextElementConfigWrapMode = a.toUInt | |
| val CLAY_TEXT_WRAP_WORDS = define(0) | |
| val CLAY_TEXT_WRAP_NEWLINES = define(1) | |
| val CLAY_TEXT_WRAP_NONE = define(2) | |
| inline def getName(inline value: Clay_TextElementConfigWrapMode): Option[String] = | |
| inline value match | |
| case CLAY_TEXT_WRAP_WORDS => Some("CLAY_TEXT_WRAP_WORDS") | |
| case CLAY_TEXT_WRAP_NEWLINES => Some("CLAY_TEXT_WRAP_NEWLINES") | |
| case CLAY_TEXT_WRAP_NONE => Some("CLAY_TEXT_WRAP_NONE") | |
| case _ => _root_.scala.None | |
| extension (a: Clay_TextElementConfigWrapMode) | |
| inline def &(b: Clay_TextElementConfigWrapMode): Clay_TextElementConfigWrapMode = a & b | |
| inline def |(b: Clay_TextElementConfigWrapMode): Clay_TextElementConfigWrapMode = a | b | |
| inline def is(b: Clay_TextElementConfigWrapMode): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay__ElementConfigType = CUnsignedChar | |
| object Clay__ElementConfigType extends _BindgenEnumCUnsignedChar[Clay__ElementConfigType]: | |
| given _tag: Tag[Clay__ElementConfigType] = Tag.UByte | |
| inline def define(inline a: Long): Clay__ElementConfigType = a.toUByte | |
| val CLAY__ELEMENT_CONFIG_TYPE_NONE = define(0) | |
| val CLAY__ELEMENT_CONFIG_TYPE_RECTANGLE = define(1) | |
| val CLAY__ELEMENT_CONFIG_TYPE_BORDER_CONTAINER = define(2) | |
| val CLAY__ELEMENT_CONFIG_TYPE_FLOATING_CONTAINER = define(4) | |
| val CLAY__ELEMENT_CONFIG_TYPE_SCROLL_CONTAINER = define(8) | |
| val CLAY__ELEMENT_CONFIG_TYPE_IMAGE = define(16) | |
| val CLAY__ELEMENT_CONFIG_TYPE_TEXT = define(32) | |
| val CLAY__ELEMENT_CONFIG_TYPE_CUSTOM = define(64) | |
| inline def getName(inline value: Clay__ElementConfigType): Option[String] = | |
| inline value match | |
| case CLAY__ELEMENT_CONFIG_TYPE_NONE => Some("CLAY__ELEMENT_CONFIG_TYPE_NONE") | |
| case CLAY__ELEMENT_CONFIG_TYPE_RECTANGLE => Some("CLAY__ELEMENT_CONFIG_TYPE_RECTANGLE") | |
| case CLAY__ELEMENT_CONFIG_TYPE_BORDER_CONTAINER => Some("CLAY__ELEMENT_CONFIG_TYPE_BORDER_CONTAINER") | |
| case CLAY__ELEMENT_CONFIG_TYPE_FLOATING_CONTAINER => Some("CLAY__ELEMENT_CONFIG_TYPE_FLOATING_CONTAINER") | |
| case CLAY__ELEMENT_CONFIG_TYPE_SCROLL_CONTAINER => Some("CLAY__ELEMENT_CONFIG_TYPE_SCROLL_CONTAINER") | |
| case CLAY__ELEMENT_CONFIG_TYPE_IMAGE => Some("CLAY__ELEMENT_CONFIG_TYPE_IMAGE") | |
| case CLAY__ELEMENT_CONFIG_TYPE_TEXT => Some("CLAY__ELEMENT_CONFIG_TYPE_TEXT") | |
| case CLAY__ELEMENT_CONFIG_TYPE_CUSTOM => Some("CLAY__ELEMENT_CONFIG_TYPE_CUSTOM") | |
| case _ => _root_.scala.None | |
| extension (a: Clay__ElementConfigType) | |
| inline def &(b: Clay__ElementConfigType): Clay__ElementConfigType = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay__ElementConfigType): Clay__ElementConfigType = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay__ElementConfigType): Boolean = (a & b) == b | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay__SizingType = CUnsignedChar | |
| object Clay__SizingType extends _BindgenEnumCUnsignedChar[Clay__SizingType]: | |
| given _tag: Tag[Clay__SizingType] = Tag.UByte | |
| inline def define(inline a: Long): Clay__SizingType = a.toUByte | |
| val CLAY__SIZING_TYPE_FIT = define(0) | |
| val CLAY__SIZING_TYPE_GROW = define(1) | |
| val CLAY__SIZING_TYPE_PERCENT = define(2) | |
| val CLAY__SIZING_TYPE_FIXED = define(3) | |
| inline def getName(inline value: Clay__SizingType): Option[String] = | |
| inline value match | |
| case CLAY__SIZING_TYPE_FIT => Some("CLAY__SIZING_TYPE_FIT") | |
| case CLAY__SIZING_TYPE_GROW => Some("CLAY__SIZING_TYPE_GROW") | |
| case CLAY__SIZING_TYPE_PERCENT => Some("CLAY__SIZING_TYPE_PERCENT") | |
| case CLAY__SIZING_TYPE_FIXED => Some("CLAY__SIZING_TYPE_FIXED") | |
| case _ => _root_.scala.None | |
| extension (a: Clay__SizingType) | |
| inline def &(b: Clay__SizingType): Clay__SizingType = ((a & b) & 0xff.toUInt).toUByte | |
| inline def |(b: Clay__SizingType): Clay__SizingType = ((a | b) & 0xff.toUInt).toUByte | |
| inline def is(b: Clay__SizingType): Boolean = (a & b) == b | |
| object aliases: | |
| import _root_.clay.enumerations.* | |
| import _root_.clay.predef.* | |
| import _root_.clay.aliases.* | |
| import _root_.clay.structs.* | |
| import _root_.clay.unions.* | |
| /** | |
| * [bindgen] header: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/arm/_types.h | |
| */ | |
| opaque type __darwin_intptr_t = CLongInt | |
| object __darwin_intptr_t: | |
| given _tag: Tag[__darwin_intptr_t] = Tag.Size | |
| inline def apply(inline o: CLongInt): __darwin_intptr_t = o | |
| extension (v: __darwin_intptr_t) | |
| inline def value: CLongInt = v | |
| type int32_t = scala.scalanative.unsafe.CInt | |
| object int32_t: | |
| val _tag: Tag[int32_t] = summon[Tag[scala.scalanative.unsafe.CInt]] | |
| inline def apply(inline o: scala.scalanative.unsafe.CInt): int32_t = o | |
| extension (v: int32_t) | |
| inline def value: scala.scalanative.unsafe.CInt = v | |
| /** | |
| * [bindgen] header: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/sys/_types/_intptr_t.h | |
| */ | |
| type intptr_t = __darwin_intptr_t | |
| object intptr_t: | |
| given _tag: Tag[intptr_t] = __darwin_intptr_t._tag | |
| inline def apply(inline o: __darwin_intptr_t): intptr_t = o | |
| extension (v: intptr_t) | |
| inline def value: __darwin_intptr_t = v | |
| type size_t = libc.stddef.size_t | |
| object size_t: | |
| val _tag: Tag[size_t] = summon[Tag[libc.stddef.size_t]] | |
| inline def apply(inline o: libc.stddef.size_t): size_t = o | |
| extension (v: size_t) | |
| inline def value: libc.stddef.size_t = v | |
| type uint16_t = scala.scalanative.unsigned.UShort | |
| object uint16_t: | |
| val _tag: Tag[uint16_t] = summon[Tag[scala.scalanative.unsigned.UShort]] | |
| inline def apply(inline o: scala.scalanative.unsigned.UShort): uint16_t = o | |
| extension (v: uint16_t) | |
| inline def value: scala.scalanative.unsigned.UShort = v | |
| type uint32_t = scala.scalanative.unsigned.UInt | |
| object uint32_t: | |
| val _tag: Tag[uint32_t] = summon[Tag[scala.scalanative.unsigned.UInt]] | |
| inline def apply(inline o: scala.scalanative.unsigned.UInt): uint32_t = o | |
| extension (v: uint32_t) | |
| inline def value: scala.scalanative.unsigned.UInt = v | |
| type uint8_t = scala.scalanative.unsigned.UByte | |
| object uint8_t: | |
| val _tag: Tag[uint8_t] = summon[Tag[scala.scalanative.unsigned.UByte]] | |
| inline def apply(inline o: scala.scalanative.unsigned.UByte): uint8_t = o | |
| extension (v: uint8_t) | |
| inline def value: scala.scalanative.unsigned.UByte = v | |
| /** | |
| * [bindgen] header: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/sys/_types/_uintptr_t.h | |
| */ | |
| opaque type uintptr_t = CUnsignedLongInt | |
| object uintptr_t: | |
| given _tag: Tag[uintptr_t] = Tag.USize | |
| inline def apply(inline o: CUnsignedLongInt): uintptr_t = o | |
| extension (v: uintptr_t) | |
| inline def value: CUnsignedLongInt = v | |
| object structs: | |
| import _root_.clay.enumerations.* | |
| import _root_.clay.predef.* | |
| import _root_.clay.aliases.* | |
| import _root_.clay.structs.* | |
| import _root_.clay.unions.* | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Arena = CStruct3[uintptr_t, size_t, CString] | |
| object Clay_Arena: | |
| given _tag: Tag[Clay_Arena] = Tag.materializeCStruct3Tag[uintptr_t, size_t, CString] | |
| def apply()(using Zone): Ptr[Clay_Arena] = scala.scalanative.unsafe.alloc[Clay_Arena](1) | |
| def apply(nextAllocation : uintptr_t, capacity : size_t, memory : CString)(using Zone): Ptr[Clay_Arena] = | |
| val ____ptr = apply() | |
| (!____ptr).nextAllocation = nextAllocation | |
| (!____ptr).capacity = capacity | |
| (!____ptr).memory = memory | |
| ____ptr | |
| extension (struct: Clay_Arena) | |
| def nextAllocation : uintptr_t = struct._1 | |
| def nextAllocation_=(value: uintptr_t): Unit = !struct.at1 = value | |
| def capacity : size_t = struct._2 | |
| def capacity_=(value: size_t): Unit = !struct.at2 = value | |
| def memory : CString = struct._3 | |
| def memory_=(value: CString): Unit = !struct.at3 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Border = CStruct2[uint32_t, Clay_Color] | |
| object Clay_Border: | |
| given _tag: Tag[Clay_Border] = Tag.materializeCStruct2Tag[uint32_t, Clay_Color] | |
| def apply()(using Zone): Ptr[Clay_Border] = scala.scalanative.unsafe.alloc[Clay_Border](1) | |
| def apply(width : uint32_t, color : Clay_Color)(using Zone): Ptr[Clay_Border] = | |
| val ____ptr = apply() | |
| (!____ptr).width = width | |
| (!____ptr).color = color | |
| ____ptr | |
| extension (struct: Clay_Border) | |
| def width : uint32_t = struct._1 | |
| def width_=(value: uint32_t): Unit = !struct.at1 = value | |
| def color : Clay_Color = struct._2 | |
| def color_=(value: Clay_Color): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_BorderElementConfig = CStruct6[Clay_Border, Clay_Border, Clay_Border, Clay_Border, Clay_Border, Clay_CornerRadius] | |
| object Clay_BorderElementConfig: | |
| given _tag: Tag[Clay_BorderElementConfig] = Tag.materializeCStruct6Tag[Clay_Border, Clay_Border, Clay_Border, Clay_Border, Clay_Border, Clay_CornerRadius] | |
| def apply()(using Zone): Ptr[Clay_BorderElementConfig] = scala.scalanative.unsafe.alloc[Clay_BorderElementConfig](1) | |
| def apply(left : Clay_Border, right : Clay_Border, top : Clay_Border, bottom : Clay_Border, betweenChildren : Clay_Border, cornerRadius : Clay_CornerRadius)(using Zone): Ptr[Clay_BorderElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).left = left | |
| (!____ptr).right = right | |
| (!____ptr).top = top | |
| (!____ptr).bottom = bottom | |
| (!____ptr).betweenChildren = betweenChildren | |
| (!____ptr).cornerRadius = cornerRadius | |
| ____ptr | |
| extension (struct: Clay_BorderElementConfig) | |
| def left : Clay_Border = struct._1 | |
| def left_=(value: Clay_Border): Unit = !struct.at1 = value | |
| def right : Clay_Border = struct._2 | |
| def right_=(value: Clay_Border): Unit = !struct.at2 = value | |
| def top : Clay_Border = struct._3 | |
| def top_=(value: Clay_Border): Unit = !struct.at3 = value | |
| def bottom : Clay_Border = struct._4 | |
| def bottom_=(value: Clay_Border): Unit = !struct.at4 = value | |
| def betweenChildren : Clay_Border = struct._5 | |
| def betweenChildren_=(value: Clay_Border): Unit = !struct.at5 = value | |
| def cornerRadius : Clay_CornerRadius = struct._6 | |
| def cornerRadius_=(value: Clay_CornerRadius): Unit = !struct.at6 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_BoundingBox = CStruct4[Float, Float, Float, Float] | |
| object Clay_BoundingBox: | |
| given _tag: Tag[Clay_BoundingBox] = Tag.materializeCStruct4Tag[Float, Float, Float, Float] | |
| def apply()(using Zone): Ptr[Clay_BoundingBox] = scala.scalanative.unsafe.alloc[Clay_BoundingBox](1) | |
| def apply(x : Float, y : Float, width : Float, height : Float)(using Zone): Ptr[Clay_BoundingBox] = | |
| val ____ptr = apply() | |
| (!____ptr).x = x | |
| (!____ptr).y = y | |
| (!____ptr).width = width | |
| (!____ptr).height = height | |
| ____ptr | |
| extension (struct: Clay_BoundingBox) | |
| def x : Float = struct._1 | |
| def x_=(value: Float): Unit = !struct.at1 = value | |
| def y : Float = struct._2 | |
| def y_=(value: Float): Unit = !struct.at2 = value | |
| def width : Float = struct._3 | |
| def width_=(value: Float): Unit = !struct.at3 = value | |
| def height : Float = struct._4 | |
| def height_=(value: Float): Unit = !struct.at4 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ChildAlignment = CStruct2[Clay_LayoutAlignmentX, Clay_LayoutAlignmentY] | |
| object Clay_ChildAlignment: | |
| given _tag: Tag[Clay_ChildAlignment] = Tag.materializeCStruct2Tag[Clay_LayoutAlignmentX, Clay_LayoutAlignmentY] | |
| def apply()(using Zone): Ptr[Clay_ChildAlignment] = scala.scalanative.unsafe.alloc[Clay_ChildAlignment](1) | |
| def apply(x : Clay_LayoutAlignmentX, y : Clay_LayoutAlignmentY)(using Zone): Ptr[Clay_ChildAlignment] = | |
| val ____ptr = apply() | |
| (!____ptr).x = x | |
| (!____ptr).y = y | |
| ____ptr | |
| extension (struct: Clay_ChildAlignment) | |
| def x : Clay_LayoutAlignmentX = struct._1 | |
| def x_=(value: Clay_LayoutAlignmentX): Unit = !struct.at1 = value | |
| def y : Clay_LayoutAlignmentY = struct._2 | |
| def y_=(value: Clay_LayoutAlignmentY): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Color = CStruct4[Float, Float, Float, Float] | |
| object Clay_Color: | |
| given _tag: Tag[Clay_Color] = Tag.materializeCStruct4Tag[Float, Float, Float, Float] | |
| def apply()(using Zone): Ptr[Clay_Color] = scala.scalanative.unsafe.alloc[Clay_Color](1) | |
| def apply(r : Float, g : Float, b : Float, a : Float)(using Zone): Ptr[Clay_Color] = | |
| val ____ptr = apply() | |
| (!____ptr).r = r | |
| (!____ptr).g = g | |
| (!____ptr).b = b | |
| (!____ptr).a = a | |
| ____ptr | |
| extension (struct: Clay_Color) | |
| def r : Float = struct._1 | |
| def r_=(value: Float): Unit = !struct.at1 = value | |
| def g : Float = struct._2 | |
| def g_=(value: Float): Unit = !struct.at2 = value | |
| def b : Float = struct._3 | |
| def b_=(value: Float): Unit = !struct.at3 = value | |
| def a : Float = struct._4 | |
| def a_=(value: Float): Unit = !struct.at4 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_CornerRadius = CStruct4[Float, Float, Float, Float] | |
| object Clay_CornerRadius: | |
| given _tag: Tag[Clay_CornerRadius] = Tag.materializeCStruct4Tag[Float, Float, Float, Float] | |
| def apply()(using Zone): Ptr[Clay_CornerRadius] = scala.scalanative.unsafe.alloc[Clay_CornerRadius](1) | |
| def apply(topLeft : Float, topRight : Float, bottomLeft : Float, bottomRight : Float)(using Zone): Ptr[Clay_CornerRadius] = | |
| val ____ptr = apply() | |
| (!____ptr).topLeft = topLeft | |
| (!____ptr).topRight = topRight | |
| (!____ptr).bottomLeft = bottomLeft | |
| (!____ptr).bottomRight = bottomRight | |
| ____ptr | |
| extension (struct: Clay_CornerRadius) | |
| def topLeft : Float = struct._1 | |
| def topLeft_=(value: Float): Unit = !struct.at1 = value | |
| def topRight : Float = struct._2 | |
| def topRight_=(value: Float): Unit = !struct.at2 = value | |
| def bottomLeft : Float = struct._3 | |
| def bottomLeft_=(value: Float): Unit = !struct.at3 = value | |
| def bottomRight : Float = struct._4 | |
| def bottomRight_=(value: Float): Unit = !struct.at4 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_CustomElementConfig = CStruct1[Ptr[Byte]] | |
| object Clay_CustomElementConfig: | |
| given _tag: Tag[Clay_CustomElementConfig] = Tag.materializeCStruct1Tag[Ptr[Byte]] | |
| def apply()(using Zone): Ptr[Clay_CustomElementConfig] = scala.scalanative.unsafe.alloc[Clay_CustomElementConfig](1) | |
| def apply(customData : Ptr[Byte])(using Zone): Ptr[Clay_CustomElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).customData = customData | |
| ____ptr | |
| extension (struct: Clay_CustomElementConfig) | |
| def customData : Ptr[Byte] = struct._1 | |
| def customData_=(value: Ptr[Byte]): Unit = !struct.at1 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Dimensions = CStruct2[Float, Float] | |
| object Clay_Dimensions: | |
| given _tag: Tag[Clay_Dimensions] = Tag.materializeCStruct2Tag[Float, Float] | |
| def apply()(using Zone): Ptr[Clay_Dimensions] = scala.scalanative.unsafe.alloc[Clay_Dimensions](1) | |
| def apply(width : Float, height : Float)(using Zone): Ptr[Clay_Dimensions] = | |
| val ____ptr = apply() | |
| (!____ptr).width = width | |
| (!____ptr).height = height | |
| ____ptr | |
| extension (struct: Clay_Dimensions) | |
| def width : Float = struct._1 | |
| def width_=(value: Float): Unit = !struct.at1 = value | |
| def height : Float = struct._2 | |
| def height_=(value: Float): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ElementConfig = CStruct2[Clay__ElementConfigType, Clay_ElementConfigUnion] | |
| object Clay_ElementConfig: | |
| given _tag: Tag[Clay_ElementConfig] = Tag.materializeCStruct2Tag[Clay__ElementConfigType, Clay_ElementConfigUnion] | |
| def apply()(using Zone): Ptr[Clay_ElementConfig] = scala.scalanative.unsafe.alloc[Clay_ElementConfig](1) | |
| def apply(`type` : Clay__ElementConfigType, config : Clay_ElementConfigUnion)(using Zone): Ptr[Clay_ElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).`type` = `type` | |
| (!____ptr).config = config | |
| ____ptr | |
| extension (struct: Clay_ElementConfig) | |
| def `type` : Clay__ElementConfigType = struct._1 | |
| def type_=(value: Clay__ElementConfigType): Unit = !struct.at1 = value | |
| def config : Clay_ElementConfigUnion = struct._2 | |
| def config_=(value: Clay_ElementConfigUnion): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ElementId = CStruct4[uint32_t, uint32_t, uint32_t, Clay_String] | |
| object Clay_ElementId: | |
| given _tag: Tag[Clay_ElementId] = Tag.materializeCStruct4Tag[uint32_t, uint32_t, uint32_t, Clay_String] | |
| def apply()(using Zone): Ptr[Clay_ElementId] = scala.scalanative.unsafe.alloc[Clay_ElementId](1) | |
| def apply(id : uint32_t, offset : uint32_t, baseId : uint32_t, stringId : Clay_String)(using Zone): Ptr[Clay_ElementId] = | |
| val ____ptr = apply() | |
| (!____ptr).id = id | |
| (!____ptr).offset = offset | |
| (!____ptr).baseId = baseId | |
| (!____ptr).stringId = stringId | |
| ____ptr | |
| extension (struct: Clay_ElementId) | |
| def id : uint32_t = struct._1 | |
| def id_=(value: uint32_t): Unit = !struct.at1 = value | |
| def offset : uint32_t = struct._2 | |
| def offset_=(value: uint32_t): Unit = !struct.at2 = value | |
| def baseId : uint32_t = struct._3 | |
| def baseId_=(value: uint32_t): Unit = !struct.at3 = value | |
| def stringId : Clay_String = struct._4 | |
| def stringId_=(value: Clay_String): Unit = !struct.at4 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ErrorData = CStruct3[Clay_ErrorType, Clay_String, uintptr_t] | |
| object Clay_ErrorData: | |
| given _tag: Tag[Clay_ErrorData] = Tag.materializeCStruct3Tag[Clay_ErrorType, Clay_String, uintptr_t] | |
| def apply()(using Zone): Ptr[Clay_ErrorData] = scala.scalanative.unsafe.alloc[Clay_ErrorData](1) | |
| def apply(errorType : Clay_ErrorType, errorText : Clay_String, userData : uintptr_t)(using Zone): Ptr[Clay_ErrorData] = | |
| val ____ptr = apply() | |
| (!____ptr).errorType = errorType | |
| (!____ptr).errorText = errorText | |
| (!____ptr).userData = userData | |
| ____ptr | |
| extension (struct: Clay_ErrorData) | |
| def errorType : Clay_ErrorType = struct._1 | |
| def errorType_=(value: Clay_ErrorType): Unit = !struct.at1 = value | |
| def errorText : Clay_String = struct._2 | |
| def errorText_=(value: Clay_String): Unit = !struct.at2 = value | |
| def userData : uintptr_t = struct._3 | |
| def userData_=(value: uintptr_t): Unit = !struct.at3 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ErrorHandler = CStruct2[CFuncPtr1[Clay_ErrorData, Unit], uintptr_t] | |
| object Clay_ErrorHandler: | |
| given _tag: Tag[Clay_ErrorHandler] = Tag.materializeCStruct2Tag[CFuncPtr1[Clay_ErrorData, Unit], uintptr_t] | |
| def apply()(using Zone): Ptr[Clay_ErrorHandler] = scala.scalanative.unsafe.alloc[Clay_ErrorHandler](1) | |
| def apply(errorHandlerFunction : CFuncPtr1[Clay_ErrorData, Unit], userData : uintptr_t)(using Zone): Ptr[Clay_ErrorHandler] = | |
| val ____ptr = apply() | |
| (!____ptr).errorHandlerFunction = errorHandlerFunction | |
| (!____ptr).userData = userData | |
| ____ptr | |
| extension (struct: Clay_ErrorHandler) | |
| def errorHandlerFunction : CFuncPtr1[Clay_ErrorData, Unit] = struct._1 | |
| def errorHandlerFunction_=(value: CFuncPtr1[Clay_ErrorData, Unit]): Unit = !struct.at1 = value | |
| def userData : uintptr_t = struct._2 | |
| def userData_=(value: uintptr_t): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_FloatingAttachPoints = CStruct2[Clay_FloatingAttachPointType, Clay_FloatingAttachPointType] | |
| object Clay_FloatingAttachPoints: | |
| given _tag: Tag[Clay_FloatingAttachPoints] = Tag.materializeCStruct2Tag[Clay_FloatingAttachPointType, Clay_FloatingAttachPointType] | |
| def apply()(using Zone): Ptr[Clay_FloatingAttachPoints] = scala.scalanative.unsafe.alloc[Clay_FloatingAttachPoints](1) | |
| def apply(element : Clay_FloatingAttachPointType, parent : Clay_FloatingAttachPointType)(using Zone): Ptr[Clay_FloatingAttachPoints] = | |
| val ____ptr = apply() | |
| (!____ptr).element = element | |
| (!____ptr).parent = parent | |
| ____ptr | |
| extension (struct: Clay_FloatingAttachPoints) | |
| def element : Clay_FloatingAttachPointType = struct._1 | |
| def element_=(value: Clay_FloatingAttachPointType): Unit = !struct.at1 = value | |
| def parent : Clay_FloatingAttachPointType = struct._2 | |
| def parent_=(value: Clay_FloatingAttachPointType): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_FloatingElementConfig = CStruct6[Clay_Vector2, Clay_Dimensions, uint16_t, uint32_t, Clay_FloatingAttachPoints, Clay_PointerCaptureMode] | |
| object Clay_FloatingElementConfig: | |
| given _tag: Tag[Clay_FloatingElementConfig] = Tag.materializeCStruct6Tag[Clay_Vector2, Clay_Dimensions, uint16_t, uint32_t, Clay_FloatingAttachPoints, Clay_PointerCaptureMode] | |
| def apply()(using Zone): Ptr[Clay_FloatingElementConfig] = scala.scalanative.unsafe.alloc[Clay_FloatingElementConfig](1) | |
| def apply(offset : Clay_Vector2, expand : Clay_Dimensions, zIndex : uint16_t, parentId : uint32_t, attachment : Clay_FloatingAttachPoints, pointerCaptureMode : Clay_PointerCaptureMode)(using Zone): Ptr[Clay_FloatingElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).offset = offset | |
| (!____ptr).expand = expand | |
| (!____ptr).zIndex = zIndex | |
| (!____ptr).parentId = parentId | |
| (!____ptr).attachment = attachment | |
| (!____ptr).pointerCaptureMode = pointerCaptureMode | |
| ____ptr | |
| extension (struct: Clay_FloatingElementConfig) | |
| def offset : Clay_Vector2 = struct._1 | |
| def offset_=(value: Clay_Vector2): Unit = !struct.at1 = value | |
| def expand : Clay_Dimensions = struct._2 | |
| def expand_=(value: Clay_Dimensions): Unit = !struct.at2 = value | |
| def zIndex : uint16_t = struct._3 | |
| def zIndex_=(value: uint16_t): Unit = !struct.at3 = value | |
| def parentId : uint32_t = struct._4 | |
| def parentId_=(value: uint32_t): Unit = !struct.at4 = value | |
| def attachment : Clay_FloatingAttachPoints = struct._5 | |
| def attachment_=(value: Clay_FloatingAttachPoints): Unit = !struct.at5 = value | |
| def pointerCaptureMode : Clay_PointerCaptureMode = struct._6 | |
| def pointerCaptureMode_=(value: Clay_PointerCaptureMode): Unit = !struct.at6 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ImageElementConfig = CStruct2[Ptr[Byte], Clay_Dimensions] | |
| object Clay_ImageElementConfig: | |
| given _tag: Tag[Clay_ImageElementConfig] = Tag.materializeCStruct2Tag[Ptr[Byte], Clay_Dimensions] | |
| def apply()(using Zone): Ptr[Clay_ImageElementConfig] = scala.scalanative.unsafe.alloc[Clay_ImageElementConfig](1) | |
| def apply(imageData : Ptr[Byte], sourceDimensions : Clay_Dimensions)(using Zone): Ptr[Clay_ImageElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).imageData = imageData | |
| (!____ptr).sourceDimensions = sourceDimensions | |
| ____ptr | |
| extension (struct: Clay_ImageElementConfig) | |
| def imageData : Ptr[Byte] = struct._1 | |
| def imageData_=(value: Ptr[Byte]): Unit = !struct.at1 = value | |
| def sourceDimensions : Clay_Dimensions = struct._2 | |
| def sourceDimensions_=(value: Clay_Dimensions): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_LayoutConfig = CStruct5[Clay_Sizing, Clay_Padding, uint16_t, Clay_ChildAlignment, Clay_LayoutDirection] | |
| object Clay_LayoutConfig: | |
| given _tag: Tag[Clay_LayoutConfig] = Tag.materializeCStruct5Tag[Clay_Sizing, Clay_Padding, uint16_t, Clay_ChildAlignment, Clay_LayoutDirection] | |
| def apply()(using Zone): Ptr[Clay_LayoutConfig] = scala.scalanative.unsafe.alloc[Clay_LayoutConfig](1) | |
| def apply(sizing : Clay_Sizing, padding : Clay_Padding, childGap : uint16_t, childAlignment : Clay_ChildAlignment, layoutDirection : Clay_LayoutDirection)(using Zone): Ptr[Clay_LayoutConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).sizing = sizing | |
| (!____ptr).padding = padding | |
| (!____ptr).childGap = childGap | |
| (!____ptr).childAlignment = childAlignment | |
| (!____ptr).layoutDirection = layoutDirection | |
| ____ptr | |
| extension (struct: Clay_LayoutConfig) | |
| def sizing : Clay_Sizing = struct._1 | |
| def sizing_=(value: Clay_Sizing): Unit = !struct.at1 = value | |
| def padding : Clay_Padding = struct._2 | |
| def padding_=(value: Clay_Padding): Unit = !struct.at2 = value | |
| def childGap : uint16_t = struct._3 | |
| def childGap_=(value: uint16_t): Unit = !struct.at3 = value | |
| def childAlignment : Clay_ChildAlignment = struct._4 | |
| def childAlignment_=(value: Clay_ChildAlignment): Unit = !struct.at4 = value | |
| def layoutDirection : Clay_LayoutDirection = struct._5 | |
| def layoutDirection_=(value: Clay_LayoutDirection): Unit = !struct.at5 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Padding = CStruct2[uint16_t, uint16_t] | |
| object Clay_Padding: | |
| given _tag: Tag[Clay_Padding] = Tag.materializeCStruct2Tag[uint16_t, uint16_t] | |
| def apply()(using Zone): Ptr[Clay_Padding] = scala.scalanative.unsafe.alloc[Clay_Padding](1) | |
| def apply(x : uint16_t, y : uint16_t)(using Zone): Ptr[Clay_Padding] = | |
| val ____ptr = apply() | |
| (!____ptr).x = x | |
| (!____ptr).y = y | |
| ____ptr | |
| extension (struct: Clay_Padding) | |
| def x : uint16_t = struct._1 | |
| def x_=(value: uint16_t): Unit = !struct.at1 = value | |
| def y : uint16_t = struct._2 | |
| def y_=(value: uint16_t): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_PointerData = CStruct2[Clay_Vector2, Clay_PointerDataInteractionState] | |
| object Clay_PointerData: | |
| given _tag: Tag[Clay_PointerData] = Tag.materializeCStruct2Tag[Clay_Vector2, Clay_PointerDataInteractionState] | |
| def apply()(using Zone): Ptr[Clay_PointerData] = scala.scalanative.unsafe.alloc[Clay_PointerData](1) | |
| def apply(position : Clay_Vector2, state : Clay_PointerDataInteractionState)(using Zone): Ptr[Clay_PointerData] = | |
| val ____ptr = apply() | |
| (!____ptr).position = position | |
| (!____ptr).state = state | |
| ____ptr | |
| extension (struct: Clay_PointerData) | |
| def position : Clay_Vector2 = struct._1 | |
| def position_=(value: Clay_Vector2): Unit = !struct.at1 = value | |
| def state : Clay_PointerDataInteractionState = struct._2 | |
| def state_=(value: Clay_PointerDataInteractionState): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_RectangleElementConfig = CStruct2[Clay_Color, Clay_CornerRadius] | |
| object Clay_RectangleElementConfig: | |
| given _tag: Tag[Clay_RectangleElementConfig] = Tag.materializeCStruct2Tag[Clay_Color, Clay_CornerRadius] | |
| def apply()(using Zone): Ptr[Clay_RectangleElementConfig] = scala.scalanative.unsafe.alloc[Clay_RectangleElementConfig](1) | |
| def apply(color : Clay_Color, cornerRadius : Clay_CornerRadius)(using Zone): Ptr[Clay_RectangleElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).color = color | |
| (!____ptr).cornerRadius = cornerRadius | |
| ____ptr | |
| extension (struct: Clay_RectangleElementConfig) | |
| def color : Clay_Color = struct._1 | |
| def color_=(value: Clay_Color): Unit = !struct.at1 = value | |
| def cornerRadius : Clay_CornerRadius = struct._2 | |
| def cornerRadius_=(value: Clay_CornerRadius): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_RenderCommand = CStruct5[Clay_BoundingBox, Clay_ElementConfigUnion, Clay_String, uint32_t, Clay_RenderCommandType] | |
| object Clay_RenderCommand: | |
| given _tag: Tag[Clay_RenderCommand] = Tag.materializeCStruct5Tag[Clay_BoundingBox, Clay_ElementConfigUnion, Clay_String, uint32_t, Clay_RenderCommandType] | |
| def apply()(using Zone): Ptr[Clay_RenderCommand] = scala.scalanative.unsafe.alloc[Clay_RenderCommand](1) | |
| def apply(boundingBox : Clay_BoundingBox, config : Clay_ElementConfigUnion, text : Clay_String, id : uint32_t, commandType : Clay_RenderCommandType)(using Zone): Ptr[Clay_RenderCommand] = | |
| val ____ptr = apply() | |
| (!____ptr).boundingBox = boundingBox | |
| (!____ptr).config = config | |
| (!____ptr).text = text | |
| (!____ptr).id = id | |
| (!____ptr).commandType = commandType | |
| ____ptr | |
| extension (struct: Clay_RenderCommand) | |
| def boundingBox : Clay_BoundingBox = struct._1 | |
| def boundingBox_=(value: Clay_BoundingBox): Unit = !struct.at1 = value | |
| def config : Clay_ElementConfigUnion = struct._2 | |
| def config_=(value: Clay_ElementConfigUnion): Unit = !struct.at2 = value | |
| def text : Clay_String = struct._3 | |
| def text_=(value: Clay_String): Unit = !struct.at3 = value | |
| def id : uint32_t = struct._4 | |
| def id_=(value: uint32_t): Unit = !struct.at4 = value | |
| def commandType : Clay_RenderCommandType = struct._5 | |
| def commandType_=(value: Clay_RenderCommandType): Unit = !struct.at5 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_RenderCommandArray = CStruct3[uint32_t, uint32_t, Ptr[Clay_RenderCommand]] | |
| object Clay_RenderCommandArray: | |
| given _tag: Tag[Clay_RenderCommandArray] = Tag.materializeCStruct3Tag[uint32_t, uint32_t, Ptr[Clay_RenderCommand]] | |
| def apply()(using Zone): Ptr[Clay_RenderCommandArray] = scala.scalanative.unsafe.alloc[Clay_RenderCommandArray](1) | |
| def apply(capacity : uint32_t, length : uint32_t, internalArray : Ptr[Clay_RenderCommand])(using Zone): Ptr[Clay_RenderCommandArray] = | |
| val ____ptr = apply() | |
| (!____ptr).capacity = capacity | |
| (!____ptr).length = length | |
| (!____ptr).internalArray = internalArray | |
| ____ptr | |
| extension (struct: Clay_RenderCommandArray) | |
| def capacity : uint32_t = struct._1 | |
| def capacity_=(value: uint32_t): Unit = !struct.at1 = value | |
| def length : uint32_t = struct._2 | |
| def length_=(value: uint32_t): Unit = !struct.at2 = value | |
| def internalArray : Ptr[Clay_RenderCommand] = struct._3 | |
| def internalArray_=(value: Ptr[Clay_RenderCommand]): Unit = !struct.at3 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ScrollContainerData = CStruct5[Ptr[Clay_Vector2], Clay_Dimensions, Clay_Dimensions, Clay_ScrollElementConfig, Boolean] | |
| object Clay_ScrollContainerData: | |
| given _tag: Tag[Clay_ScrollContainerData] = Tag.materializeCStruct5Tag[Ptr[Clay_Vector2], Clay_Dimensions, Clay_Dimensions, Clay_ScrollElementConfig, Boolean] | |
| def apply()(using Zone): Ptr[Clay_ScrollContainerData] = scala.scalanative.unsafe.alloc[Clay_ScrollContainerData](1) | |
| def apply(scrollPosition : Ptr[Clay_Vector2], scrollContainerDimensions : Clay_Dimensions, contentDimensions : Clay_Dimensions, config : Clay_ScrollElementConfig, found : Boolean)(using Zone): Ptr[Clay_ScrollContainerData] = | |
| val ____ptr = apply() | |
| (!____ptr).scrollPosition = scrollPosition | |
| (!____ptr).scrollContainerDimensions = scrollContainerDimensions | |
| (!____ptr).contentDimensions = contentDimensions | |
| (!____ptr).config = config | |
| (!____ptr).found = found | |
| ____ptr | |
| extension (struct: Clay_ScrollContainerData) | |
| def scrollPosition : Ptr[Clay_Vector2] = struct._1 | |
| def scrollPosition_=(value: Ptr[Clay_Vector2]): Unit = !struct.at1 = value | |
| def scrollContainerDimensions : Clay_Dimensions = struct._2 | |
| def scrollContainerDimensions_=(value: Clay_Dimensions): Unit = !struct.at2 = value | |
| def contentDimensions : Clay_Dimensions = struct._3 | |
| def contentDimensions_=(value: Clay_Dimensions): Unit = !struct.at3 = value | |
| def config : Clay_ScrollElementConfig = struct._4 | |
| def config_=(value: Clay_ScrollElementConfig): Unit = !struct.at4 = value | |
| def found : Boolean = struct._5 | |
| def found_=(value: Boolean): Unit = !struct.at5 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ScrollElementConfig = CStruct2[Boolean, Boolean] | |
| object Clay_ScrollElementConfig: | |
| given _tag: Tag[Clay_ScrollElementConfig] = Tag.materializeCStruct2Tag[Boolean, Boolean] | |
| def apply()(using Zone): Ptr[Clay_ScrollElementConfig] = scala.scalanative.unsafe.alloc[Clay_ScrollElementConfig](1) | |
| def apply(horizontal : Boolean, vertical : Boolean)(using Zone): Ptr[Clay_ScrollElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).horizontal = horizontal | |
| (!____ptr).vertical = vertical | |
| ____ptr | |
| extension (struct: Clay_ScrollElementConfig) | |
| def horizontal : Boolean = struct._1 | |
| def horizontal_=(value: Boolean): Unit = !struct.at1 = value | |
| def vertical : Boolean = struct._2 | |
| def vertical_=(value: Boolean): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Sizing = CStruct2[Clay_SizingAxis, Clay_SizingAxis] | |
| object Clay_Sizing: | |
| given _tag: Tag[Clay_Sizing] = Tag.materializeCStruct2Tag[Clay_SizingAxis, Clay_SizingAxis] | |
| def apply()(using Zone): Ptr[Clay_Sizing] = scala.scalanative.unsafe.alloc[Clay_Sizing](1) | |
| def apply(width : Clay_SizingAxis, height : Clay_SizingAxis)(using Zone): Ptr[Clay_Sizing] = | |
| val ____ptr = apply() | |
| (!____ptr).width = width | |
| (!____ptr).height = height | |
| ____ptr | |
| extension (struct: Clay_Sizing) | |
| def width : Clay_SizingAxis = struct._1 | |
| def width_=(value: Clay_SizingAxis): Unit = !struct.at1 = value | |
| def height : Clay_SizingAxis = struct._2 | |
| def height_=(value: Clay_SizingAxis): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_SizingAxis = CStruct2[Clay_SizingAxis.Union0, Clay__SizingType] | |
| object Clay_SizingAxis: | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Union0 = CArray[Byte, Nat._8] | |
| object Union0: | |
| given _tag: Tag[Union0] = Tag.CArray[CChar, Nat._8](Tag.Byte, Tag.Nat8) | |
| def apply()(using Zone): Ptr[Union0] = | |
| val ___ptr = alloc[Union0](1) | |
| ___ptr | |
| @scala.annotation.targetName("apply_minMax") | |
| def apply(minMax: Clay_SizingMinMax)(using Zone): Ptr[Union0] = | |
| val ___ptr = alloc[Union0](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Clay_SizingMinMax]].update(0, minMax) | |
| ___ptr | |
| @scala.annotation.targetName("apply_percent") | |
| def apply(percent: Float)(using Zone): Ptr[Union0] = | |
| val ___ptr = alloc[Union0](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Float]].update(0, percent) | |
| ___ptr | |
| extension (struct: Union0) | |
| def minMax : Clay_SizingMinMax = !struct.at(0).asInstanceOf[Ptr[Clay_SizingMinMax]] | |
| def minMax_=(value: Clay_SizingMinMax): Unit = !struct.at(0).asInstanceOf[Ptr[Clay_SizingMinMax]] = value | |
| def percent : Float = !struct.at(0).asInstanceOf[Ptr[Float]] | |
| def percent_=(value: Float): Unit = !struct.at(0).asInstanceOf[Ptr[Float]] = value | |
| given _tag: Tag[Clay_SizingAxis] = Tag.materializeCStruct2Tag[Clay_SizingAxis.Union0, Clay__SizingType] | |
| def apply()(using Zone): Ptr[Clay_SizingAxis] = scala.scalanative.unsafe.alloc[Clay_SizingAxis](1) | |
| def apply(size : Clay_SizingAxis.Union0, `type` : Clay__SizingType)(using Zone): Ptr[Clay_SizingAxis] = | |
| val ____ptr = apply() | |
| (!____ptr).size = size | |
| (!____ptr).`type` = `type` | |
| ____ptr | |
| extension (struct: Clay_SizingAxis) | |
| def size : Clay_SizingAxis.Union0 = struct._1 | |
| def size_=(value: Clay_SizingAxis.Union0): Unit = !struct.at1 = value | |
| def `type` : Clay__SizingType = struct._2 | |
| def type_=(value: Clay__SizingType): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_SizingMinMax = CStruct2[Float, Float] | |
| object Clay_SizingMinMax: | |
| given _tag: Tag[Clay_SizingMinMax] = Tag.materializeCStruct2Tag[Float, Float] | |
| def apply()(using Zone): Ptr[Clay_SizingMinMax] = scala.scalanative.unsafe.alloc[Clay_SizingMinMax](1) | |
| def apply(min : Float, max : Float)(using Zone): Ptr[Clay_SizingMinMax] = | |
| val ____ptr = apply() | |
| (!____ptr).min = min | |
| (!____ptr).max = max | |
| ____ptr | |
| extension (struct: Clay_SizingMinMax) | |
| def min : Float = struct._1 | |
| def min_=(value: Float): Unit = !struct.at1 = value | |
| def max : Float = struct._2 | |
| def max_=(value: Float): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_String = CStruct2[size_t, CString] | |
| object Clay_String: | |
| given _tag: Tag[Clay_String] = Tag.materializeCStruct2Tag[size_t, CString] | |
| def apply()(using Zone): Ptr[Clay_String] = scala.scalanative.unsafe.alloc[Clay_String](1) | |
| def apply(length : size_t, chars : CString)(using Zone): Ptr[Clay_String] = | |
| val ____ptr = apply() | |
| (!____ptr).length = length | |
| (!____ptr).chars = chars | |
| ____ptr | |
| extension (struct: Clay_String) | |
| def length : size_t = struct._1 | |
| def length_=(value: size_t): Unit = !struct.at1 = value | |
| def chars : CString = struct._2 | |
| def chars_=(value: CString): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_TextElementConfig = CStruct6[Clay_Color, uint16_t, uint16_t, uint16_t, uint16_t, Clay_TextElementConfigWrapMode] | |
| object Clay_TextElementConfig: | |
| given _tag: Tag[Clay_TextElementConfig] = Tag.materializeCStruct6Tag[Clay_Color, uint16_t, uint16_t, uint16_t, uint16_t, Clay_TextElementConfigWrapMode] | |
| def apply()(using Zone): Ptr[Clay_TextElementConfig] = scala.scalanative.unsafe.alloc[Clay_TextElementConfig](1) | |
| def apply(textColor : Clay_Color, fontId : uint16_t, fontSize : uint16_t, letterSpacing : uint16_t, lineHeight : uint16_t, wrapMode : Clay_TextElementConfigWrapMode)(using Zone): Ptr[Clay_TextElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).textColor = textColor | |
| (!____ptr).fontId = fontId | |
| (!____ptr).fontSize = fontSize | |
| (!____ptr).letterSpacing = letterSpacing | |
| (!____ptr).lineHeight = lineHeight | |
| (!____ptr).wrapMode = wrapMode | |
| ____ptr | |
| extension (struct: Clay_TextElementConfig) | |
| def textColor : Clay_Color = struct._1 | |
| def textColor_=(value: Clay_Color): Unit = !struct.at1 = value | |
| def fontId : uint16_t = struct._2 | |
| def fontId_=(value: uint16_t): Unit = !struct.at2 = value | |
| def fontSize : uint16_t = struct._3 | |
| def fontSize_=(value: uint16_t): Unit = !struct.at3 = value | |
| def letterSpacing : uint16_t = struct._4 | |
| def letterSpacing_=(value: uint16_t): Unit = !struct.at4 = value | |
| def lineHeight : uint16_t = struct._5 | |
| def lineHeight_=(value: uint16_t): Unit = !struct.at5 = value | |
| def wrapMode : Clay_TextElementConfigWrapMode = struct._6 | |
| def wrapMode_=(value: Clay_TextElementConfigWrapMode): Unit = !struct.at6 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_Vector2 = CStruct2[Float, Float] | |
| object Clay_Vector2: | |
| given _tag: Tag[Clay_Vector2] = Tag.materializeCStruct2Tag[Float, Float] | |
| def apply()(using Zone): Ptr[Clay_Vector2] = scala.scalanative.unsafe.alloc[Clay_Vector2](1) | |
| def apply(x : Float, y : Float)(using Zone): Ptr[Clay_Vector2] = | |
| val ____ptr = apply() | |
| (!____ptr).x = x | |
| (!____ptr).y = y | |
| ____ptr | |
| extension (struct: Clay_Vector2) | |
| def x : Float = struct._1 | |
| def x_=(value: Float): Unit = !struct.at1 = value | |
| def y : Float = struct._2 | |
| def y_=(value: Float): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Arena = CStruct2[CChar, Clay_Arena] | |
| object Clay__AlignClay_Arena: | |
| given _tag: Tag[Clay__AlignClay_Arena] = Tag.materializeCStruct2Tag[CChar, Clay_Arena] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Arena] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Arena](1) | |
| def apply(c : CChar, x : Clay_Arena)(using Zone): Ptr[Clay__AlignClay_Arena] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Arena) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Arena = struct._2 | |
| def x_=(value: Clay_Arena): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Border = CStruct2[CChar, Clay_Border] | |
| object Clay__AlignClay_Border: | |
| given _tag: Tag[Clay__AlignClay_Border] = Tag.materializeCStruct2Tag[CChar, Clay_Border] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Border] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Border](1) | |
| def apply(c : CChar, x : Clay_Border)(using Zone): Ptr[Clay__AlignClay_Border] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Border) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Border = struct._2 | |
| def x_=(value: Clay_Border): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_BorderElementConfig = CStruct2[CChar, Clay_BorderElementConfig] | |
| object Clay__AlignClay_BorderElementConfig: | |
| given _tag: Tag[Clay__AlignClay_BorderElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_BorderElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_BorderElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_BorderElementConfig](1) | |
| def apply(c : CChar, x : Clay_BorderElementConfig)(using Zone): Ptr[Clay__AlignClay_BorderElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_BorderElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_BorderElementConfig = struct._2 | |
| def x_=(value: Clay_BorderElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_BoundingBox = CStruct2[CChar, Clay_BoundingBox] | |
| object Clay__AlignClay_BoundingBox: | |
| given _tag: Tag[Clay__AlignClay_BoundingBox] = Tag.materializeCStruct2Tag[CChar, Clay_BoundingBox] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_BoundingBox] = scala.scalanative.unsafe.alloc[Clay__AlignClay_BoundingBox](1) | |
| def apply(c : CChar, x : Clay_BoundingBox)(using Zone): Ptr[Clay__AlignClay_BoundingBox] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_BoundingBox) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_BoundingBox = struct._2 | |
| def x_=(value: Clay_BoundingBox): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ChildAlignment = CStruct2[CChar, Clay_ChildAlignment] | |
| object Clay__AlignClay_ChildAlignment: | |
| given _tag: Tag[Clay__AlignClay_ChildAlignment] = Tag.materializeCStruct2Tag[CChar, Clay_ChildAlignment] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ChildAlignment] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ChildAlignment](1) | |
| def apply(c : CChar, x : Clay_ChildAlignment)(using Zone): Ptr[Clay__AlignClay_ChildAlignment] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ChildAlignment) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ChildAlignment = struct._2 | |
| def x_=(value: Clay_ChildAlignment): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Color = CStruct2[CChar, Clay_Color] | |
| object Clay__AlignClay_Color: | |
| given _tag: Tag[Clay__AlignClay_Color] = Tag.materializeCStruct2Tag[CChar, Clay_Color] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Color] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Color](1) | |
| def apply(c : CChar, x : Clay_Color)(using Zone): Ptr[Clay__AlignClay_Color] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Color) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Color = struct._2 | |
| def x_=(value: Clay_Color): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_CornerRadius = CStruct2[CChar, Clay_CornerRadius] | |
| object Clay__AlignClay_CornerRadius: | |
| given _tag: Tag[Clay__AlignClay_CornerRadius] = Tag.materializeCStruct2Tag[CChar, Clay_CornerRadius] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_CornerRadius] = scala.scalanative.unsafe.alloc[Clay__AlignClay_CornerRadius](1) | |
| def apply(c : CChar, x : Clay_CornerRadius)(using Zone): Ptr[Clay__AlignClay_CornerRadius] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_CornerRadius) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_CornerRadius = struct._2 | |
| def x_=(value: Clay_CornerRadius): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_CustomElementConfig = CStruct2[CChar, Clay_CustomElementConfig] | |
| object Clay__AlignClay_CustomElementConfig: | |
| given _tag: Tag[Clay__AlignClay_CustomElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_CustomElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_CustomElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_CustomElementConfig](1) | |
| def apply(c : CChar, x : Clay_CustomElementConfig)(using Zone): Ptr[Clay__AlignClay_CustomElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_CustomElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_CustomElementConfig = struct._2 | |
| def x_=(value: Clay_CustomElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Dimensions = CStruct2[CChar, Clay_Dimensions] | |
| object Clay__AlignClay_Dimensions: | |
| given _tag: Tag[Clay__AlignClay_Dimensions] = Tag.materializeCStruct2Tag[CChar, Clay_Dimensions] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Dimensions] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Dimensions](1) | |
| def apply(c : CChar, x : Clay_Dimensions)(using Zone): Ptr[Clay__AlignClay_Dimensions] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Dimensions) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Dimensions = struct._2 | |
| def x_=(value: Clay_Dimensions): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ElementConfig = CStruct2[CChar, Clay_ElementConfig] | |
| object Clay__AlignClay_ElementConfig: | |
| given _tag: Tag[Clay__AlignClay_ElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_ElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ElementConfig](1) | |
| def apply(c : CChar, x : Clay_ElementConfig)(using Zone): Ptr[Clay__AlignClay_ElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ElementConfig = struct._2 | |
| def x_=(value: Clay_ElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ElementConfigUnion = CStruct2[CChar, Clay_ElementConfigUnion] | |
| object Clay__AlignClay_ElementConfigUnion: | |
| given _tag: Tag[Clay__AlignClay_ElementConfigUnion] = Tag.materializeCStruct2Tag[CChar, Clay_ElementConfigUnion] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ElementConfigUnion] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ElementConfigUnion](1) | |
| def apply(c : CChar, x : Clay_ElementConfigUnion)(using Zone): Ptr[Clay__AlignClay_ElementConfigUnion] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ElementConfigUnion) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ElementConfigUnion = struct._2 | |
| def x_=(value: Clay_ElementConfigUnion): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ElementId = CStruct2[CChar, Clay_ElementId] | |
| object Clay__AlignClay_ElementId: | |
| given _tag: Tag[Clay__AlignClay_ElementId] = Tag.materializeCStruct2Tag[CChar, Clay_ElementId] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ElementId] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ElementId](1) | |
| def apply(c : CChar, x : Clay_ElementId)(using Zone): Ptr[Clay__AlignClay_ElementId] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ElementId) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ElementId = struct._2 | |
| def x_=(value: Clay_ElementId): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ErrorData = CStruct2[CChar, Clay_ErrorData] | |
| object Clay__AlignClay_ErrorData: | |
| given _tag: Tag[Clay__AlignClay_ErrorData] = Tag.materializeCStruct2Tag[CChar, Clay_ErrorData] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ErrorData] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ErrorData](1) | |
| def apply(c : CChar, x : Clay_ErrorData)(using Zone): Ptr[Clay__AlignClay_ErrorData] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ErrorData) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ErrorData = struct._2 | |
| def x_=(value: Clay_ErrorData): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ErrorHandler = CStruct2[CChar, Clay_ErrorHandler] | |
| object Clay__AlignClay_ErrorHandler: | |
| given _tag: Tag[Clay__AlignClay_ErrorHandler] = Tag.materializeCStruct2Tag[CChar, Clay_ErrorHandler] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ErrorHandler] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ErrorHandler](1) | |
| def apply(c : CChar, x : Clay_ErrorHandler)(using Zone): Ptr[Clay__AlignClay_ErrorHandler] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ErrorHandler) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ErrorHandler = struct._2 | |
| def x_=(value: Clay_ErrorHandler): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ErrorType = CStruct2[CChar, Clay_ErrorType] | |
| object Clay__AlignClay_ErrorType: | |
| given _tag: Tag[Clay__AlignClay_ErrorType] = Tag.materializeCStruct2Tag[CChar, Clay_ErrorType] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ErrorType] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ErrorType](1) | |
| def apply(c : CChar, x : Clay_ErrorType)(using Zone): Ptr[Clay__AlignClay_ErrorType] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ErrorType) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ErrorType = struct._2 | |
| def x_=(value: Clay_ErrorType): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_FloatingAttachPointType = CStruct2[CChar, Clay_FloatingAttachPointType] | |
| object Clay__AlignClay_FloatingAttachPointType: | |
| given _tag: Tag[Clay__AlignClay_FloatingAttachPointType] = Tag.materializeCStruct2Tag[CChar, Clay_FloatingAttachPointType] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_FloatingAttachPointType] = scala.scalanative.unsafe.alloc[Clay__AlignClay_FloatingAttachPointType](1) | |
| def apply(c : CChar, x : Clay_FloatingAttachPointType)(using Zone): Ptr[Clay__AlignClay_FloatingAttachPointType] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_FloatingAttachPointType) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_FloatingAttachPointType = struct._2 | |
| def x_=(value: Clay_FloatingAttachPointType): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_FloatingAttachPoints = CStruct2[CChar, Clay_FloatingAttachPoints] | |
| object Clay__AlignClay_FloatingAttachPoints: | |
| given _tag: Tag[Clay__AlignClay_FloatingAttachPoints] = Tag.materializeCStruct2Tag[CChar, Clay_FloatingAttachPoints] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_FloatingAttachPoints] = scala.scalanative.unsafe.alloc[Clay__AlignClay_FloatingAttachPoints](1) | |
| def apply(c : CChar, x : Clay_FloatingAttachPoints)(using Zone): Ptr[Clay__AlignClay_FloatingAttachPoints] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_FloatingAttachPoints) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_FloatingAttachPoints = struct._2 | |
| def x_=(value: Clay_FloatingAttachPoints): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_FloatingElementConfig = CStruct2[CChar, Clay_FloatingElementConfig] | |
| object Clay__AlignClay_FloatingElementConfig: | |
| given _tag: Tag[Clay__AlignClay_FloatingElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_FloatingElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_FloatingElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_FloatingElementConfig](1) | |
| def apply(c : CChar, x : Clay_FloatingElementConfig)(using Zone): Ptr[Clay__AlignClay_FloatingElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_FloatingElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_FloatingElementConfig = struct._2 | |
| def x_=(value: Clay_FloatingElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ImageElementConfig = CStruct2[CChar, Clay_ImageElementConfig] | |
| object Clay__AlignClay_ImageElementConfig: | |
| given _tag: Tag[Clay__AlignClay_ImageElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_ImageElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ImageElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ImageElementConfig](1) | |
| def apply(c : CChar, x : Clay_ImageElementConfig)(using Zone): Ptr[Clay__AlignClay_ImageElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ImageElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ImageElementConfig = struct._2 | |
| def x_=(value: Clay_ImageElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_LayoutAlignmentX = CStruct2[CChar, Clay_LayoutAlignmentX] | |
| object Clay__AlignClay_LayoutAlignmentX: | |
| given _tag: Tag[Clay__AlignClay_LayoutAlignmentX] = Tag.materializeCStruct2Tag[CChar, Clay_LayoutAlignmentX] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_LayoutAlignmentX] = scala.scalanative.unsafe.alloc[Clay__AlignClay_LayoutAlignmentX](1) | |
| def apply(c : CChar, x : Clay_LayoutAlignmentX)(using Zone): Ptr[Clay__AlignClay_LayoutAlignmentX] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_LayoutAlignmentX) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_LayoutAlignmentX = struct._2 | |
| def x_=(value: Clay_LayoutAlignmentX): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_LayoutAlignmentY = CStruct2[CChar, Clay_LayoutAlignmentY] | |
| object Clay__AlignClay_LayoutAlignmentY: | |
| given _tag: Tag[Clay__AlignClay_LayoutAlignmentY] = Tag.materializeCStruct2Tag[CChar, Clay_LayoutAlignmentY] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_LayoutAlignmentY] = scala.scalanative.unsafe.alloc[Clay__AlignClay_LayoutAlignmentY](1) | |
| def apply(c : CChar, x : Clay_LayoutAlignmentY)(using Zone): Ptr[Clay__AlignClay_LayoutAlignmentY] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_LayoutAlignmentY) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_LayoutAlignmentY = struct._2 | |
| def x_=(value: Clay_LayoutAlignmentY): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_LayoutConfig = CStruct2[CChar, Clay_LayoutConfig] | |
| object Clay__AlignClay_LayoutConfig: | |
| given _tag: Tag[Clay__AlignClay_LayoutConfig] = Tag.materializeCStruct2Tag[CChar, Clay_LayoutConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_LayoutConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_LayoutConfig](1) | |
| def apply(c : CChar, x : Clay_LayoutConfig)(using Zone): Ptr[Clay__AlignClay_LayoutConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_LayoutConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_LayoutConfig = struct._2 | |
| def x_=(value: Clay_LayoutConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_LayoutDirection = CStruct2[CChar, Clay_LayoutDirection] | |
| object Clay__AlignClay_LayoutDirection: | |
| given _tag: Tag[Clay__AlignClay_LayoutDirection] = Tag.materializeCStruct2Tag[CChar, Clay_LayoutDirection] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_LayoutDirection] = scala.scalanative.unsafe.alloc[Clay__AlignClay_LayoutDirection](1) | |
| def apply(c : CChar, x : Clay_LayoutDirection)(using Zone): Ptr[Clay__AlignClay_LayoutDirection] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_LayoutDirection) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_LayoutDirection = struct._2 | |
| def x_=(value: Clay_LayoutDirection): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Padding = CStruct2[CChar, Clay_Padding] | |
| object Clay__AlignClay_Padding: | |
| given _tag: Tag[Clay__AlignClay_Padding] = Tag.materializeCStruct2Tag[CChar, Clay_Padding] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Padding] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Padding](1) | |
| def apply(c : CChar, x : Clay_Padding)(using Zone): Ptr[Clay__AlignClay_Padding] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Padding) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Padding = struct._2 | |
| def x_=(value: Clay_Padding): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_PointerCaptureMode = CStruct2[CChar, Clay_PointerCaptureMode] | |
| object Clay__AlignClay_PointerCaptureMode: | |
| given _tag: Tag[Clay__AlignClay_PointerCaptureMode] = Tag.materializeCStruct2Tag[CChar, Clay_PointerCaptureMode] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_PointerCaptureMode] = scala.scalanative.unsafe.alloc[Clay__AlignClay_PointerCaptureMode](1) | |
| def apply(c : CChar, x : Clay_PointerCaptureMode)(using Zone): Ptr[Clay__AlignClay_PointerCaptureMode] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_PointerCaptureMode) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_PointerCaptureMode = struct._2 | |
| def x_=(value: Clay_PointerCaptureMode): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_PointerData = CStruct2[CChar, Clay_PointerData] | |
| object Clay__AlignClay_PointerData: | |
| given _tag: Tag[Clay__AlignClay_PointerData] = Tag.materializeCStruct2Tag[CChar, Clay_PointerData] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_PointerData] = scala.scalanative.unsafe.alloc[Clay__AlignClay_PointerData](1) | |
| def apply(c : CChar, x : Clay_PointerData)(using Zone): Ptr[Clay__AlignClay_PointerData] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_PointerData) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_PointerData = struct._2 | |
| def x_=(value: Clay_PointerData): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_PointerDataInteractionState = CStruct2[CChar, Clay_PointerDataInteractionState] | |
| object Clay__AlignClay_PointerDataInteractionState: | |
| given _tag: Tag[Clay__AlignClay_PointerDataInteractionState] = Tag.materializeCStruct2Tag[CChar, Clay_PointerDataInteractionState] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_PointerDataInteractionState] = scala.scalanative.unsafe.alloc[Clay__AlignClay_PointerDataInteractionState](1) | |
| def apply(c : CChar, x : Clay_PointerDataInteractionState)(using Zone): Ptr[Clay__AlignClay_PointerDataInteractionState] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_PointerDataInteractionState) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_PointerDataInteractionState = struct._2 | |
| def x_=(value: Clay_PointerDataInteractionState): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_RectangleElementConfig = CStruct2[CChar, Clay_RectangleElementConfig] | |
| object Clay__AlignClay_RectangleElementConfig: | |
| given _tag: Tag[Clay__AlignClay_RectangleElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_RectangleElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_RectangleElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_RectangleElementConfig](1) | |
| def apply(c : CChar, x : Clay_RectangleElementConfig)(using Zone): Ptr[Clay__AlignClay_RectangleElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_RectangleElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_RectangleElementConfig = struct._2 | |
| def x_=(value: Clay_RectangleElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_RenderCommand = CStruct2[CChar, Clay_RenderCommand] | |
| object Clay__AlignClay_RenderCommand: | |
| given _tag: Tag[Clay__AlignClay_RenderCommand] = Tag.materializeCStruct2Tag[CChar, Clay_RenderCommand] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_RenderCommand] = scala.scalanative.unsafe.alloc[Clay__AlignClay_RenderCommand](1) | |
| def apply(c : CChar, x : Clay_RenderCommand)(using Zone): Ptr[Clay__AlignClay_RenderCommand] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_RenderCommand) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_RenderCommand = struct._2 | |
| def x_=(value: Clay_RenderCommand): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_RenderCommandArray = CStruct2[CChar, Clay_RenderCommandArray] | |
| object Clay__AlignClay_RenderCommandArray: | |
| given _tag: Tag[Clay__AlignClay_RenderCommandArray] = Tag.materializeCStruct2Tag[CChar, Clay_RenderCommandArray] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_RenderCommandArray] = scala.scalanative.unsafe.alloc[Clay__AlignClay_RenderCommandArray](1) | |
| def apply(c : CChar, x : Clay_RenderCommandArray)(using Zone): Ptr[Clay__AlignClay_RenderCommandArray] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_RenderCommandArray) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_RenderCommandArray = struct._2 | |
| def x_=(value: Clay_RenderCommandArray): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_RenderCommandType = CStruct2[CChar, Clay_RenderCommandType] | |
| object Clay__AlignClay_RenderCommandType: | |
| given _tag: Tag[Clay__AlignClay_RenderCommandType] = Tag.materializeCStruct2Tag[CChar, Clay_RenderCommandType] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_RenderCommandType] = scala.scalanative.unsafe.alloc[Clay__AlignClay_RenderCommandType](1) | |
| def apply(c : CChar, x : Clay_RenderCommandType)(using Zone): Ptr[Clay__AlignClay_RenderCommandType] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_RenderCommandType) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_RenderCommandType = struct._2 | |
| def x_=(value: Clay_RenderCommandType): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ScrollContainerData = CStruct2[CChar, Clay_ScrollContainerData] | |
| object Clay__AlignClay_ScrollContainerData: | |
| given _tag: Tag[Clay__AlignClay_ScrollContainerData] = Tag.materializeCStruct2Tag[CChar, Clay_ScrollContainerData] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ScrollContainerData] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ScrollContainerData](1) | |
| def apply(c : CChar, x : Clay_ScrollContainerData)(using Zone): Ptr[Clay__AlignClay_ScrollContainerData] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ScrollContainerData) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ScrollContainerData = struct._2 | |
| def x_=(value: Clay_ScrollContainerData): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_ScrollElementConfig = CStruct2[CChar, Clay_ScrollElementConfig] | |
| object Clay__AlignClay_ScrollElementConfig: | |
| given _tag: Tag[Clay__AlignClay_ScrollElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_ScrollElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_ScrollElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_ScrollElementConfig](1) | |
| def apply(c : CChar, x : Clay_ScrollElementConfig)(using Zone): Ptr[Clay__AlignClay_ScrollElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_ScrollElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_ScrollElementConfig = struct._2 | |
| def x_=(value: Clay_ScrollElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Sizing = CStruct2[CChar, Clay_Sizing] | |
| object Clay__AlignClay_Sizing: | |
| given _tag: Tag[Clay__AlignClay_Sizing] = Tag.materializeCStruct2Tag[CChar, Clay_Sizing] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Sizing] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Sizing](1) | |
| def apply(c : CChar, x : Clay_Sizing)(using Zone): Ptr[Clay__AlignClay_Sizing] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Sizing) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Sizing = struct._2 | |
| def x_=(value: Clay_Sizing): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_SizingAxis = CStruct2[CChar, Clay_SizingAxis] | |
| object Clay__AlignClay_SizingAxis: | |
| given _tag: Tag[Clay__AlignClay_SizingAxis] = Tag.materializeCStruct2Tag[CChar, Clay_SizingAxis] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_SizingAxis] = scala.scalanative.unsafe.alloc[Clay__AlignClay_SizingAxis](1) | |
| def apply(c : CChar, x : Clay_SizingAxis)(using Zone): Ptr[Clay__AlignClay_SizingAxis] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_SizingAxis) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_SizingAxis = struct._2 | |
| def x_=(value: Clay_SizingAxis): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_SizingMinMax = CStruct2[CChar, Clay_SizingMinMax] | |
| object Clay__AlignClay_SizingMinMax: | |
| given _tag: Tag[Clay__AlignClay_SizingMinMax] = Tag.materializeCStruct2Tag[CChar, Clay_SizingMinMax] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_SizingMinMax] = scala.scalanative.unsafe.alloc[Clay__AlignClay_SizingMinMax](1) | |
| def apply(c : CChar, x : Clay_SizingMinMax)(using Zone): Ptr[Clay__AlignClay_SizingMinMax] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_SizingMinMax) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_SizingMinMax = struct._2 | |
| def x_=(value: Clay_SizingMinMax): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_String = CStruct2[CChar, Clay_String] | |
| object Clay__AlignClay_String: | |
| given _tag: Tag[Clay__AlignClay_String] = Tag.materializeCStruct2Tag[CChar, Clay_String] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_String] = scala.scalanative.unsafe.alloc[Clay__AlignClay_String](1) | |
| def apply(c : CChar, x : Clay_String)(using Zone): Ptr[Clay__AlignClay_String] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_String) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_String = struct._2 | |
| def x_=(value: Clay_String): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_TextElementConfig = CStruct2[CChar, Clay_TextElementConfig] | |
| object Clay__AlignClay_TextElementConfig: | |
| given _tag: Tag[Clay__AlignClay_TextElementConfig] = Tag.materializeCStruct2Tag[CChar, Clay_TextElementConfig] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_TextElementConfig] = scala.scalanative.unsafe.alloc[Clay__AlignClay_TextElementConfig](1) | |
| def apply(c : CChar, x : Clay_TextElementConfig)(using Zone): Ptr[Clay__AlignClay_TextElementConfig] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_TextElementConfig) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_TextElementConfig = struct._2 | |
| def x_=(value: Clay_TextElementConfig): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_TextElementConfigWrapMode = CStruct2[CChar, Clay_TextElementConfigWrapMode] | |
| object Clay__AlignClay_TextElementConfigWrapMode: | |
| given _tag: Tag[Clay__AlignClay_TextElementConfigWrapMode] = Tag.materializeCStruct2Tag[CChar, Clay_TextElementConfigWrapMode] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_TextElementConfigWrapMode] = scala.scalanative.unsafe.alloc[Clay__AlignClay_TextElementConfigWrapMode](1) | |
| def apply(c : CChar, x : Clay_TextElementConfigWrapMode)(using Zone): Ptr[Clay__AlignClay_TextElementConfigWrapMode] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_TextElementConfigWrapMode) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_TextElementConfigWrapMode = struct._2 | |
| def x_=(value: Clay_TextElementConfigWrapMode): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay_Vector2 = CStruct2[CChar, Clay_Vector2] | |
| object Clay__AlignClay_Vector2: | |
| given _tag: Tag[Clay__AlignClay_Vector2] = Tag.materializeCStruct2Tag[CChar, Clay_Vector2] | |
| def apply()(using Zone): Ptr[Clay__AlignClay_Vector2] = scala.scalanative.unsafe.alloc[Clay__AlignClay_Vector2](1) | |
| def apply(c : CChar, x : Clay_Vector2)(using Zone): Ptr[Clay__AlignClay_Vector2] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay_Vector2) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay_Vector2 = struct._2 | |
| def x_=(value: Clay_Vector2): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay__ElementConfigType = CStruct2[CChar, Clay__ElementConfigType] | |
| object Clay__AlignClay__ElementConfigType: | |
| given _tag: Tag[Clay__AlignClay__ElementConfigType] = Tag.materializeCStruct2Tag[CChar, Clay__ElementConfigType] | |
| def apply()(using Zone): Ptr[Clay__AlignClay__ElementConfigType] = scala.scalanative.unsafe.alloc[Clay__AlignClay__ElementConfigType](1) | |
| def apply(c : CChar, x : Clay__ElementConfigType)(using Zone): Ptr[Clay__AlignClay__ElementConfigType] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay__ElementConfigType) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay__ElementConfigType = struct._2 | |
| def x_=(value: Clay__ElementConfigType): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay__SizingType = CStruct2[CChar, Clay__SizingType] | |
| object Clay__AlignClay__SizingType: | |
| given _tag: Tag[Clay__AlignClay__SizingType] = Tag.materializeCStruct2Tag[CChar, Clay__SizingType] | |
| def apply()(using Zone): Ptr[Clay__AlignClay__SizingType] = scala.scalanative.unsafe.alloc[Clay__AlignClay__SizingType](1) | |
| def apply(c : CChar, x : Clay__SizingType)(using Zone): Ptr[Clay__AlignClay__SizingType] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay__SizingType) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay__SizingType = struct._2 | |
| def x_=(value: Clay__SizingType): Unit = !struct.at2 = value | |
| opaque type Clay__AlignClay__StringArray = CStruct2[CChar, Clay__StringArray] | |
| object Clay__AlignClay__StringArray: | |
| given _tag: Tag[Clay__AlignClay__StringArray] = Tag.materializeCStruct2Tag[CChar, Clay__StringArray] | |
| def apply()(using Zone): Ptr[Clay__AlignClay__StringArray] = scala.scalanative.unsafe.alloc[Clay__AlignClay__StringArray](1) | |
| def apply(c : CChar, x : Clay__StringArray)(using Zone): Ptr[Clay__AlignClay__StringArray] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__AlignClay__StringArray) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Clay__StringArray = struct._2 | |
| def x_=(value: Clay__StringArray): Unit = !struct.at2 = value | |
| opaque type Clay__Alignbool = CStruct2[CChar, Boolean] | |
| object Clay__Alignbool: | |
| given _tag: Tag[Clay__Alignbool] = Tag.materializeCStruct2Tag[CChar, Boolean] | |
| def apply()(using Zone): Ptr[Clay__Alignbool] = scala.scalanative.unsafe.alloc[Clay__Alignbool](1) | |
| def apply(c : CChar, x : Boolean)(using Zone): Ptr[Clay__Alignbool] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__Alignbool) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Boolean = struct._2 | |
| def x_=(value: Boolean): Unit = !struct.at2 = value | |
| opaque type Clay__Alignint32_t = CStruct2[CChar, int32_t] | |
| object Clay__Alignint32_t: | |
| given _tag: Tag[Clay__Alignint32_t] = Tag.materializeCStruct2Tag[CChar, int32_t] | |
| def apply()(using Zone): Ptr[Clay__Alignint32_t] = scala.scalanative.unsafe.alloc[Clay__Alignint32_t](1) | |
| def apply(c : CChar, x : int32_t)(using Zone): Ptr[Clay__Alignint32_t] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__Alignint32_t) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : int32_t = struct._2 | |
| def x_=(value: int32_t): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay__Alignpointer = CStruct2[CChar, Ptr[Byte]] | |
| object Clay__Alignpointer: | |
| given _tag: Tag[Clay__Alignpointer] = Tag.materializeCStruct2Tag[CChar, Ptr[Byte]] | |
| def apply()(using Zone): Ptr[Clay__Alignpointer] = scala.scalanative.unsafe.alloc[Clay__Alignpointer](1) | |
| def apply(c : CChar, x : Ptr[Byte])(using Zone): Ptr[Clay__Alignpointer] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__Alignpointer) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : Ptr[Byte] = struct._2 | |
| def x_=(value: Ptr[Byte]): Unit = !struct.at2 = value | |
| opaque type Clay__Alignuint8_t = CStruct2[CChar, uint8_t] | |
| object Clay__Alignuint8_t: | |
| given _tag: Tag[Clay__Alignuint8_t] = Tag.materializeCStruct2Tag[CChar, uint8_t] | |
| def apply()(using Zone): Ptr[Clay__Alignuint8_t] = scala.scalanative.unsafe.alloc[Clay__Alignuint8_t](1) | |
| def apply(c : CChar, x : uint8_t)(using Zone): Ptr[Clay__Alignuint8_t] = | |
| val ____ptr = apply() | |
| (!____ptr).c = c | |
| (!____ptr).x = x | |
| ____ptr | |
| extension (struct: Clay__Alignuint8_t) | |
| def c : CChar = struct._1 | |
| def c_=(value: CChar): Unit = !struct.at1 = value | |
| def x : uint8_t = struct._2 | |
| def x_=(value: uint8_t): Unit = !struct.at2 = value | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay__StringArray = CStruct3[uint32_t, uint32_t, Ptr[Clay_String]] | |
| object Clay__StringArray: | |
| given _tag: Tag[Clay__StringArray] = Tag.materializeCStruct3Tag[uint32_t, uint32_t, Ptr[Clay_String]] | |
| def apply()(using Zone): Ptr[Clay__StringArray] = scala.scalanative.unsafe.alloc[Clay__StringArray](1) | |
| def apply(capacity : uint32_t, length : uint32_t, internalArray : Ptr[Clay_String])(using Zone): Ptr[Clay__StringArray] = | |
| val ____ptr = apply() | |
| (!____ptr).capacity = capacity | |
| (!____ptr).length = length | |
| (!____ptr).internalArray = internalArray | |
| ____ptr | |
| extension (struct: Clay__StringArray) | |
| def capacity : uint32_t = struct._1 | |
| def capacity_=(value: uint32_t): Unit = !struct.at1 = value | |
| def length : uint32_t = struct._2 | |
| def length_=(value: uint32_t): Unit = !struct.at2 = value | |
| def internalArray : Ptr[Clay_String] = struct._3 | |
| def internalArray_=(value: Ptr[Clay_String]): Unit = !struct.at3 = value | |
| object unions: | |
| import _root_.clay.enumerations.* | |
| import _root_.clay.predef.* | |
| import _root_.clay.aliases.* | |
| import _root_.clay.structs.* | |
| import _root_.clay.unions.* | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| opaque type Clay_ElementConfigUnion = CArray[Byte, Nat._8] | |
| object Clay_ElementConfigUnion: | |
| given _tag: Tag[Clay_ElementConfigUnion] = Tag.CArray[CChar, Nat._8](Tag.Byte, Tag.Nat8) | |
| def apply()(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| ___ptr | |
| @scala.annotation.targetName("apply_rectangleElementConfig") | |
| def apply(rectangleElementConfig: Ptr[Clay_RectangleElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_RectangleElementConfig]]].update(0, rectangleElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_textElementConfig") | |
| def apply(textElementConfig: Ptr[Clay_TextElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_TextElementConfig]]].update(0, textElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_imageElementConfig") | |
| def apply(imageElementConfig: Ptr[Clay_ImageElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_ImageElementConfig]]].update(0, imageElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_floatingElementConfig") | |
| def apply(floatingElementConfig: Ptr[Clay_FloatingElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_FloatingElementConfig]]].update(0, floatingElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_customElementConfig") | |
| def apply(customElementConfig: Ptr[Clay_CustomElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_CustomElementConfig]]].update(0, customElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_scrollElementConfig") | |
| def apply(scrollElementConfig: Ptr[Clay_ScrollElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_ScrollElementConfig]]].update(0, scrollElementConfig) | |
| ___ptr | |
| @scala.annotation.targetName("apply_borderElementConfig") | |
| def apply(borderElementConfig: Ptr[Clay_BorderElementConfig])(using Zone): Ptr[Clay_ElementConfigUnion] = | |
| val ___ptr = alloc[Clay_ElementConfigUnion](1) | |
| val un = !___ptr | |
| un.at(0).asInstanceOf[Ptr[Ptr[Clay_BorderElementConfig]]].update(0, borderElementConfig) | |
| ___ptr | |
| extension (struct: Clay_ElementConfigUnion) | |
| def rectangleElementConfig : Ptr[Clay_RectangleElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_RectangleElementConfig]]] | |
| def rectangleElementConfig_=(value: Ptr[Clay_RectangleElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_RectangleElementConfig]]] = value | |
| def textElementConfig : Ptr[Clay_TextElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_TextElementConfig]]] | |
| def textElementConfig_=(value: Ptr[Clay_TextElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_TextElementConfig]]] = value | |
| def imageElementConfig : Ptr[Clay_ImageElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_ImageElementConfig]]] | |
| def imageElementConfig_=(value: Ptr[Clay_ImageElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_ImageElementConfig]]] = value | |
| def floatingElementConfig : Ptr[Clay_FloatingElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_FloatingElementConfig]]] | |
| def floatingElementConfig_=(value: Ptr[Clay_FloatingElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_FloatingElementConfig]]] = value | |
| def customElementConfig : Ptr[Clay_CustomElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_CustomElementConfig]]] | |
| def customElementConfig_=(value: Ptr[Clay_CustomElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_CustomElementConfig]]] = value | |
| def scrollElementConfig : Ptr[Clay_ScrollElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_ScrollElementConfig]]] | |
| def scrollElementConfig_=(value: Ptr[Clay_ScrollElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_ScrollElementConfig]]] = value | |
| def borderElementConfig : Ptr[Clay_BorderElementConfig] = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_BorderElementConfig]]] | |
| def borderElementConfig_=(value: Ptr[Clay_BorderElementConfig]): Unit = !struct.at(0).asInstanceOf[Ptr[Ptr[Clay_BorderElementConfig]]] = value | |
| @extern | |
| private[clay] object extern_functions: | |
| import _root_.clay.enumerations.* | |
| import _root_.clay.predef.* | |
| import _root_.clay.aliases.* | |
| import _root_.clay.structs.* | |
| import _root_.clay.unions.* | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_BeginLayout(): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_Hovered(): Boolean = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_IsDebugModeEnabled(): Boolean = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_MinMemorySize(): uint32_t = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_OnHover(onHoverFunction : CFuncPtr3[Clay_ElementId, Clay_PointerData, intptr_t, Unit], userData : intptr_t): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_RenderCommandArray_Get(array : Ptr[Clay_RenderCommandArray], index : int32_t): Ptr[Clay_RenderCommand] = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetCullingEnabled(enabled : Boolean): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetDebugModeEnabled(enabled : Boolean): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetMaxElementCount(maxElementCount : uint32_t): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetMaxMeasureTextCacheWordCount(maxMeasureTextCacheWordCount : uint32_t): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetMeasureTextFunction(measureTextFunction : CFuncPtr2[Ptr[Clay_String], Ptr[Clay_TextElementConfig], Clay_Dimensions]): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetQueryScrollOffsetFunction(queryScrollOffsetFunction : CFuncPtr1[uint32_t, Clay_Vector2]): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__AttachElementConfig(config : Clay_ElementConfigUnion, `type` : Clay__ElementConfigType): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__AttachLayoutConfig(config : Ptr[Clay_LayoutConfig]): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__CloseElement(): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__ElementPostConfiguration(): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__Noop(): Unit = extern | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__OpenElement(): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_CreateArenaWithCapacityAndMemory(capacity : uint32_t, offset : Ptr[Byte], __return : Ptr[Clay_Arena]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_EndLayout(__return : Ptr[Clay_RenderCommandArray]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_GetElementId(idString : Ptr[Clay_String], __return : Ptr[Clay_ElementId]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_GetElementIdWithIndex(idString : Ptr[Clay_String], index : uint32_t, __return : Ptr[Clay_ElementId]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_GetScrollContainerData(id : Ptr[Clay_ElementId], __return : Ptr[Clay_ScrollContainerData]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_Initialize(arena : Ptr[Clay_Arena], layoutDimensions : Ptr[Clay_Dimensions], errorHandler : Ptr[Clay_ErrorHandler]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_PointerOver(elementId : Ptr[Clay_ElementId]): Boolean = extern | |
| private[clay] def __sn_wrap_clay_Clay_SetLayoutDimensions(dimensions : Ptr[Clay_Dimensions]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_SetPointerState(position : Ptr[Clay_Vector2], pointerDown : Boolean): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay_UpdateScrollContainers(enableDragScrolling : Boolean, scrollDelta : Ptr[Clay_Vector2], deltaTime : Float): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay__AttachId(id : Ptr[Clay_ElementId]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay__HashString(key : Ptr[Clay_String], offset : uint32_t, seed : uint32_t, __return : Ptr[Clay_ElementId]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay__OpenTextElement(text : Ptr[Clay_String], textConfig : Ptr[Clay_TextElementConfig]): Unit = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreBorderElementConfig(config : Ptr[Clay_BorderElementConfig]): Ptr[Clay_BorderElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreCustomElementConfig(config : Ptr[Clay_CustomElementConfig]): Ptr[Clay_CustomElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreFloatingElementConfig(config : Ptr[Clay_FloatingElementConfig]): Ptr[Clay_FloatingElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreImageElementConfig(config : Ptr[Clay_ImageElementConfig]): Ptr[Clay_ImageElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreLayoutConfig(config : Ptr[Clay_LayoutConfig]): Ptr[Clay_LayoutConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreRectangleElementConfig(config : Ptr[Clay_RectangleElementConfig]): Ptr[Clay_RectangleElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreScrollElementConfig(config : Ptr[Clay_ScrollElementConfig]): Ptr[Clay_ScrollElementConfig] = extern | |
| private[clay] def __sn_wrap_clay_Clay__StoreTextElementConfig(config : Ptr[Clay_TextElementConfig]): Ptr[Clay_TextElementConfig] = extern | |
| object functions: | |
| import _root_.clay.enumerations.* | |
| import _root_.clay.predef.* | |
| import _root_.clay.aliases.* | |
| import _root_.clay.structs.* | |
| import _root_.clay.unions.* | |
| import extern_functions.* | |
| export extern_functions.* | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_CreateArenaWithCapacityAndMemory(capacity : uint32_t, offset : Ptr[Byte])(using Zone): Clay_Arena = | |
| val __ptr_0: Ptr[Clay_Arena] = alloc[Clay_Arena](1) | |
| __sn_wrap_clay_Clay_CreateArenaWithCapacityAndMemory(capacity, offset, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_CreateArenaWithCapacityAndMemory(capacity : uint32_t, offset : Ptr[Byte])(__return : Ptr[Clay_Arena]): Unit = | |
| __sn_wrap_clay_Clay_CreateArenaWithCapacityAndMemory(capacity, offset, __return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_EndLayout()(__return : Ptr[Clay_RenderCommandArray]): Unit = | |
| __sn_wrap_clay_Clay_EndLayout(__return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_EndLayout()(using Zone): Clay_RenderCommandArray = | |
| val __ptr_0: Ptr[Clay_RenderCommandArray] = alloc[Clay_RenderCommandArray](1) | |
| __sn_wrap_clay_Clay_EndLayout((__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementId(idString : Ptr[Clay_String])(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| __sn_wrap_clay_Clay_GetElementId(idString, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementId(idString : Clay_String)(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| val __ptr_1: Ptr[Clay_String] = alloc[Clay_String](1) | |
| !(__ptr_1 + 0) = idString | |
| __sn_wrap_clay_Clay_GetElementId((__ptr_1 + 0), (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementId(idString : Ptr[Clay_String])(__return : Ptr[Clay_ElementId]): Unit = | |
| __sn_wrap_clay_Clay_GetElementId(idString, __return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementIdWithIndex(idString : Ptr[Clay_String], index : uint32_t)(__return : Ptr[Clay_ElementId]): Unit = | |
| __sn_wrap_clay_Clay_GetElementIdWithIndex(idString, index, __return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementIdWithIndex(idString : Ptr[Clay_String], index : uint32_t)(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| __sn_wrap_clay_Clay_GetElementIdWithIndex(idString, index, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetElementIdWithIndex(idString : Clay_String, index : uint32_t)(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| val __ptr_1: Ptr[Clay_String] = alloc[Clay_String](1) | |
| !(__ptr_1 + 0) = idString | |
| __sn_wrap_clay_Clay_GetElementIdWithIndex((__ptr_1 + 0), index, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetScrollContainerData(id : Ptr[Clay_ElementId])(using Zone): Clay_ScrollContainerData = | |
| val __ptr_0: Ptr[Clay_ScrollContainerData] = alloc[Clay_ScrollContainerData](1) | |
| __sn_wrap_clay_Clay_GetScrollContainerData(id, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetScrollContainerData(id : Ptr[Clay_ElementId])(__return : Ptr[Clay_ScrollContainerData]): Unit = | |
| __sn_wrap_clay_Clay_GetScrollContainerData(id, __return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_GetScrollContainerData(id : Clay_ElementId)(using Zone): Clay_ScrollContainerData = | |
| val __ptr_0: Ptr[Clay_ScrollContainerData] = alloc[Clay_ScrollContainerData](1) | |
| val __ptr_1: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| !(__ptr_1 + 0) = id | |
| __sn_wrap_clay_Clay_GetScrollContainerData((__ptr_1 + 0), (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_Initialize(arena : Clay_Arena, layoutDimensions : Clay_Dimensions, errorHandler : Clay_ErrorHandler)(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_Arena] = alloc[Clay_Arena](1) | |
| val __ptr_1: Ptr[Clay_ErrorHandler] = alloc[Clay_ErrorHandler](1) | |
| val __ptr_2: Ptr[Clay_Dimensions] = alloc[Clay_Dimensions](1) | |
| !(__ptr_0 + 0) = arena | |
| !(__ptr_2 + 0) = layoutDimensions | |
| !(__ptr_1 + 0) = errorHandler | |
| __sn_wrap_clay_Clay_Initialize((__ptr_0 + 0), (__ptr_2 + 0), (__ptr_1 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_Initialize(arena : Ptr[Clay_Arena], layoutDimensions : Ptr[Clay_Dimensions], errorHandler : Ptr[Clay_ErrorHandler]): Unit = | |
| __sn_wrap_clay_Clay_Initialize(arena, layoutDimensions, errorHandler) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_PointerOver(elementId : Ptr[Clay_ElementId]): Boolean = | |
| __sn_wrap_clay_Clay_PointerOver(elementId) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_PointerOver(elementId : Clay_ElementId)(using Zone): Boolean = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| !(__ptr_0 + 0) = elementId | |
| __sn_wrap_clay_Clay_PointerOver((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetLayoutDimensions(dimensions : Ptr[Clay_Dimensions]): Unit = | |
| __sn_wrap_clay_Clay_SetLayoutDimensions(dimensions) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetLayoutDimensions(dimensions : Clay_Dimensions)(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_Dimensions] = alloc[Clay_Dimensions](1) | |
| !(__ptr_0 + 0) = dimensions | |
| __sn_wrap_clay_Clay_SetLayoutDimensions((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetPointerState(position : Ptr[Clay_Vector2], pointerDown : Boolean): Unit = | |
| __sn_wrap_clay_Clay_SetPointerState(position, pointerDown) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_SetPointerState(position : Clay_Vector2, pointerDown : Boolean)(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_Vector2] = alloc[Clay_Vector2](1) | |
| !(__ptr_0 + 0) = position | |
| __sn_wrap_clay_Clay_SetPointerState((__ptr_0 + 0), pointerDown) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_UpdateScrollContainers(enableDragScrolling : Boolean, scrollDelta : Clay_Vector2, deltaTime : Float)(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_Vector2] = alloc[Clay_Vector2](1) | |
| !(__ptr_0 + 0) = scrollDelta | |
| __sn_wrap_clay_Clay_UpdateScrollContainers(enableDragScrolling, (__ptr_0 + 0), deltaTime) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay_UpdateScrollContainers(enableDragScrolling : Boolean, scrollDelta : Ptr[Clay_Vector2], deltaTime : Float): Unit = | |
| __sn_wrap_clay_Clay_UpdateScrollContainers(enableDragScrolling, scrollDelta, deltaTime) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__AttachId(id : Ptr[Clay_ElementId]): Unit = | |
| __sn_wrap_clay_Clay__AttachId(id) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__AttachId(id : Clay_ElementId)(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| !(__ptr_0 + 0) = id | |
| __sn_wrap_clay_Clay__AttachId((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__HashString(key : Ptr[Clay_String], offset : uint32_t, seed : uint32_t)(__return : Ptr[Clay_ElementId]): Unit = | |
| __sn_wrap_clay_Clay__HashString(key, offset, seed, __return) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__HashString(key : Clay_String, offset : uint32_t, seed : uint32_t)(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| val __ptr_1: Ptr[Clay_String] = alloc[Clay_String](1) | |
| !(__ptr_1 + 0) = key | |
| __sn_wrap_clay_Clay__HashString((__ptr_1 + 0), offset, seed, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__HashString(key : Ptr[Clay_String], offset : uint32_t, seed : uint32_t)(using Zone): Clay_ElementId = | |
| val __ptr_0: Ptr[Clay_ElementId] = alloc[Clay_ElementId](1) | |
| __sn_wrap_clay_Clay__HashString(key, offset, seed, (__ptr_0 + 0)) | |
| !(__ptr_0 + 0) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__OpenTextElement(text : Ptr[Clay_String], textConfig : Ptr[Clay_TextElementConfig]): Unit = | |
| __sn_wrap_clay_Clay__OpenTextElement(text, textConfig) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__OpenTextElement(text : Clay_String, textConfig : Ptr[Clay_TextElementConfig])(using Zone): Unit = | |
| val __ptr_0: Ptr[Clay_String] = alloc[Clay_String](1) | |
| !(__ptr_0 + 0) = text | |
| __sn_wrap_clay_Clay__OpenTextElement((__ptr_0 + 0), textConfig) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreBorderElementConfig(config : Clay_BorderElementConfig)(using Zone): Ptr[Clay_BorderElementConfig] = | |
| val __ptr_0: Ptr[Clay_BorderElementConfig] = alloc[Clay_BorderElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreBorderElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreBorderElementConfig(config : Ptr[Clay_BorderElementConfig]): Ptr[Clay_BorderElementConfig] = | |
| __sn_wrap_clay_Clay__StoreBorderElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreCustomElementConfig(config : Clay_CustomElementConfig)(using Zone): Ptr[Clay_CustomElementConfig] = | |
| val __ptr_0: Ptr[Clay_CustomElementConfig] = alloc[Clay_CustomElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreCustomElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreCustomElementConfig(config : Ptr[Clay_CustomElementConfig]): Ptr[Clay_CustomElementConfig] = | |
| __sn_wrap_clay_Clay__StoreCustomElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreFloatingElementConfig(config : Clay_FloatingElementConfig)(using Zone): Ptr[Clay_FloatingElementConfig] = | |
| val __ptr_0: Ptr[Clay_FloatingElementConfig] = alloc[Clay_FloatingElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreFloatingElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreFloatingElementConfig(config : Ptr[Clay_FloatingElementConfig]): Ptr[Clay_FloatingElementConfig] = | |
| __sn_wrap_clay_Clay__StoreFloatingElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreImageElementConfig(config : Ptr[Clay_ImageElementConfig]): Ptr[Clay_ImageElementConfig] = | |
| __sn_wrap_clay_Clay__StoreImageElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreImageElementConfig(config : Clay_ImageElementConfig)(using Zone): Ptr[Clay_ImageElementConfig] = | |
| val __ptr_0: Ptr[Clay_ImageElementConfig] = alloc[Clay_ImageElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreImageElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreLayoutConfig(config : Ptr[Clay_LayoutConfig]): Ptr[Clay_LayoutConfig] = | |
| __sn_wrap_clay_Clay__StoreLayoutConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreLayoutConfig(config : Clay_LayoutConfig)(using Zone): Ptr[Clay_LayoutConfig] = | |
| val __ptr_0: Ptr[Clay_LayoutConfig] = alloc[Clay_LayoutConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreLayoutConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreRectangleElementConfig(config : Ptr[Clay_RectangleElementConfig]): Ptr[Clay_RectangleElementConfig] = | |
| __sn_wrap_clay_Clay__StoreRectangleElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreRectangleElementConfig(config : Clay_RectangleElementConfig)(using Zone): Ptr[Clay_RectangleElementConfig] = | |
| val __ptr_0: Ptr[Clay_RectangleElementConfig] = alloc[Clay_RectangleElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreRectangleElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreScrollElementConfig(config : Ptr[Clay_ScrollElementConfig]): Ptr[Clay_ScrollElementConfig] = | |
| __sn_wrap_clay_Clay__StoreScrollElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreScrollElementConfig(config : Clay_ScrollElementConfig)(using Zone): Ptr[Clay_ScrollElementConfig] = | |
| val __ptr_0: Ptr[Clay_ScrollElementConfig] = alloc[Clay_ScrollElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreScrollElementConfig((__ptr_0 + 0)) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreTextElementConfig(config : Ptr[Clay_TextElementConfig]): Ptr[Clay_TextElementConfig] = | |
| __sn_wrap_clay_Clay__StoreTextElementConfig(config) | |
| /** | |
| * [bindgen] header: clay.h | |
| */ | |
| def Clay__StoreTextElementConfig(config : Clay_TextElementConfig)(using Zone): Ptr[Clay_TextElementConfig] = | |
| val __ptr_0: Ptr[Clay_TextElementConfig] = alloc[Clay_TextElementConfig](1) | |
| !(__ptr_0 + 0) = config | |
| __sn_wrap_clay_Clay__StoreTextElementConfig((__ptr_0 + 0)) | |
| object types: | |
| export _root_.clay.structs.* | |
| export _root_.clay.aliases.* | |
| export _root_.clay.unions.* | |
| export _root_.clay.enumerations.* | |
| object all: | |
| export _root_.clay.enumerations.Clay_ErrorType | |
| export _root_.clay.enumerations.Clay_FloatingAttachPointType | |
| export _root_.clay.enumerations.Clay_LayoutAlignmentX | |
| export _root_.clay.enumerations.Clay_LayoutAlignmentY | |
| export _root_.clay.enumerations.Clay_LayoutDirection | |
| export _root_.clay.enumerations.Clay_PointerCaptureMode | |
| export _root_.clay.enumerations.Clay_PointerDataInteractionState | |
| export _root_.clay.enumerations.Clay_RenderCommandType | |
| export _root_.clay.enumerations.Clay_TextElementConfigWrapMode | |
| export _root_.clay.enumerations.Clay__ElementConfigType | |
| export _root_.clay.enumerations.Clay__SizingType | |
| export _root_.clay.aliases.__darwin_intptr_t | |
| export _root_.clay.aliases.int32_t | |
| export _root_.clay.aliases.intptr_t | |
| export _root_.clay.aliases.size_t | |
| export _root_.clay.aliases.uint16_t | |
| export _root_.clay.aliases.uint32_t | |
| export _root_.clay.aliases.uint8_t | |
| export _root_.clay.aliases.uintptr_t | |
| export _root_.clay.structs.Clay_Arena | |
| export _root_.clay.structs.Clay_Border | |
| export _root_.clay.structs.Clay_BorderElementConfig | |
| export _root_.clay.structs.Clay_BoundingBox | |
| export _root_.clay.structs.Clay_ChildAlignment | |
| export _root_.clay.structs.Clay_Color | |
| export _root_.clay.structs.Clay_CornerRadius | |
| export _root_.clay.structs.Clay_CustomElementConfig | |
| export _root_.clay.structs.Clay_Dimensions | |
| export _root_.clay.structs.Clay_ElementConfig | |
| export _root_.clay.structs.Clay_ElementId | |
| export _root_.clay.structs.Clay_ErrorData | |
| export _root_.clay.structs.Clay_ErrorHandler | |
| export _root_.clay.structs.Clay_FloatingAttachPoints | |
| export _root_.clay.structs.Clay_FloatingElementConfig | |
| export _root_.clay.structs.Clay_ImageElementConfig | |
| export _root_.clay.structs.Clay_LayoutConfig | |
| export _root_.clay.structs.Clay_Padding | |
| export _root_.clay.structs.Clay_PointerData | |
| export _root_.clay.structs.Clay_RectangleElementConfig | |
| export _root_.clay.structs.Clay_RenderCommand | |
| export _root_.clay.structs.Clay_RenderCommandArray | |
| export _root_.clay.structs.Clay_ScrollContainerData | |
| export _root_.clay.structs.Clay_ScrollElementConfig | |
| export _root_.clay.structs.Clay_Sizing | |
| export _root_.clay.structs.Clay_SizingAxis | |
| export _root_.clay.structs.Clay_SizingMinMax | |
| export _root_.clay.structs.Clay_String | |
| export _root_.clay.structs.Clay_TextElementConfig | |
| export _root_.clay.structs.Clay_Vector2 | |
| export _root_.clay.structs.Clay__AlignClay_Arena | |
| export _root_.clay.structs.Clay__AlignClay_Border | |
| export _root_.clay.structs.Clay__AlignClay_BorderElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_BoundingBox | |
| export _root_.clay.structs.Clay__AlignClay_ChildAlignment | |
| export _root_.clay.structs.Clay__AlignClay_Color | |
| export _root_.clay.structs.Clay__AlignClay_CornerRadius | |
| export _root_.clay.structs.Clay__AlignClay_CustomElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_Dimensions | |
| export _root_.clay.structs.Clay__AlignClay_ElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_ElementConfigUnion | |
| export _root_.clay.structs.Clay__AlignClay_ElementId | |
| export _root_.clay.structs.Clay__AlignClay_ErrorData | |
| export _root_.clay.structs.Clay__AlignClay_ErrorHandler | |
| export _root_.clay.structs.Clay__AlignClay_ErrorType | |
| export _root_.clay.structs.Clay__AlignClay_FloatingAttachPointType | |
| export _root_.clay.structs.Clay__AlignClay_FloatingAttachPoints | |
| export _root_.clay.structs.Clay__AlignClay_FloatingElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_ImageElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_LayoutAlignmentX | |
| export _root_.clay.structs.Clay__AlignClay_LayoutAlignmentY | |
| export _root_.clay.structs.Clay__AlignClay_LayoutConfig | |
| export _root_.clay.structs.Clay__AlignClay_LayoutDirection | |
| export _root_.clay.structs.Clay__AlignClay_Padding | |
| export _root_.clay.structs.Clay__AlignClay_PointerCaptureMode | |
| export _root_.clay.structs.Clay__AlignClay_PointerData | |
| export _root_.clay.structs.Clay__AlignClay_PointerDataInteractionState | |
| export _root_.clay.structs.Clay__AlignClay_RectangleElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_RenderCommand | |
| export _root_.clay.structs.Clay__AlignClay_RenderCommandArray | |
| export _root_.clay.structs.Clay__AlignClay_RenderCommandType | |
| export _root_.clay.structs.Clay__AlignClay_ScrollContainerData | |
| export _root_.clay.structs.Clay__AlignClay_ScrollElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_Sizing | |
| export _root_.clay.structs.Clay__AlignClay_SizingAxis | |
| export _root_.clay.structs.Clay__AlignClay_SizingMinMax | |
| export _root_.clay.structs.Clay__AlignClay_String | |
| export _root_.clay.structs.Clay__AlignClay_TextElementConfig | |
| export _root_.clay.structs.Clay__AlignClay_TextElementConfigWrapMode | |
| export _root_.clay.structs.Clay__AlignClay_Vector2 | |
| export _root_.clay.structs.Clay__AlignClay__ElementConfigType | |
| export _root_.clay.structs.Clay__AlignClay__SizingType | |
| export _root_.clay.structs.Clay__AlignClay__StringArray | |
| export _root_.clay.structs.Clay__Alignbool | |
| export _root_.clay.structs.Clay__Alignint32_t | |
| export _root_.clay.structs.Clay__Alignpointer | |
| export _root_.clay.structs.Clay__Alignuint8_t | |
| export _root_.clay.structs.Clay__StringArray | |
| export _root_.clay.unions.Clay_ElementConfigUnion | |
| export _root_.clay.functions.Clay_BeginLayout | |
| export _root_.clay.functions.Clay_Hovered | |
| export _root_.clay.functions.Clay_IsDebugModeEnabled | |
| export _root_.clay.functions.Clay_MinMemorySize | |
| export _root_.clay.functions.Clay_OnHover | |
| export _root_.clay.functions.Clay_RenderCommandArray_Get | |
| export _root_.clay.functions.Clay_SetCullingEnabled | |
| export _root_.clay.functions.Clay_SetDebugModeEnabled | |
| export _root_.clay.functions.Clay_SetMaxElementCount | |
| export _root_.clay.functions.Clay_SetMaxMeasureTextCacheWordCount | |
| export _root_.clay.functions.Clay_SetMeasureTextFunction | |
| export _root_.clay.functions.Clay_SetQueryScrollOffsetFunction | |
| export _root_.clay.functions.Clay__AttachElementConfig | |
| export _root_.clay.functions.Clay__AttachLayoutConfig | |
| export _root_.clay.functions.Clay__CloseElement | |
| export _root_.clay.functions.Clay__ElementPostConfiguration | |
| export _root_.clay.functions.Clay__Noop | |
| export _root_.clay.functions.Clay__OpenElement | |
| export _root_.clay.functions.Clay_CreateArenaWithCapacityAndMemory | |
| export _root_.clay.functions.Clay_EndLayout | |
| export _root_.clay.functions.Clay_GetElementId | |
| export _root_.clay.functions.Clay_GetElementIdWithIndex | |
| export _root_.clay.functions.Clay_GetScrollContainerData | |
| export _root_.clay.functions.Clay_Initialize | |
| export _root_.clay.functions.Clay_PointerOver | |
| export _root_.clay.functions.Clay_SetLayoutDimensions | |
| export _root_.clay.functions.Clay_SetPointerState | |
| export _root_.clay.functions.Clay_UpdateScrollContainers | |
| export _root_.clay.functions.Clay__AttachId | |
| export _root_.clay.functions.Clay__HashString | |
| export _root_.clay.functions.Clay__OpenTextElement | |
| export _root_.clay.functions.Clay__StoreBorderElementConfig | |
| export _root_.clay.functions.Clay__StoreCustomElementConfig | |
| export _root_.clay.functions.Clay__StoreFloatingElementConfig | |
| export _root_.clay.functions.Clay__StoreImageElementConfig | |
| export _root_.clay.functions.Clay__StoreLayoutConfig | |
| export _root_.clay.functions.Clay__StoreRectangleElementConfig | |
| export _root_.clay.functions.Clay__StoreScrollElementConfig | |
| export _root_.clay.functions.Clay__StoreTextElementConfig |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment