diff --git a/bindings/jai/.gitignore b/bindings/jai/.gitignore index 246a04a..02edf89 100644 --- a/bindings/jai/.gitignore +++ b/bindings/jai/.gitignore @@ -1,4 +1,5 @@ .build/ -examples/clay_official_website.exe -examples/clay_official_website.pdb +examples/introducing_clay_video_demo/main.exe +examples/introducing_clay_video_demo/main.pdb +examples/introducing_clay_video_demo/main.rdi source/clay.h \ No newline at end of file diff --git a/bindings/jai/clay-jai/windows/clay.lib b/bindings/jai/clay-jai/windows/clay.lib index be26d91..9c30c71 100644 Binary files a/bindings/jai/clay-jai/windows/clay.lib and b/bindings/jai/clay-jai/windows/clay.lib differ diff --git a/bindings/jai/examples/introducing_clay_video_demo/clay_renderer_raylib.jai b/bindings/jai/examples/introducing_clay_video_demo/clay_renderer_raylib.jai index 162f4d9..439fc47 100644 --- a/bindings/jai/examples/introducing_clay_video_demo/clay_renderer_raylib.jai +++ b/bindings/jai/examples/introducing_clay_video_demo/clay_renderer_raylib.jai @@ -54,9 +54,9 @@ raylib_initialize :: (width: s32, height: s32, $$title: string, flags: Raylib.Co Raylib.InitWindow(width, height, c_string_title); } -clay_raylib_render :: (render_commands: *Clay.RenderCommandArray) { +clay_raylib_render :: (render_commands: Clay.RenderCommandArray) { for 0..render_commands.length - 1 { - render_command := Clay.RenderCommandArray_Get(render_commands, cast(s32) it); + render_command := Clay.RenderCommandArray_Get(*render_commands, cast(s32) it); bounding_box := render_command.boundingBox; if #complete render_command.commandType == { diff --git a/bindings/jai/examples/introducing_clay_video_demo/main.jai b/bindings/jai/examples/introducing_clay_video_demo/main.jai index f018722..d697d7a 100644 --- a/bindings/jai/examples/introducing_clay_video_demo/main.jai +++ b/bindings/jai/examples/introducing_clay_video_demo/main.jai @@ -30,7 +30,7 @@ to_jai_string :: (str: Clay.String) -> string { handle_clay_errors :: (error_data: Clay.ErrorData) #c_call { push_context { - print("%", to_jai_string(error_data.errorText)); + log_error("Clay Error : %", to_jai_string(error_data.errorText)); } } @@ -39,15 +39,65 @@ main :: () { raylib_initialize(1024, 768, "Introducing Clay Demo", flags); clay_required_memory := Clay.MinMemorySize(); - clay_memory := Clay.CreateArenaWithCapacityAndMemory(clay_required_memory, alloc(clay_required_memory)); + memory := NewArray(clay_required_memory, u8); + clay_memory := Clay.CreateArenaWithCapacityAndMemory(clay_required_memory, memory.data); Clay.Initialize( clay_memory, Clay.Dimensions.{cast(float, Raylib.GetScreenWidth()), cast(float, Raylib.GetScreenHeight())}, .{handle_clay_errors, 0} ); + Clay.SetMeasureTextFunction(raylib_measure_text); g_raylib_fonts[FONT_ID_BODY_16] = .{ FONT_ID_BODY_16, Raylib.LoadFontEx("resources/Roboto-Regular.ttf", 48, null, 400), }; + Raylib.SetTextureFilter(g_raylib_fonts[FONT_ID_BODY_16].font.texture, .BILINEAR); + + while !Raylib.WindowShouldClose() { + Clay.SetLayoutDimensions(.{ + cast(float, Raylib.GetScreenWidth()), + cast(float, Raylib.GetScreenHeight()), + }); + + mouse_position := Raylib.GetMousePosition(); + scroll_delta := Raylib.GetMouseWheelMoveV(); + Clay.SetPointerState(mouse_position, Raylib.IsMouseButtonDown(0)); + Clay.UpdateScrollContainers(true, scroll_delta, Raylib.GetFrameTime()); + + layout_expand := Clay.Sizing.{ + Clay.SizingGrow(), + Clay.SizingGrow(), + }; + + content_background_config := Clay.RectangleElementConfig.{ + color = .{90, 90, 90, 255}, + cornerRadius = .{8, 8, 8, 8}, + }; + + Clay.BeginLayout(); + if Clay.UI( + Clay.ID("OuterContainer"), + Clay.Layout(.{ + layoutDirection = .TOP_TO_BOTTOM, + sizing = Clay.Sizing.{ + Clay.SizingGrow(), + Clay.SizingGrow(), + }, + padding = .{16, 16}, + childGap = 16, + }), + Clay.Rectangle(.{color = .{43, 41, 51, 255}}) + ) { + + } + + render_commands := Clay.EndLayout(); + + Raylib.BeginDrawing(); + Raylib.ClearBackground(Raylib.BLACK); + clay_raylib_render(render_commands); + Raylib.EndDrawing(); + } + } \ No newline at end of file diff --git a/bindings/jai/examples/introducing_clay_video_demo/resources/Roboto-Regular.ttf b/bindings/jai/examples/introducing_clay_video_demo/resources/Roboto-Regular.ttf new file mode 100644 index 0000000..ddf4bfa Binary files /dev/null and b/bindings/jai/examples/introducing_clay_video_demo/resources/Roboto-Regular.ttf differ diff --git a/bindings/jai/generate.jai b/bindings/jai/generate.jai index abae2eb..219c0dd 100644 --- a/bindings/jai/generate.jai +++ b/bindings/jai/generate.jai @@ -5,13 +5,6 @@ SOURCE_PATH :: "source"; // These have custom declaration in module.jai DECLARATIONS_TO_OMIT :: string.[ "Clay_Vector2", - // "Clay_Color", -]; - -// These types must be included because they are referenced by public types -PRIVATE_DECLARATION_TO_INCLUDE :: string.[ - "Clay__SizingType", - "Clay__ElementConfigType" ]; #if AT_COMPILE_TIME { @@ -40,7 +33,7 @@ generate_bindings :: (args: [] string, minimum_os_version: type_of(Compiler.Buil could_copy := FileUtils.copy_file("../../clay.h", "source/clay.h"); if !could_copy then return false; - defer File.file_delete("source/clay.h"); + defer if !compile_debug then File.file_delete("source/clay.h"); if compile { source_file := tprint("%/clay.c", SOURCE_PATH); @@ -49,20 +42,21 @@ generate_bindings :: (args: [] string, minimum_os_version: type_of(Compiler.Buil #if OS == .WINDOWS { File.make_directory_if_it_does_not_exist("clay-jai/windows", true); - // success &&= BuildCpp.build_cpp_static_lib("clay-jai/windows/clay", source_file, extra=.["/w"], debug=compile_debug); - command := ifx compile_debug { + write_string("Compiling debug...\n"); Process.break_command_into_strings("clang -g -gcodeview -c source\\clay.c"); } else { + write_string("Compiling release...\n"); Process.break_command_into_strings("clang -O3 -c source\\clay.c"); } result := Process.run_command(..command, capture_and_return_output=true, print_captured_output=true); if result.exit_code != 0 then return false; defer File.file_delete("clay.o"); - command = Process.break_command_into_strings("llvm-ar -rc clay-jai/windows/clay.lib clay.o"); + write_string("Linking...\n"); + command = Process.break_command_into_strings("llvm-ar -rcs clay-jai/windows/clay.lib clay.o"); result = Process.run_command(..command, capture_and_return_output=true, print_captured_output=true); - // if result.exit_code != 0 then return false; + if result.exit_code != 0 then return false; } else { // TODO MacOS // TODO Linux @@ -70,6 +64,7 @@ generate_bindings :: (args: [] string, minimum_os_version: type_of(Compiler.Buil } if !success then return false; + write_string("Succesfully built clay\n"); } output_filename: string; @@ -108,9 +103,8 @@ clay_visitor :: (decl: *Generator.Declaration, parent_decl: *Generator.Declarati return .STOP; } - if String.begins_with(decl.name, "Clay__") && !array_find(PRIVATE_DECLARATION_TO_INCLUDE, decl.name) { - decl.decl_flags |= .OMIT_FROM_OUTPUT; - return .STOP; + if String.begins_with(decl.name, "Clay__") { + decl.output_name = String.slice(decl.name, 5, decl.name.count - 5); } } diff --git a/bindings/jai/module.jai b/bindings/jai/module.jai index f079abb..7d792f3 100644 --- a/bindings/jai/module.jai +++ b/bindings/jai/module.jai @@ -1,9 +1,50 @@ Vector2 :: Math.Vector2; +make_string :: (str: string) -> String { + return .{cast(u64, str.count), str.data}; +} + +UI :: (id: ElementId, layout: LayoutConfig, configs: ..ElementConfig, $call := #caller_code) -> bool #must #expand { + _OpenElement(); + _AttachId(id); + _AttachLayoutConfig(_StoreLayoutConfig(layout)); + for configs _AttachElementConfig(it.config, it.type); + _ElementPostConfiguration(); + + // TODO Fix the need to have to add the namespace here + #insert,scope(call) #code defer Clay._CloseElement();; + + return true; + + // `defer _CloseElement(); +} + +ID :: (label: string, index: u32 = 0) -> ElementId { + return _HashString(make_string(label), index, 0); +} + +Layout :: (config: LayoutConfig) -> LayoutConfig { + // We can just return the config because the layout is attached and stored in the UI function + return config; +} + +Rectangle :: (config: RectangleElementConfig) -> ElementConfig { + return .{ + type = .RECTANGLE, + config.rectangleElementConfig = _StoreRectangleElementConfig(config) + }; +} + +SizingGrow :: (size_min_max: SizingMinMax = .{}) -> SizingAxis { + return .{type = .GROW, size = .{minMax = size_min_max}}; +} + #scope_module Math :: #import "Math"; +Compiler :: #import "Compiler"; +ProgramPrint :: #import "Program_Print"; #if OS == .WINDOWS { #load "windows.jai"; diff --git a/bindings/jai/windows.jai b/bindings/jai/windows.jai index ad4e3d0..00b8635 100644 --- a/bindings/jai/windows.jai +++ b/bindings/jai/windows.jai @@ -1,11 +1,29 @@ // // This file was auto-generated using the following command: // -// jai generate.jai - -compile +// jai generate.jai - -compile -debug // +// NOTE: If you need to get the offset for other standard types in the future, add them here. +_Alignpointer :: struct { + c: u8; + x: *void; +} +_Alignbool :: struct { + c: u8; + x: bool; +} +_Alignuint8_t :: struct { + c: u8; + x: u8; +} +_Alignint32_t :: struct { + c: u8; + x: s32; +} + // Utility Structs ------------------------- // Note: Clay_String is not guaranteed to be null terminated. It may be if created from a literal C string, // but it is also used to represent slices. @@ -13,17 +31,47 @@ String :: struct { length: u64; chars: *u8; } +_AlignClay_String :: struct { + c: u8; + // Utility Structs ------------------------- + // Note: Clay_String is not guaranteed to be null terminated. It may be if created from a literal C string, + // but it is also used to represent slices. + x: String; +} + +_StringArray :: struct { + capacity: u32; + length: u32; + internalArray: *String; +} +_AlignClay__StringArray :: struct { + c: u8; + x: _StringArray; +} Arena :: struct { nextAllocation: u64; capacity: u64; memory: *u8; } +_AlignClay_Arena :: struct { + c: u8; + x: Arena; +} Dimensions :: struct { width: float; height: float; } +_AlignClay_Dimensions :: struct { + c: u8; + x: Dimensions; +} + +_AlignClay_Vector2 :: struct { + c: u8; + x: Vector2; +} Color :: struct { r: float; @@ -31,6 +79,10 @@ Color :: struct { b: float; a: float; } +_AlignClay_Color :: struct { + c: u8; + x: Color; +} BoundingBox :: struct { x: float; @@ -38,6 +90,10 @@ BoundingBox :: struct { width: float; height: float; } +_AlignClay_BoundingBox :: struct { + c: u8; + x: BoundingBox; +} // baseId + offset = id ElementId :: struct { @@ -46,6 +102,11 @@ ElementId :: struct { baseId: u32; stringId: String; } +_AlignClay_ElementId :: struct { + c: u8; + // baseId + offset = id + x: ElementId; +} CornerRadius :: struct { topLeft: float; @@ -53,8 +114,12 @@ CornerRadius :: struct { bottomLeft: float; bottomRight: float; } +_AlignClay_CornerRadius :: struct { + c: u8; + x: CornerRadius; +} -ElementConfigType :: enum s32 { +_ElementConfigType :: enum s32 { NONE :: 0; RECTANGLE :: 1; BORDER_CONTAINER :: 2; @@ -72,6 +137,10 @@ ElementConfigType :: enum s32 { CLAY__ELEMENT_CONFIG_TYPE_TEXT :: TEXT; CLAY__ELEMENT_CONFIG_TYPE_CUSTOM :: CUSTOM; } +_AlignClay__ElementConfigType :: struct { + c: u8; + x: _ElementConfigType; +} LayoutDirection :: enum s32 { LEFT_TO_RIGHT :: 0; @@ -79,6 +148,12 @@ LayoutDirection :: enum s32 { CLAY_LEFT_TO_RIGHT :: LEFT_TO_RIGHT; CLAY_TOP_TO_BOTTOM :: TOP_TO_BOTTOM; } +_AlignClay_LayoutDirection :: struct { + c: u8; + // Element Configs --------------------------- + // Layout + x: LayoutDirection; +} LayoutAlignmentX :: enum s32 { LEFT :: 0; @@ -88,6 +163,10 @@ LayoutAlignmentX :: enum s32 { CLAY_ALIGN_X_RIGHT :: RIGHT; CLAY_ALIGN_X_CENTER :: CENTER; } +_AlignClay_LayoutAlignmentX :: struct { + c: u8; + x: LayoutAlignmentX; +} LayoutAlignmentY :: enum s32 { TOP :: 0; @@ -97,8 +176,12 @@ LayoutAlignmentY :: enum s32 { CLAY_ALIGN_Y_BOTTOM :: BOTTOM; CLAY_ALIGN_Y_CENTER :: CENTER; } +_AlignClay_LayoutAlignmentY :: struct { + c: u8; + x: LayoutAlignmentY; +} -SizingType :: enum s32 { +_SizingType :: enum s32 { FIT :: 0; GROW :: 1; PERCENT :: 2; @@ -108,34 +191,58 @@ SizingType :: enum s32 { CLAY__SIZING_TYPE_PERCENT :: PERCENT; CLAY__SIZING_TYPE_FIXED :: FIXED; } +_AlignClay__SizingType :: struct { + c: u8; + x: _SizingType; +} ChildAlignment :: struct { x: LayoutAlignmentX; y: LayoutAlignmentY; } +_AlignClay_ChildAlignment :: struct { + c: u8; + x: ChildAlignment; +} SizingMinMax :: struct { min: float; max: float; } +_AlignClay_SizingMinMax :: struct { + c: u8; + x: SizingMinMax; +} SizingAxis :: struct { size: union { minMax: SizingMinMax; percent: float; }; - type: SizingType; + type: _SizingType; +} +_AlignClay_SizingAxis :: struct { + c: u8; + x: SizingAxis; } Sizing :: struct { width: SizingAxis; height: SizingAxis; } +_AlignClay_Sizing :: struct { + c: u8; + x: Sizing; +} Padding :: struct { x: u16; y: u16; } +_AlignClay_Padding :: struct { + c: u8; + x: Padding; +} LayoutConfig :: struct { sizing: Sizing; @@ -144,6 +251,10 @@ LayoutConfig :: struct { childAlignment: ChildAlignment; layoutDirection: LayoutDirection; } +_AlignClay_LayoutConfig :: struct { + c: u8; + x: LayoutConfig; +} CLAY_LAYOUT_DEFAULT: LayoutConfig #elsewhere clay; @@ -154,6 +265,11 @@ RectangleElementConfig :: struct { cornerRadius: CornerRadius; } +_AlignClay_RectangleElementConfig :: struct { + c: u8; + x: RectangleElementConfig; +} + // Text TextElementConfigWrapMode :: enum s32 { WORDS :: 0; @@ -163,6 +279,11 @@ TextElementConfigWrapMode :: enum s32 { CLAY_TEXT_WRAP_NEWLINES :: NEWLINES; CLAY_TEXT_WRAP_NONE :: NONE; } +_AlignClay_TextElementConfigWrapMode :: struct { + c: u8; + // Text + x: TextElementConfigWrapMode; +} TextElementConfig :: struct { textColor: Color; @@ -173,12 +294,22 @@ TextElementConfig :: struct { wrapMode: TextElementConfigWrapMode; } +_AlignClay_TextElementConfig :: struct { + c: u8; + x: TextElementConfig; +} + // Image ImageElementConfig :: struct { imageData: *void; sourceDimensions: Dimensions; } +_AlignClay_ImageElementConfig :: struct { + c: u8; + x: ImageElementConfig; +} + FloatingAttachPointType :: enum s32 { LEFT_TOP :: 0; LEFT_CENTER :: 1; @@ -199,11 +330,20 @@ FloatingAttachPointType :: enum s32 { CLAY_ATTACH_POINT_RIGHT_CENTER :: RIGHT_CENTER; CLAY_ATTACH_POINT_RIGHT_BOTTOM :: RIGHT_BOTTOM; } +_AlignClay_FloatingAttachPointType :: struct { + c: u8; + // Floating + x: FloatingAttachPointType; +} FloatingAttachPoints :: struct { element: FloatingAttachPointType; parent: FloatingAttachPointType; } +_AlignClay_FloatingAttachPoints :: struct { + c: u8; + x: FloatingAttachPoints; +} PointerCaptureMode :: enum s32 { CAPTURE :: 0; @@ -211,6 +351,10 @@ PointerCaptureMode :: enum s32 { CLAY_POINTER_CAPTURE_MODE_CAPTURE :: CAPTURE; CLAY_POINTER_CAPTURE_MODE_PASSTHROUGH :: PASSTHROUGH; } +_AlignClay_PointerCaptureMode :: struct { + c: u8; + x: PointerCaptureMode; +} FloatingElementConfig :: struct { offset: Vector2; @@ -220,23 +364,42 @@ FloatingElementConfig :: struct { attachment: FloatingAttachPoints; pointerCaptureMode: PointerCaptureMode; } +_AlignClay_FloatingElementConfig :: struct { + c: u8; + x: FloatingElementConfig; +} // Custom CustomElementConfig :: struct { customData: *void; } +_AlignClay_CustomElementConfig :: struct { + c: u8; + x: CustomElementConfig; +} + // Scroll ScrollElementConfig :: struct { horizontal: bool; vertical: bool; } +_AlignClay_ScrollElementConfig :: struct { + c: u8; + // Scroll + x: ScrollElementConfig; +} // Border Border :: struct { width: u32; color: Color; } +_AlignClay_Border :: struct { + c: u8; + // Border + x: Border; +} BorderElementConfig :: struct { left: Border; @@ -246,6 +409,10 @@ BorderElementConfig :: struct { betweenChildren: Border; cornerRadius: CornerRadius; } +_AlignClay_BorderElementConfig :: struct { + c: u8; + x: BorderElementConfig; +} ElementConfigUnion :: union { rectangleElementConfig: *RectangleElementConfig; @@ -256,11 +423,19 @@ ElementConfigUnion :: union { scrollElementConfig: *ScrollElementConfig; borderElementConfig: *BorderElementConfig; } +_AlignClay_ElementConfigUnion :: struct { + c: u8; + x: ElementConfigUnion; +} ElementConfig :: struct { - type: ElementConfigType; + type: _ElementConfigType; config: ElementConfigUnion; } +_AlignClay_ElementConfig :: struct { + c: u8; + x: ElementConfig; +} // Miscellaneous Structs & Enums --------------------------------- ScrollContainerData :: struct { @@ -272,6 +447,11 @@ ScrollContainerData :: struct { config: ScrollElementConfig; found: bool; } +_AlignClay_ScrollContainerData :: struct { + c: u8; + // Miscellaneous Structs & Enums --------------------------------- + x: ScrollContainerData; +} RenderCommandType :: enum s32 { NONE :: 0; @@ -291,6 +471,10 @@ RenderCommandType :: enum s32 { CLAY_RENDER_COMMAND_TYPE_SCISSOR_END :: SCISSOR_END; CLAY_RENDER_COMMAND_TYPE_CUSTOM :: CUSTOM; } +_AlignClay_RenderCommandType :: struct { + c: u8; + x: RenderCommandType; +} RenderCommand :: struct { boundingBox: BoundingBox; @@ -299,12 +483,20 @@ RenderCommand :: struct { id: u32; commandType: RenderCommandType; } +_AlignClay_RenderCommand :: struct { + c: u8; + x: RenderCommand; +} RenderCommandArray :: struct { capacity: u32; length: u32; internalArray: *RenderCommand; } +_AlignClay_RenderCommandArray :: struct { + c: u8; + x: RenderCommandArray; +} PointerDataInteractionState :: enum s32 { PRESSED_THIS_FRAME :: 0; @@ -316,11 +508,19 @@ PointerDataInteractionState :: enum s32 { CLAY_POINTER_DATA_RELEASED_THIS_FRAME :: RELEASED_THIS_FRAME; CLAY_POINTER_DATA_RELEASED :: RELEASED; } +_AlignClay_PointerDataInteractionState :: struct { + c: u8; + x: PointerDataInteractionState; +} PointerData :: struct { position: Vector2; state: PointerDataInteractionState; } +_AlignClay_PointerData :: struct { + c: u8; + x: PointerData; +} ErrorType :: enum s32 { TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED :: 0; @@ -338,17 +538,29 @@ ErrorType :: enum s32 { CLAY_ERROR_TYPE_FLOATING_CONTAINER_PARENT_NOT_FOUND :: FLOATING_CONTAINER_PARENT_NOT_FOUND; CLAY_ERROR_TYPE_INTERNAL_ERROR :: INTERNAL_ERROR; } +_AlignClay_ErrorType :: struct { + c: u8; + x: ErrorType; +} ErrorData :: struct { errorType: ErrorType; errorText: String; userData: u64; } +_AlignClay_ErrorData :: struct { + c: u8; + x: ErrorData; +} ErrorHandler :: struct { errorHandlerFunction: #type (errorText: ErrorData) -> void #c_call; userData: u64; } +_AlignClay_ErrorHandler :: struct { + c: u8; + x: ErrorHandler; +} // Function Forward Declarations --------------------------------- // Public API functions --- @@ -375,6 +587,28 @@ SetCullingEnabled :: (enabled: bool) -> void #foreign clay "Clay_SetCullingEnabl SetMaxElementCount :: (maxElementCount: u32) -> void #foreign clay "Clay_SetMaxElementCount"; SetMaxMeasureTextCacheWordCount :: (maxMeasureTextCacheWordCount: u32) -> void #foreign clay "Clay_SetMaxMeasureTextCacheWordCount"; +// Internal API functions required by macros +_OpenElement :: () -> void #foreign clay "Clay__OpenElement"; +_CloseElement :: () -> void #foreign clay "Clay__CloseElement"; +_StoreLayoutConfig :: (config: LayoutConfig) -> *LayoutConfig #foreign clay "Clay__StoreLayoutConfig"; +_ElementPostConfiguration :: () -> void #foreign clay "Clay__ElementPostConfiguration"; +_AttachId :: (id: ElementId) -> void #foreign clay "Clay__AttachId"; +_AttachLayoutConfig :: (config: *LayoutConfig) -> void #foreign clay "Clay__AttachLayoutConfig"; +_AttachElementConfig :: (config: ElementConfigUnion, type: _ElementConfigType) -> void #foreign clay "Clay__AttachElementConfig"; +_StoreRectangleElementConfig :: (config: RectangleElementConfig) -> *RectangleElementConfig #foreign clay "Clay__StoreRectangleElementConfig"; +_StoreTextElementConfig :: (config: TextElementConfig) -> *TextElementConfig #foreign clay "Clay__StoreTextElementConfig"; +_StoreImageElementConfig :: (config: ImageElementConfig) -> *ImageElementConfig #foreign clay "Clay__StoreImageElementConfig"; +_StoreFloatingElementConfig :: (config: FloatingElementConfig) -> *FloatingElementConfig #foreign clay "Clay__StoreFloatingElementConfig"; +_StoreCustomElementConfig :: (config: CustomElementConfig) -> *CustomElementConfig #foreign clay "Clay__StoreCustomElementConfig"; +_StoreScrollElementConfig :: (config: ScrollElementConfig) -> *ScrollElementConfig #foreign clay "Clay__StoreScrollElementConfig"; +_StoreBorderElementConfig :: (config: BorderElementConfig) -> *BorderElementConfig #foreign clay "Clay__StoreBorderElementConfig"; +_HashString :: (key: String, offset: u32, seed: u32) -> ElementId #foreign clay "Clay__HashString"; +_Noop :: () -> void #foreign clay "Clay__Noop"; +_OpenTextElement :: (text: String, textConfig: *TextElementConfig) -> void #foreign clay "Clay__OpenTextElement"; + +_debugViewHighlightColor: Color #elsewhere clay "Clay__debugViewHighlightColor"; +_debugViewWidth: u32 #elsewhere clay "Clay__debugViewWidth"; + #scope_file #import "Basic"; // For assert @@ -382,6 +616,42 @@ SetMaxMeasureTextCacheWordCount :: (maxMeasureTextCacheWordCount: u32) -> void # clay :: #library,no_dll "clay-jai/windows/clay"; #run { + { + instance: _Alignpointer; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_Alignpointer.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignpointer.c)) == 1, "_Alignpointer.c has unexpected size % instead of 1", size_of(type_of(_Alignpointer.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_Alignpointer.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignpointer.x)) == 8, "_Alignpointer.x has unexpected size % instead of 8", size_of(type_of(_Alignpointer.x))); + assert(size_of(_Alignpointer) == 16, "_Alignpointer has size % instead of 16", size_of(_Alignpointer)); + } + + { + instance: _Alignbool; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_Alignbool.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignbool.c)) == 1, "_Alignbool.c has unexpected size % instead of 1", size_of(type_of(_Alignbool.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 1, "_Alignbool.x has unexpected offset % instead of 1", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignbool.x)) == 1, "_Alignbool.x has unexpected size % instead of 1", size_of(type_of(_Alignbool.x))); + assert(size_of(_Alignbool) == 2, "_Alignbool has size % instead of 2", size_of(_Alignbool)); + } + + { + instance: _Alignuint8_t; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_Alignuint8_t.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignuint8_t.c)) == 1, "_Alignuint8_t.c has unexpected size % instead of 1", size_of(type_of(_Alignuint8_t.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 1, "_Alignuint8_t.x has unexpected offset % instead of 1", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignuint8_t.x)) == 1, "_Alignuint8_t.x has unexpected size % instead of 1", size_of(type_of(_Alignuint8_t.x))); + assert(size_of(_Alignuint8_t) == 2, "_Alignuint8_t has size % instead of 2", size_of(_Alignuint8_t)); + } + + { + instance: _Alignint32_t; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_Alignint32_t.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignint32_t.c)) == 1, "_Alignint32_t.c has unexpected size % instead of 1", size_of(type_of(_Alignint32_t.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_Alignint32_t.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_Alignint32_t.x)) == 4, "_Alignint32_t.x has unexpected size % instead of 4", size_of(type_of(_Alignint32_t.x))); + assert(size_of(_Alignint32_t) == 8, "_Alignint32_t has size % instead of 8", size_of(_Alignint32_t)); + } + { instance: String; assert(((cast(*void)(*instance.length)) - cast(*void)(*instance)) == 0, "String.length has unexpected offset % instead of 0", ((cast(*void)(*instance.length)) - cast(*void)(*instance))); @@ -391,6 +661,35 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(String) == 16, "String has size % instead of 16", size_of(String)); } + { + instance: _AlignClay_String; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_String.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_String.c)) == 1, "_AlignClay_String.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_String.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_String.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_String.x)) == 16, "_AlignClay_String.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_String.x))); + assert(size_of(_AlignClay_String) == 24, "_AlignClay_String has size % instead of 24", size_of(_AlignClay_String)); + } + + { + instance: _StringArray; + assert(((cast(*void)(*instance.capacity)) - cast(*void)(*instance)) == 0, "_StringArray.capacity has unexpected offset % instead of 0", ((cast(*void)(*instance.capacity)) - cast(*void)(*instance))); + assert(size_of(type_of(_StringArray.capacity)) == 4, "_StringArray.capacity has unexpected size % instead of 4", size_of(type_of(_StringArray.capacity))); + assert(((cast(*void)(*instance.length)) - cast(*void)(*instance)) == 4, "_StringArray.length has unexpected offset % instead of 4", ((cast(*void)(*instance.length)) - cast(*void)(*instance))); + assert(size_of(type_of(_StringArray.length)) == 4, "_StringArray.length has unexpected size % instead of 4", size_of(type_of(_StringArray.length))); + assert(((cast(*void)(*instance.internalArray)) - cast(*void)(*instance)) == 8, "_StringArray.internalArray has unexpected offset % instead of 8", ((cast(*void)(*instance.internalArray)) - cast(*void)(*instance))); + assert(size_of(type_of(_StringArray.internalArray)) == 8, "_StringArray.internalArray has unexpected size % instead of 8", size_of(type_of(_StringArray.internalArray))); + assert(size_of(_StringArray) == 16, "_StringArray has size % instead of 16", size_of(_StringArray)); + } + + { + instance: _AlignClay__StringArray; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay__StringArray.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__StringArray.c)) == 1, "_AlignClay__StringArray.c has unexpected size % instead of 1", size_of(type_of(_AlignClay__StringArray.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay__StringArray.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__StringArray.x)) == 16, "_AlignClay__StringArray.x has unexpected size % instead of 16", size_of(type_of(_AlignClay__StringArray.x))); + assert(size_of(_AlignClay__StringArray) == 24, "_AlignClay__StringArray has size % instead of 24", size_of(_AlignClay__StringArray)); + } + { instance: Arena; assert(((cast(*void)(*instance.nextAllocation)) - cast(*void)(*instance)) == 0, "Arena.nextAllocation has unexpected offset % instead of 0", ((cast(*void)(*instance.nextAllocation)) - cast(*void)(*instance))); @@ -402,6 +701,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Arena) == 24, "Arena has size % instead of 24", size_of(Arena)); } + { + instance: _AlignClay_Arena; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Arena.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Arena.c)) == 1, "_AlignClay_Arena.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Arena.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_Arena.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Arena.x)) == 24, "_AlignClay_Arena.x has unexpected size % instead of 24", size_of(type_of(_AlignClay_Arena.x))); + assert(size_of(_AlignClay_Arena) == 32, "_AlignClay_Arena has size % instead of 32", size_of(_AlignClay_Arena)); + } + { instance: Dimensions; assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 0, "Dimensions.width has unexpected offset % instead of 0", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); @@ -411,6 +719,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Dimensions) == 8, "Dimensions has size % instead of 8", size_of(Dimensions)); } + { + instance: _AlignClay_Dimensions; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Dimensions.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Dimensions.c)) == 1, "_AlignClay_Dimensions.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Dimensions.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_Dimensions.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Dimensions.x)) == 8, "_AlignClay_Dimensions.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_Dimensions.x))); + assert(size_of(_AlignClay_Dimensions) == 12, "_AlignClay_Dimensions has size % instead of 12", size_of(_AlignClay_Dimensions)); + } + + { + instance: _AlignClay_Vector2; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Vector2.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Vector2.c)) == 1, "_AlignClay_Vector2.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Vector2.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_Vector2.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Vector2.x)) == 8, "_AlignClay_Vector2.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_Vector2.x))); + assert(size_of(_AlignClay_Vector2) == 12, "_AlignClay_Vector2 has size % instead of 12", size_of(_AlignClay_Vector2)); + } + { instance: Color; assert(((cast(*void)(*instance.r)) - cast(*void)(*instance)) == 0, "Color.r has unexpected offset % instead of 0", ((cast(*void)(*instance.r)) - cast(*void)(*instance))); @@ -424,6 +750,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Color) == 16, "Color has size % instead of 16", size_of(Color)); } + { + instance: _AlignClay_Color; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Color.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Color.c)) == 1, "_AlignClay_Color.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Color.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_Color.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Color.x)) == 16, "_AlignClay_Color.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_Color.x))); + assert(size_of(_AlignClay_Color) == 20, "_AlignClay_Color has size % instead of 20", size_of(_AlignClay_Color)); + } + { instance: BoundingBox; assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "BoundingBox.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); @@ -437,6 +772,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(BoundingBox) == 16, "BoundingBox has size % instead of 16", size_of(BoundingBox)); } + { + instance: _AlignClay_BoundingBox; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_BoundingBox.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_BoundingBox.c)) == 1, "_AlignClay_BoundingBox.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_BoundingBox.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_BoundingBox.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_BoundingBox.x)) == 16, "_AlignClay_BoundingBox.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_BoundingBox.x))); + assert(size_of(_AlignClay_BoundingBox) == 20, "_AlignClay_BoundingBox has size % instead of 20", size_of(_AlignClay_BoundingBox)); + } + { instance: ElementId; assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "ElementId.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); @@ -450,6 +794,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ElementId) == 32, "ElementId has size % instead of 32", size_of(ElementId)); } + { + instance: _AlignClay_ElementId; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ElementId.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementId.c)) == 1, "_AlignClay_ElementId.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ElementId.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ElementId.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementId.x)) == 32, "_AlignClay_ElementId.x has unexpected size % instead of 32", size_of(type_of(_AlignClay_ElementId.x))); + assert(size_of(_AlignClay_ElementId) == 40, "_AlignClay_ElementId has size % instead of 40", size_of(_AlignClay_ElementId)); + } + { instance: CornerRadius; assert(((cast(*void)(*instance.topLeft)) - cast(*void)(*instance)) == 0, "CornerRadius.topLeft has unexpected offset % instead of 0", ((cast(*void)(*instance.topLeft)) - cast(*void)(*instance))); @@ -463,6 +816,60 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(CornerRadius) == 16, "CornerRadius has size % instead of 16", size_of(CornerRadius)); } + { + instance: _AlignClay_CornerRadius; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_CornerRadius.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_CornerRadius.c)) == 1, "_AlignClay_CornerRadius.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_CornerRadius.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_CornerRadius.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_CornerRadius.x)) == 16, "_AlignClay_CornerRadius.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_CornerRadius.x))); + assert(size_of(_AlignClay_CornerRadius) == 20, "_AlignClay_CornerRadius has size % instead of 20", size_of(_AlignClay_CornerRadius)); + } + + { + instance: _AlignClay__ElementConfigType; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay__ElementConfigType.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__ElementConfigType.c)) == 1, "_AlignClay__ElementConfigType.c has unexpected size % instead of 1", size_of(type_of(_AlignClay__ElementConfigType.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay__ElementConfigType.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__ElementConfigType.x)) == 4, "_AlignClay__ElementConfigType.x has unexpected size % instead of 4", size_of(type_of(_AlignClay__ElementConfigType.x))); + assert(size_of(_AlignClay__ElementConfigType) == 8, "_AlignClay__ElementConfigType has size % instead of 8", size_of(_AlignClay__ElementConfigType)); + } + + { + instance: _AlignClay_LayoutDirection; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_LayoutDirection.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutDirection.c)) == 1, "_AlignClay_LayoutDirection.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_LayoutDirection.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_LayoutDirection.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutDirection.x)) == 4, "_AlignClay_LayoutDirection.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_LayoutDirection.x))); + assert(size_of(_AlignClay_LayoutDirection) == 8, "_AlignClay_LayoutDirection has size % instead of 8", size_of(_AlignClay_LayoutDirection)); + } + + { + instance: _AlignClay_LayoutAlignmentX; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_LayoutAlignmentX.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutAlignmentX.c)) == 1, "_AlignClay_LayoutAlignmentX.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_LayoutAlignmentX.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_LayoutAlignmentX.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutAlignmentX.x)) == 4, "_AlignClay_LayoutAlignmentX.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_LayoutAlignmentX.x))); + assert(size_of(_AlignClay_LayoutAlignmentX) == 8, "_AlignClay_LayoutAlignmentX has size % instead of 8", size_of(_AlignClay_LayoutAlignmentX)); + } + + { + instance: _AlignClay_LayoutAlignmentY; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_LayoutAlignmentY.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutAlignmentY.c)) == 1, "_AlignClay_LayoutAlignmentY.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_LayoutAlignmentY.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_LayoutAlignmentY.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutAlignmentY.x)) == 4, "_AlignClay_LayoutAlignmentY.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_LayoutAlignmentY.x))); + assert(size_of(_AlignClay_LayoutAlignmentY) == 8, "_AlignClay_LayoutAlignmentY has size % instead of 8", size_of(_AlignClay_LayoutAlignmentY)); + } + + { + instance: _AlignClay__SizingType; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay__SizingType.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__SizingType.c)) == 1, "_AlignClay__SizingType.c has unexpected size % instead of 1", size_of(type_of(_AlignClay__SizingType.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay__SizingType.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay__SizingType.x)) == 4, "_AlignClay__SizingType.x has unexpected size % instead of 4", size_of(type_of(_AlignClay__SizingType.x))); + assert(size_of(_AlignClay__SizingType) == 8, "_AlignClay__SizingType has size % instead of 8", size_of(_AlignClay__SizingType)); + } + { instance: ChildAlignment; assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "ChildAlignment.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); @@ -472,6 +879,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ChildAlignment) == 8, "ChildAlignment has size % instead of 8", size_of(ChildAlignment)); } + { + instance: _AlignClay_ChildAlignment; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ChildAlignment.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ChildAlignment.c)) == 1, "_AlignClay_ChildAlignment.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ChildAlignment.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_ChildAlignment.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ChildAlignment.x)) == 8, "_AlignClay_ChildAlignment.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_ChildAlignment.x))); + assert(size_of(_AlignClay_ChildAlignment) == 12, "_AlignClay_ChildAlignment has size % instead of 12", size_of(_AlignClay_ChildAlignment)); + } + { instance: SizingMinMax; assert(((cast(*void)(*instance.min)) - cast(*void)(*instance)) == 0, "SizingMinMax.min has unexpected offset % instead of 0", ((cast(*void)(*instance.min)) - cast(*void)(*instance))); @@ -481,6 +897,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(SizingMinMax) == 8, "SizingMinMax has size % instead of 8", size_of(SizingMinMax)); } + { + instance: _AlignClay_SizingMinMax; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_SizingMinMax.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_SizingMinMax.c)) == 1, "_AlignClay_SizingMinMax.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_SizingMinMax.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_SizingMinMax.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_SizingMinMax.x)) == 8, "_AlignClay_SizingMinMax.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_SizingMinMax.x))); + assert(size_of(_AlignClay_SizingMinMax) == 12, "_AlignClay_SizingMinMax has size % instead of 12", size_of(_AlignClay_SizingMinMax)); + } + { instance: SizingAxis; assert(((cast(*void)(*instance.size)) - cast(*void)(*instance)) == 0, "SizingAxis.size has unexpected offset % instead of 0", ((cast(*void)(*instance.size)) - cast(*void)(*instance))); @@ -490,6 +915,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(SizingAxis) == 12, "SizingAxis has size % instead of 12", size_of(SizingAxis)); } + { + instance: _AlignClay_SizingAxis; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_SizingAxis.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_SizingAxis.c)) == 1, "_AlignClay_SizingAxis.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_SizingAxis.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_SizingAxis.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_SizingAxis.x)) == 12, "_AlignClay_SizingAxis.x has unexpected size % instead of 12", size_of(type_of(_AlignClay_SizingAxis.x))); + assert(size_of(_AlignClay_SizingAxis) == 16, "_AlignClay_SizingAxis has size % instead of 16", size_of(_AlignClay_SizingAxis)); + } + { instance: Sizing; assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 0, "Sizing.width has unexpected offset % instead of 0", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); @@ -499,6 +933,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Sizing) == 24, "Sizing has size % instead of 24", size_of(Sizing)); } + { + instance: _AlignClay_Sizing; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Sizing.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Sizing.c)) == 1, "_AlignClay_Sizing.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Sizing.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_Sizing.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Sizing.x)) == 24, "_AlignClay_Sizing.x has unexpected size % instead of 24", size_of(type_of(_AlignClay_Sizing.x))); + assert(size_of(_AlignClay_Sizing) == 28, "_AlignClay_Sizing has size % instead of 28", size_of(_AlignClay_Sizing)); + } + { instance: Padding; assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "Padding.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); @@ -508,6 +951,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Padding) == 4, "Padding has size % instead of 4", size_of(Padding)); } + { + instance: _AlignClay_Padding; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Padding.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Padding.c)) == 1, "_AlignClay_Padding.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Padding.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 2, "_AlignClay_Padding.x has unexpected offset % instead of 2", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Padding.x)) == 4, "_AlignClay_Padding.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_Padding.x))); + assert(size_of(_AlignClay_Padding) == 6, "_AlignClay_Padding has size % instead of 6", size_of(_AlignClay_Padding)); + } + { instance: LayoutConfig; assert(((cast(*void)(*instance.sizing)) - cast(*void)(*instance)) == 0, "LayoutConfig.sizing has unexpected offset % instead of 0", ((cast(*void)(*instance.sizing)) - cast(*void)(*instance))); @@ -523,6 +975,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(LayoutConfig) == 44, "LayoutConfig has size % instead of 44", size_of(LayoutConfig)); } + { + instance: _AlignClay_LayoutConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_LayoutConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutConfig.c)) == 1, "_AlignClay_LayoutConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_LayoutConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_LayoutConfig.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_LayoutConfig.x)) == 44, "_AlignClay_LayoutConfig.x has unexpected size % instead of 44", size_of(type_of(_AlignClay_LayoutConfig.x))); + assert(size_of(_AlignClay_LayoutConfig) == 48, "_AlignClay_LayoutConfig has size % instead of 48", size_of(_AlignClay_LayoutConfig)); + } + { instance: RectangleElementConfig; assert(((cast(*void)(*instance.color)) - cast(*void)(*instance)) == 0, "RectangleElementConfig.color has unexpected offset % instead of 0", ((cast(*void)(*instance.color)) - cast(*void)(*instance))); @@ -532,6 +993,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(RectangleElementConfig) == 32, "RectangleElementConfig has size % instead of 32", size_of(RectangleElementConfig)); } + { + instance: _AlignClay_RectangleElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_RectangleElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RectangleElementConfig.c)) == 1, "_AlignClay_RectangleElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_RectangleElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_RectangleElementConfig.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RectangleElementConfig.x)) == 32, "_AlignClay_RectangleElementConfig.x has unexpected size % instead of 32", size_of(type_of(_AlignClay_RectangleElementConfig.x))); + assert(size_of(_AlignClay_RectangleElementConfig) == 36, "_AlignClay_RectangleElementConfig has size % instead of 36", size_of(_AlignClay_RectangleElementConfig)); + } + + { + instance: _AlignClay_TextElementConfigWrapMode; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_TextElementConfigWrapMode.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_TextElementConfigWrapMode.c)) == 1, "_AlignClay_TextElementConfigWrapMode.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_TextElementConfigWrapMode.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_TextElementConfigWrapMode.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_TextElementConfigWrapMode.x)) == 4, "_AlignClay_TextElementConfigWrapMode.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_TextElementConfigWrapMode.x))); + assert(size_of(_AlignClay_TextElementConfigWrapMode) == 8, "_AlignClay_TextElementConfigWrapMode has size % instead of 8", size_of(_AlignClay_TextElementConfigWrapMode)); + } + { instance: TextElementConfig; assert(((cast(*void)(*instance.textColor)) - cast(*void)(*instance)) == 0, "TextElementConfig.textColor has unexpected offset % instead of 0", ((cast(*void)(*instance.textColor)) - cast(*void)(*instance))); @@ -549,6 +1028,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(TextElementConfig) == 28, "TextElementConfig has size % instead of 28", size_of(TextElementConfig)); } + { + instance: _AlignClay_TextElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_TextElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_TextElementConfig.c)) == 1, "_AlignClay_TextElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_TextElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_TextElementConfig.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_TextElementConfig.x)) == 28, "_AlignClay_TextElementConfig.x has unexpected size % instead of 28", size_of(type_of(_AlignClay_TextElementConfig.x))); + assert(size_of(_AlignClay_TextElementConfig) == 32, "_AlignClay_TextElementConfig has size % instead of 32", size_of(_AlignClay_TextElementConfig)); + } + { instance: ImageElementConfig; assert(((cast(*void)(*instance.imageData)) - cast(*void)(*instance)) == 0, "ImageElementConfig.imageData has unexpected offset % instead of 0", ((cast(*void)(*instance.imageData)) - cast(*void)(*instance))); @@ -558,6 +1046,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ImageElementConfig) == 16, "ImageElementConfig has size % instead of 16", size_of(ImageElementConfig)); } + { + instance: _AlignClay_ImageElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ImageElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ImageElementConfig.c)) == 1, "_AlignClay_ImageElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ImageElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ImageElementConfig.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ImageElementConfig.x)) == 16, "_AlignClay_ImageElementConfig.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_ImageElementConfig.x))); + assert(size_of(_AlignClay_ImageElementConfig) == 24, "_AlignClay_ImageElementConfig has size % instead of 24", size_of(_AlignClay_ImageElementConfig)); + } + + { + instance: _AlignClay_FloatingAttachPointType; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_FloatingAttachPointType.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingAttachPointType.c)) == 1, "_AlignClay_FloatingAttachPointType.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_FloatingAttachPointType.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_FloatingAttachPointType.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingAttachPointType.x)) == 4, "_AlignClay_FloatingAttachPointType.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_FloatingAttachPointType.x))); + assert(size_of(_AlignClay_FloatingAttachPointType) == 8, "_AlignClay_FloatingAttachPointType has size % instead of 8", size_of(_AlignClay_FloatingAttachPointType)); + } + { instance: FloatingAttachPoints; assert(((cast(*void)(*instance.element)) - cast(*void)(*instance)) == 0, "FloatingAttachPoints.element has unexpected offset % instead of 0", ((cast(*void)(*instance.element)) - cast(*void)(*instance))); @@ -567,6 +1073,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(FloatingAttachPoints) == 8, "FloatingAttachPoints has size % instead of 8", size_of(FloatingAttachPoints)); } + { + instance: _AlignClay_FloatingAttachPoints; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_FloatingAttachPoints.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingAttachPoints.c)) == 1, "_AlignClay_FloatingAttachPoints.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_FloatingAttachPoints.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_FloatingAttachPoints.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingAttachPoints.x)) == 8, "_AlignClay_FloatingAttachPoints.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_FloatingAttachPoints.x))); + assert(size_of(_AlignClay_FloatingAttachPoints) == 12, "_AlignClay_FloatingAttachPoints has size % instead of 12", size_of(_AlignClay_FloatingAttachPoints)); + } + + { + instance: _AlignClay_PointerCaptureMode; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_PointerCaptureMode.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerCaptureMode.c)) == 1, "_AlignClay_PointerCaptureMode.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_PointerCaptureMode.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_PointerCaptureMode.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerCaptureMode.x)) == 4, "_AlignClay_PointerCaptureMode.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_PointerCaptureMode.x))); + assert(size_of(_AlignClay_PointerCaptureMode) == 8, "_AlignClay_PointerCaptureMode has size % instead of 8", size_of(_AlignClay_PointerCaptureMode)); + } + { instance: FloatingElementConfig; assert(((cast(*void)(*instance.offset)) - cast(*void)(*instance)) == 0, "FloatingElementConfig.offset has unexpected offset % instead of 0", ((cast(*void)(*instance.offset)) - cast(*void)(*instance))); @@ -584,6 +1108,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(FloatingElementConfig) == 36, "FloatingElementConfig has size % instead of 36", size_of(FloatingElementConfig)); } + { + instance: _AlignClay_FloatingElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_FloatingElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingElementConfig.c)) == 1, "_AlignClay_FloatingElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_FloatingElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_FloatingElementConfig.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_FloatingElementConfig.x)) == 36, "_AlignClay_FloatingElementConfig.x has unexpected size % instead of 36", size_of(type_of(_AlignClay_FloatingElementConfig.x))); + assert(size_of(_AlignClay_FloatingElementConfig) == 40, "_AlignClay_FloatingElementConfig has size % instead of 40", size_of(_AlignClay_FloatingElementConfig)); + } + { instance: CustomElementConfig; assert(((cast(*void)(*instance.customData)) - cast(*void)(*instance)) == 0, "CustomElementConfig.customData has unexpected offset % instead of 0", ((cast(*void)(*instance.customData)) - cast(*void)(*instance))); @@ -591,6 +1124,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(CustomElementConfig) == 8, "CustomElementConfig has size % instead of 8", size_of(CustomElementConfig)); } + { + instance: _AlignClay_CustomElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_CustomElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_CustomElementConfig.c)) == 1, "_AlignClay_CustomElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_CustomElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_CustomElementConfig.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_CustomElementConfig.x)) == 8, "_AlignClay_CustomElementConfig.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_CustomElementConfig.x))); + assert(size_of(_AlignClay_CustomElementConfig) == 16, "_AlignClay_CustomElementConfig has size % instead of 16", size_of(_AlignClay_CustomElementConfig)); + } + { instance: ScrollElementConfig; assert(((cast(*void)(*instance.horizontal)) - cast(*void)(*instance)) == 0, "ScrollElementConfig.horizontal has unexpected offset % instead of 0", ((cast(*void)(*instance.horizontal)) - cast(*void)(*instance))); @@ -600,6 +1142,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ScrollElementConfig) == 2, "ScrollElementConfig has size % instead of 2", size_of(ScrollElementConfig)); } + { + instance: _AlignClay_ScrollElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ScrollElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ScrollElementConfig.c)) == 1, "_AlignClay_ScrollElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ScrollElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 1, "_AlignClay_ScrollElementConfig.x has unexpected offset % instead of 1", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ScrollElementConfig.x)) == 2, "_AlignClay_ScrollElementConfig.x has unexpected size % instead of 2", size_of(type_of(_AlignClay_ScrollElementConfig.x))); + assert(size_of(_AlignClay_ScrollElementConfig) == 3, "_AlignClay_ScrollElementConfig has size % instead of 3", size_of(_AlignClay_ScrollElementConfig)); + } + { instance: Border; assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 0, "Border.width has unexpected offset % instead of 0", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); @@ -609,6 +1160,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(Border) == 20, "Border has size % instead of 20", size_of(Border)); } + { + instance: _AlignClay_Border; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_Border.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Border.c)) == 1, "_AlignClay_Border.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_Border.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_Border.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_Border.x)) == 20, "_AlignClay_Border.x has unexpected size % instead of 20", size_of(type_of(_AlignClay_Border.x))); + assert(size_of(_AlignClay_Border) == 24, "_AlignClay_Border has size % instead of 24", size_of(_AlignClay_Border)); + } + { instance: BorderElementConfig; assert(((cast(*void)(*instance.left)) - cast(*void)(*instance)) == 0, "BorderElementConfig.left has unexpected offset % instead of 0", ((cast(*void)(*instance.left)) - cast(*void)(*instance))); @@ -626,6 +1186,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(BorderElementConfig) == 116, "BorderElementConfig has size % instead of 116", size_of(BorderElementConfig)); } + { + instance: _AlignClay_BorderElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_BorderElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_BorderElementConfig.c)) == 1, "_AlignClay_BorderElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_BorderElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_BorderElementConfig.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_BorderElementConfig.x)) == 116, "_AlignClay_BorderElementConfig.x has unexpected size % instead of 116", size_of(type_of(_AlignClay_BorderElementConfig.x))); + assert(size_of(_AlignClay_BorderElementConfig) == 120, "_AlignClay_BorderElementConfig has size % instead of 120", size_of(_AlignClay_BorderElementConfig)); + } + { instance: ElementConfigUnion; assert(((cast(*void)(*instance.rectangleElementConfig)) - cast(*void)(*instance)) == 0, "ElementConfigUnion.rectangleElementConfig has unexpected offset % instead of 0", ((cast(*void)(*instance.rectangleElementConfig)) - cast(*void)(*instance))); @@ -645,6 +1214,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ElementConfigUnion) == 8, "ElementConfigUnion has size % instead of 8", size_of(ElementConfigUnion)); } + { + instance: _AlignClay_ElementConfigUnion; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ElementConfigUnion.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementConfigUnion.c)) == 1, "_AlignClay_ElementConfigUnion.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ElementConfigUnion.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ElementConfigUnion.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementConfigUnion.x)) == 8, "_AlignClay_ElementConfigUnion.x has unexpected size % instead of 8", size_of(type_of(_AlignClay_ElementConfigUnion.x))); + assert(size_of(_AlignClay_ElementConfigUnion) == 16, "_AlignClay_ElementConfigUnion has size % instead of 16", size_of(_AlignClay_ElementConfigUnion)); + } + { instance: ElementConfig; assert(((cast(*void)(*instance.type)) - cast(*void)(*instance)) == 0, "ElementConfig.type has unexpected offset % instead of 0", ((cast(*void)(*instance.type)) - cast(*void)(*instance))); @@ -654,6 +1232,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ElementConfig) == 16, "ElementConfig has size % instead of 16", size_of(ElementConfig)); } + { + instance: _AlignClay_ElementConfig; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ElementConfig.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementConfig.c)) == 1, "_AlignClay_ElementConfig.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ElementConfig.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ElementConfig.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ElementConfig.x)) == 16, "_AlignClay_ElementConfig.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_ElementConfig.x))); + assert(size_of(_AlignClay_ElementConfig) == 24, "_AlignClay_ElementConfig has size % instead of 24", size_of(_AlignClay_ElementConfig)); + } + { instance: ScrollContainerData; assert(((cast(*void)(*instance.scrollPosition)) - cast(*void)(*instance)) == 0, "ScrollContainerData.scrollPosition has unexpected offset % instead of 0", ((cast(*void)(*instance.scrollPosition)) - cast(*void)(*instance))); @@ -669,6 +1256,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ScrollContainerData) == 32, "ScrollContainerData has size % instead of 32", size_of(ScrollContainerData)); } + { + instance: _AlignClay_ScrollContainerData; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ScrollContainerData.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ScrollContainerData.c)) == 1, "_AlignClay_ScrollContainerData.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ScrollContainerData.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ScrollContainerData.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ScrollContainerData.x)) == 32, "_AlignClay_ScrollContainerData.x has unexpected size % instead of 32", size_of(type_of(_AlignClay_ScrollContainerData.x))); + assert(size_of(_AlignClay_ScrollContainerData) == 40, "_AlignClay_ScrollContainerData has size % instead of 40", size_of(_AlignClay_ScrollContainerData)); + } + + { + instance: _AlignClay_RenderCommandType; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_RenderCommandType.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommandType.c)) == 1, "_AlignClay_RenderCommandType.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_RenderCommandType.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_RenderCommandType.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommandType.x)) == 4, "_AlignClay_RenderCommandType.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_RenderCommandType.x))); + assert(size_of(_AlignClay_RenderCommandType) == 8, "_AlignClay_RenderCommandType has size % instead of 8", size_of(_AlignClay_RenderCommandType)); + } + { instance: RenderCommand; assert(((cast(*void)(*instance.boundingBox)) - cast(*void)(*instance)) == 0, "RenderCommand.boundingBox has unexpected offset % instead of 0", ((cast(*void)(*instance.boundingBox)) - cast(*void)(*instance))); @@ -684,6 +1289,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(RenderCommand) == 48, "RenderCommand has size % instead of 48", size_of(RenderCommand)); } + { + instance: _AlignClay_RenderCommand; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_RenderCommand.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommand.c)) == 1, "_AlignClay_RenderCommand.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_RenderCommand.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_RenderCommand.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommand.x)) == 48, "_AlignClay_RenderCommand.x has unexpected size % instead of 48", size_of(type_of(_AlignClay_RenderCommand.x))); + assert(size_of(_AlignClay_RenderCommand) == 56, "_AlignClay_RenderCommand has size % instead of 56", size_of(_AlignClay_RenderCommand)); + } + { instance: RenderCommandArray; assert(((cast(*void)(*instance.capacity)) - cast(*void)(*instance)) == 0, "RenderCommandArray.capacity has unexpected offset % instead of 0", ((cast(*void)(*instance.capacity)) - cast(*void)(*instance))); @@ -695,6 +1309,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(RenderCommandArray) == 16, "RenderCommandArray has size % instead of 16", size_of(RenderCommandArray)); } + { + instance: _AlignClay_RenderCommandArray; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_RenderCommandArray.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommandArray.c)) == 1, "_AlignClay_RenderCommandArray.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_RenderCommandArray.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_RenderCommandArray.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_RenderCommandArray.x)) == 16, "_AlignClay_RenderCommandArray.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_RenderCommandArray.x))); + assert(size_of(_AlignClay_RenderCommandArray) == 24, "_AlignClay_RenderCommandArray has size % instead of 24", size_of(_AlignClay_RenderCommandArray)); + } + + { + instance: _AlignClay_PointerDataInteractionState; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_PointerDataInteractionState.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerDataInteractionState.c)) == 1, "_AlignClay_PointerDataInteractionState.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_PointerDataInteractionState.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_PointerDataInteractionState.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerDataInteractionState.x)) == 4, "_AlignClay_PointerDataInteractionState.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_PointerDataInteractionState.x))); + assert(size_of(_AlignClay_PointerDataInteractionState) == 8, "_AlignClay_PointerDataInteractionState has size % instead of 8", size_of(_AlignClay_PointerDataInteractionState)); + } + { instance: PointerData; assert(((cast(*void)(*instance.position)) - cast(*void)(*instance)) == 0, "PointerData.position has unexpected offset % instead of 0", ((cast(*void)(*instance.position)) - cast(*void)(*instance))); @@ -704,6 +1336,24 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(PointerData) == 12, "PointerData has size % instead of 12", size_of(PointerData)); } + { + instance: _AlignClay_PointerData; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_PointerData.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerData.c)) == 1, "_AlignClay_PointerData.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_PointerData.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_PointerData.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_PointerData.x)) == 12, "_AlignClay_PointerData.x has unexpected size % instead of 12", size_of(type_of(_AlignClay_PointerData.x))); + assert(size_of(_AlignClay_PointerData) == 16, "_AlignClay_PointerData has size % instead of 16", size_of(_AlignClay_PointerData)); + } + + { + instance: _AlignClay_ErrorType; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ErrorType.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorType.c)) == 1, "_AlignClay_ErrorType.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ErrorType.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 4, "_AlignClay_ErrorType.x has unexpected offset % instead of 4", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorType.x)) == 4, "_AlignClay_ErrorType.x has unexpected size % instead of 4", size_of(type_of(_AlignClay_ErrorType.x))); + assert(size_of(_AlignClay_ErrorType) == 8, "_AlignClay_ErrorType has size % instead of 8", size_of(_AlignClay_ErrorType)); + } + { instance: ErrorData; assert(((cast(*void)(*instance.errorType)) - cast(*void)(*instance)) == 0, "ErrorData.errorType has unexpected offset % instead of 0", ((cast(*void)(*instance.errorType)) - cast(*void)(*instance))); @@ -715,6 +1365,15 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(ErrorData) == 32, "ErrorData has size % instead of 32", size_of(ErrorData)); } + { + instance: _AlignClay_ErrorData; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ErrorData.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorData.c)) == 1, "_AlignClay_ErrorData.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ErrorData.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ErrorData.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorData.x)) == 32, "_AlignClay_ErrorData.x has unexpected size % instead of 32", size_of(type_of(_AlignClay_ErrorData.x))); + assert(size_of(_AlignClay_ErrorData) == 40, "_AlignClay_ErrorData has size % instead of 40", size_of(_AlignClay_ErrorData)); + } + { instance: ErrorHandler; assert(((cast(*void)(*instance.errorHandlerFunction)) - cast(*void)(*instance)) == 0, "ErrorHandler.errorHandlerFunction has unexpected offset % instead of 0", ((cast(*void)(*instance.errorHandlerFunction)) - cast(*void)(*instance))); @@ -723,5 +1382,14 @@ clay :: #library,no_dll "clay-jai/windows/clay"; assert(size_of(type_of(ErrorHandler.userData)) == 8, "ErrorHandler.userData has unexpected size % instead of 8", size_of(type_of(ErrorHandler.userData))); assert(size_of(ErrorHandler) == 16, "ErrorHandler has size % instead of 16", size_of(ErrorHandler)); } + + { + instance: _AlignClay_ErrorHandler; + assert(((cast(*void)(*instance.c)) - cast(*void)(*instance)) == 0, "_AlignClay_ErrorHandler.c has unexpected offset % instead of 0", ((cast(*void)(*instance.c)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorHandler.c)) == 1, "_AlignClay_ErrorHandler.c has unexpected size % instead of 1", size_of(type_of(_AlignClay_ErrorHandler.c))); + assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 8, "_AlignClay_ErrorHandler.x has unexpected offset % instead of 8", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); + assert(size_of(type_of(_AlignClay_ErrorHandler.x)) == 16, "_AlignClay_ErrorHandler.x has unexpected size % instead of 16", size_of(type_of(_AlignClay_ErrorHandler.x))); + assert(size_of(_AlignClay_ErrorHandler) == 24, "_AlignClay_ErrorHandler has size % instead of 24", size_of(_AlignClay_ErrorHandler)); + } }