diff --git a/raylib/README b/raylib/README new file mode 100644 index 0000000..7f6f9fd --- /dev/null +++ b/raylib/README @@ -0,0 +1,27 @@ +------ +raylib +------ + + jai ./generate.jai # generate the bindings (not required) + jai ./examples/basic-window.jai # verify the example compiles + + #import "jc/raylib"; # import raylib + +What +---- + +Auto-generated bindings for raylib 5.5.0 + +How +--- + +These are generated without headers via Jai's +Bindings_Generator module. To change the version of +raylib these bindings use, swap out the library files +in 'win', 'mac', 'linux', and 'wasm' then regenerate the +bindings. + +You will need to rename the windows library files to +have 'lib' as a prefix. This allows us to generate +bindings one time without requiring a separate +raylib_windows file. diff --git a/raylib/generate.jai b/raylib/generate.jai index c560001..8a8d3f7 100644 --- a/raylib/generate.jai +++ b/raylib/generate.jai @@ -1,13 +1,21 @@ +#scope_file; + #run { set_build_options_dc(.{ do_output = false, write_added_strings = false }); + create_opts :: (visitor: Declaration_Visitor = null) -> Generate_Bindings_Options { + opts: Generate_Bindings_Options; + opts.visitor = visitor; + opts.add_generator_command = false; + opts.generate_library_declarations = false; + array_add(*opts.extra_clang_arguments, "-x", "c"); + return opts; + } + + print(".. generating bindings (platform: %)\n\n", OS); - opts: Generate_Bindings_Options; - opts.visitor = rl_enum_visitor; - opts.generate_library_declarations = false; - - LIBRARY_NAME :: "raylib"; + opts := create_opts(rl_enum_visitor); #if OS == .WINDOWS { array_add(*opts.libpaths, "win"); @@ -15,29 +23,25 @@ array_add(*opts.libpaths, "linux"); } else #if OS == .MACOS { array_add(*opts.libpaths, "mac"); - array_add(*opts.system_include_paths, "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include"); } else { assert(false, "unsupported OS: %", OS); } - array_add(*opts.libnames, LIBRARY_NAME); - array_add(*opts.source_files, "lib/raylib.h", "lib/raymath.h"); - array_add(*opts.extra_clang_arguments, "-x", "c"); - array_add(*opts.system_include_paths, GENERATOR_DEFAULT_SYSTEM_INCLUDE_PATH); + array_add(*opts.libnames, "libraylib"); + array_add(*opts.source_files, "lib/raylib.h", "lib/raymath.h"); assert(generate_bindings(opts, "raylib.jai"), "unable to generate bindings for raylib!"); libpaths := opts.libpaths; + libnames := opts.libnames; - opts = .{}; - opts.generate_library_declarations = false; + opts = create_opts(); opts.libpaths = libpaths; + opts.libnames = libnames; array_add(*opts.strip_prefixes, "rl", "RL"); - array_add(*opts.libnames, LIBRARY_NAME); array_add(*opts.source_files, "lib/rlgl.h"); array_add(*opts.extra_clang_arguments, "-x", "c"); - array_add(*opts.system_include_paths, GENERATOR_DEFAULT_SYSTEM_INCLUDE_PATH); assert(generate_bindings(opts, "./rlgl/rlgl.jai"), "unable to generate bindings for raylib!"); } @@ -66,7 +70,8 @@ rl_enum_visitor :: (decl: *Declaration, parent: *Declaration) -> Declaration_Vis if func.name == { case "IsWindowState"; #through; case "SetWindowState"; #through; - case "ClearWindowState"; + case "ClearWindowState"; #through; + case "SetConfigFlags"; replace_type(ftype.arguments, "flags", "ConfigFlags"); case "IsKeyPressed"; #through; diff --git a/raylib/linux/libraygui.a b/raylib/linux/libraygui.a new file mode 100644 index 0000000..46f13cd Binary files /dev/null and b/raylib/linux/libraygui.a differ diff --git a/raylib/linux/libraygui.so b/raylib/linux/libraygui.so new file mode 100644 index 0000000..bf589e0 Binary files /dev/null and b/raylib/linux/libraygui.so differ diff --git a/raylib/linux/raylib.a b/raylib/linux/libraylib.a similarity index 100% rename from raylib/linux/raylib.a rename to raylib/linux/libraylib.a diff --git a/raylib/linux/raylib.so b/raylib/linux/libraylib.so similarity index 100% rename from raylib/linux/raylib.so rename to raylib/linux/libraylib.so diff --git a/raylib/linux/libraylib.so.5.5.0 b/raylib/linux/libraylib.so.5.5.0 new file mode 100755 index 0000000..0771502 Binary files /dev/null and b/raylib/linux/libraylib.so.5.5.0 differ diff --git a/raylib/linux/libraylib.so.550 b/raylib/linux/libraylib.so.550 new file mode 100755 index 0000000..0771502 Binary files /dev/null and b/raylib/linux/libraylib.so.550 differ diff --git a/raylib/mac/libraygui.a b/raylib/mac/libraygui.a new file mode 100644 index 0000000..cd870a0 Binary files /dev/null and b/raylib/mac/libraygui.a differ diff --git a/raylib/mac/libraygui.dylib b/raylib/mac/libraygui.dylib new file mode 100644 index 0000000..9872f7a Binary files /dev/null and b/raylib/mac/libraygui.dylib differ diff --git a/raylib/mac/raylib.dylib b/raylib/mac/libraylib.5.5.0.dylib similarity index 100% rename from raylib/mac/raylib.dylib rename to raylib/mac/libraylib.5.5.0.dylib diff --git a/raylib/mac/libraylib.550.dylib b/raylib/mac/libraylib.550.dylib new file mode 100755 index 0000000..5019b64 Binary files /dev/null and b/raylib/mac/libraylib.550.dylib differ diff --git a/raylib/mac/raylib.a b/raylib/mac/libraylib.a similarity index 100% rename from raylib/mac/raylib.a rename to raylib/mac/libraylib.a diff --git a/raylib/mac/libraylib.dylib b/raylib/mac/libraylib.dylib new file mode 100755 index 0000000..5019b64 Binary files /dev/null and b/raylib/mac/libraylib.dylib differ diff --git a/raylib/module.jai b/raylib/module.jai index 4388feb..dd68c4a 100644 --- a/raylib/module.jai +++ b/raylib/module.jai @@ -30,21 +30,21 @@ RAYWHITE :: Color.{ 245, 245, 245, 255 }; // My own White (raylib logo) #if STATIC { #if OS == { case .WINDOWS; - raylib :: #library,no_dll,link_always "win/raylib"; + libraylib :: #library,no_dll,link_always "win/libraylib"; case .MACOS; - raylib :: #library,no_dll,link_always "mac/raylib"; + libraylib :: #library,no_dll,link_always "mac/libraylib"; case .LINUX; - raylib :: #library,no_dll,link_always "linux/raylib"; + libraylib :: #library,no_dll,link_always "linux/libraylib"; } } else { #if OS == { case .WINDOWS; - raylib :: #library "win/raylib"; + libraylib :: #library "win/libraylib"; case .MACOS; - raylib :: #library "mac/raylib"; + libraylib :: #library "mac/libraylib.550"; case .LINUX; - raylib :: #library "linux/raylib"; + libraylib :: #library "linux/libraylib"; } } diff --git a/raylib/raylib.jai b/raylib/raylib.jai index 702f617..0129fdb 100644 --- a/raylib/raylib.jai +++ b/raylib/raylib.jai @@ -1,7 +1,5 @@ // -// This file was auto-generated using the following command: -// -// jai /Users/judah/Main/cod/jai/jc.jai/raylib/generate.jai +// This file was autogenerated. // @@ -1082,137 +1080,137 @@ LoadFileTextCallback :: #type (fileName: *u8) -> *u8 #c_call; SaveFileTextCallback :: #type (fileName: *u8, text: *u8) -> bool #c_call; // Window-related functions -InitWindow :: (width: s32, height: s32, title: *u8) -> void #foreign raylib; -CloseWindow :: () -> void #foreign raylib; -WindowShouldClose :: () -> bool #foreign raylib; -IsWindowReady :: () -> bool #foreign raylib; -IsWindowFullscreen :: () -> bool #foreign raylib; -IsWindowHidden :: () -> bool #foreign raylib; -IsWindowMinimized :: () -> bool #foreign raylib; -IsWindowMaximized :: () -> bool #foreign raylib; -IsWindowFocused :: () -> bool #foreign raylib; -IsWindowResized :: () -> bool #foreign raylib; -IsWindowState :: (flag: u32) -> bool #foreign raylib; -SetWindowState :: (flags: ConfigFlags) -> void #foreign raylib; -ClearWindowState :: (flags: ConfigFlags) -> void #foreign raylib; -ToggleFullscreen :: () -> void #foreign raylib; -ToggleBorderlessWindowed :: () -> void #foreign raylib; -MaximizeWindow :: () -> void #foreign raylib; -MinimizeWindow :: () -> void #foreign raylib; -RestoreWindow :: () -> void #foreign raylib; -SetWindowIcon :: (image: Image) -> void #foreign raylib; -SetWindowIcons :: (images: *Image, count: s32) -> void #foreign raylib; -SetWindowTitle :: (title: *u8) -> void #foreign raylib; -SetWindowPosition :: (x: s32, y: s32) -> void #foreign raylib; -SetWindowMonitor :: (monitor: s32) -> void #foreign raylib; -SetWindowMinSize :: (width: s32, height: s32) -> void #foreign raylib; -SetWindowMaxSize :: (width: s32, height: s32) -> void #foreign raylib; -SetWindowSize :: (width: s32, height: s32) -> void #foreign raylib; -SetWindowOpacity :: (opacity: float) -> void #foreign raylib; -SetWindowFocused :: () -> void #foreign raylib; -GetWindowHandle :: () -> *void #foreign raylib; -GetScreenWidth :: () -> s32 #foreign raylib; -GetScreenHeight :: () -> s32 #foreign raylib; -GetRenderWidth :: () -> s32 #foreign raylib; -GetRenderHeight :: () -> s32 #foreign raylib; -GetMonitorCount :: () -> s32 #foreign raylib; -GetCurrentMonitor :: () -> s32 #foreign raylib; -GetMonitorPosition :: (monitor: s32) -> Vector2 #foreign raylib; -GetMonitorWidth :: (monitor: s32) -> s32 #foreign raylib; -GetMonitorHeight :: (monitor: s32) -> s32 #foreign raylib; -GetMonitorPhysicalWidth :: (monitor: s32) -> s32 #foreign raylib; -GetMonitorPhysicalHeight :: (monitor: s32) -> s32 #foreign raylib; -GetMonitorRefreshRate :: (monitor: s32) -> s32 #foreign raylib; -GetWindowPosition :: () -> Vector2 #foreign raylib; -GetWindowScaleDPI :: () -> Vector2 #foreign raylib; -GetMonitorName :: (monitor: s32) -> *u8 #foreign raylib; -SetClipboardText :: (text: *u8) -> void #foreign raylib; -GetClipboardText :: () -> *u8 #foreign raylib; -GetClipboardImage :: () -> Image #foreign raylib; -EnableEventWaiting :: () -> void #foreign raylib; -DisableEventWaiting :: () -> void #foreign raylib; +InitWindow :: (width: s32, height: s32, title: *u8) -> void #foreign libraylib; +CloseWindow :: () -> void #foreign libraylib; +WindowShouldClose :: () -> bool #foreign libraylib; +IsWindowReady :: () -> bool #foreign libraylib; +IsWindowFullscreen :: () -> bool #foreign libraylib; +IsWindowHidden :: () -> bool #foreign libraylib; +IsWindowMinimized :: () -> bool #foreign libraylib; +IsWindowMaximized :: () -> bool #foreign libraylib; +IsWindowFocused :: () -> bool #foreign libraylib; +IsWindowResized :: () -> bool #foreign libraylib; +IsWindowState :: (flag: u32) -> bool #foreign libraylib; +SetWindowState :: (flags: ConfigFlags) -> void #foreign libraylib; +ClearWindowState :: (flags: ConfigFlags) -> void #foreign libraylib; +ToggleFullscreen :: () -> void #foreign libraylib; +ToggleBorderlessWindowed :: () -> void #foreign libraylib; +MaximizeWindow :: () -> void #foreign libraylib; +MinimizeWindow :: () -> void #foreign libraylib; +RestoreWindow :: () -> void #foreign libraylib; +SetWindowIcon :: (image: Image) -> void #foreign libraylib; +SetWindowIcons :: (images: *Image, count: s32) -> void #foreign libraylib; +SetWindowTitle :: (title: *u8) -> void #foreign libraylib; +SetWindowPosition :: (x: s32, y: s32) -> void #foreign libraylib; +SetWindowMonitor :: (monitor: s32) -> void #foreign libraylib; +SetWindowMinSize :: (width: s32, height: s32) -> void #foreign libraylib; +SetWindowMaxSize :: (width: s32, height: s32) -> void #foreign libraylib; +SetWindowSize :: (width: s32, height: s32) -> void #foreign libraylib; +SetWindowOpacity :: (opacity: float) -> void #foreign libraylib; +SetWindowFocused :: () -> void #foreign libraylib; +GetWindowHandle :: () -> *void #foreign libraylib; +GetScreenWidth :: () -> s32 #foreign libraylib; +GetScreenHeight :: () -> s32 #foreign libraylib; +GetRenderWidth :: () -> s32 #foreign libraylib; +GetRenderHeight :: () -> s32 #foreign libraylib; +GetMonitorCount :: () -> s32 #foreign libraylib; +GetCurrentMonitor :: () -> s32 #foreign libraylib; +GetMonitorPosition :: (monitor: s32) -> Vector2 #foreign libraylib; +GetMonitorWidth :: (monitor: s32) -> s32 #foreign libraylib; +GetMonitorHeight :: (monitor: s32) -> s32 #foreign libraylib; +GetMonitorPhysicalWidth :: (monitor: s32) -> s32 #foreign libraylib; +GetMonitorPhysicalHeight :: (monitor: s32) -> s32 #foreign libraylib; +GetMonitorRefreshRate :: (monitor: s32) -> s32 #foreign libraylib; +GetWindowPosition :: () -> Vector2 #foreign libraylib; +GetWindowScaleDPI :: () -> Vector2 #foreign libraylib; +GetMonitorName :: (monitor: s32) -> *u8 #foreign libraylib; +SetClipboardText :: (text: *u8) -> void #foreign libraylib; +GetClipboardText :: () -> *u8 #foreign libraylib; +GetClipboardImage :: () -> Image #foreign libraylib; +EnableEventWaiting :: () -> void #foreign libraylib; +DisableEventWaiting :: () -> void #foreign libraylib; // Cursor-related functions -ShowCursor :: () -> void #foreign raylib; -HideCursor :: () -> void #foreign raylib; -IsCursorHidden :: () -> bool #foreign raylib; -EnableCursor :: () -> void #foreign raylib; -DisableCursor :: () -> void #foreign raylib; -IsCursorOnScreen :: () -> bool #foreign raylib; +ShowCursor :: () -> void #foreign libraylib; +HideCursor :: () -> void #foreign libraylib; +IsCursorHidden :: () -> bool #foreign libraylib; +EnableCursor :: () -> void #foreign libraylib; +DisableCursor :: () -> void #foreign libraylib; +IsCursorOnScreen :: () -> bool #foreign libraylib; // Drawing-related functions -ClearBackground :: (color: Color) -> void #foreign raylib; -BeginDrawing :: () -> void #foreign raylib; -EndDrawing :: () -> void #foreign raylib; -BeginMode2D :: (camera: Camera2D) -> void #foreign raylib; -EndMode2D :: () -> void #foreign raylib; -BeginMode3D :: (camera: Camera3D) -> void #foreign raylib; -EndMode3D :: () -> void #foreign raylib; -BeginTextureMode :: (target: RenderTexture2D) -> void #foreign raylib; -EndTextureMode :: () -> void #foreign raylib; -BeginShaderMode :: (shader: Shader) -> void #foreign raylib; -EndShaderMode :: () -> void #foreign raylib; -BeginBlendMode :: (mode: s32) -> void #foreign raylib; -EndBlendMode :: () -> void #foreign raylib; -BeginScissorMode :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign raylib; -EndScissorMode :: () -> void #foreign raylib; -BeginVrStereoMode :: (config: VrStereoConfig) -> void #foreign raylib; -EndVrStereoMode :: () -> void #foreign raylib; +ClearBackground :: (color: Color) -> void #foreign libraylib; +BeginDrawing :: () -> void #foreign libraylib; +EndDrawing :: () -> void #foreign libraylib; +BeginMode2D :: (camera: Camera2D) -> void #foreign libraylib; +EndMode2D :: () -> void #foreign libraylib; +BeginMode3D :: (camera: Camera3D) -> void #foreign libraylib; +EndMode3D :: () -> void #foreign libraylib; +BeginTextureMode :: (target: RenderTexture2D) -> void #foreign libraylib; +EndTextureMode :: () -> void #foreign libraylib; +BeginShaderMode :: (shader: Shader) -> void #foreign libraylib; +EndShaderMode :: () -> void #foreign libraylib; +BeginBlendMode :: (mode: s32) -> void #foreign libraylib; +EndBlendMode :: () -> void #foreign libraylib; +BeginScissorMode :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign libraylib; +EndScissorMode :: () -> void #foreign libraylib; +BeginVrStereoMode :: (config: VrStereoConfig) -> void #foreign libraylib; +EndVrStereoMode :: () -> void #foreign libraylib; // VR stereo config functions for VR simulator -LoadVrStereoConfig :: (device: VrDeviceInfo) -> VrStereoConfig #foreign raylib; -UnloadVrStereoConfig :: (config: VrStereoConfig) -> void #foreign raylib; +LoadVrStereoConfig :: (device: VrDeviceInfo) -> VrStereoConfig #foreign libraylib; +UnloadVrStereoConfig :: (config: VrStereoConfig) -> void #foreign libraylib; // Shader management functions // NOTE: Shader functionality is not available on OpenGL 1.1 -LoadShader :: (vsFileName: *u8, fsFileName: *u8) -> Shader #foreign raylib; -LoadShaderFromMemory :: (vsCode: *u8, fsCode: *u8) -> Shader #foreign raylib; -IsShaderValid :: (shader: Shader) -> bool #foreign raylib; -GetShaderLocation :: (shader: Shader, uniformName: *u8) -> s32 #foreign raylib; -GetShaderLocationAttrib :: (shader: Shader, attribName: *u8) -> s32 #foreign raylib; -SetShaderValue :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32) -> void #foreign raylib; -SetShaderValueV :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign raylib; -SetShaderValueMatrix :: (shader: Shader, locIndex: s32, mat: Matrix) -> void #foreign raylib; -SetShaderValueTexture :: (shader: Shader, locIndex: s32, texture: Texture2D) -> void #foreign raylib; -UnloadShader :: (shader: Shader) -> void #foreign raylib; +LoadShader :: (vsFileName: *u8, fsFileName: *u8) -> Shader #foreign libraylib; +LoadShaderFromMemory :: (vsCode: *u8, fsCode: *u8) -> Shader #foreign libraylib; +IsShaderValid :: (shader: Shader) -> bool #foreign libraylib; +GetShaderLocation :: (shader: Shader, uniformName: *u8) -> s32 #foreign libraylib; +GetShaderLocationAttrib :: (shader: Shader, attribName: *u8) -> s32 #foreign libraylib; +SetShaderValue :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32) -> void #foreign libraylib; +SetShaderValueV :: (shader: Shader, locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign libraylib; +SetShaderValueMatrix :: (shader: Shader, locIndex: s32, mat: Matrix) -> void #foreign libraylib; +SetShaderValueTexture :: (shader: Shader, locIndex: s32, texture: Texture2D) -> void #foreign libraylib; +UnloadShader :: (shader: Shader) -> void #foreign libraylib; -GetScreenToWorldRay :: (position: Vector2, camera: Camera) -> Ray #foreign raylib; -GetScreenToWorldRayEx :: (position: Vector2, camera: Camera, width: s32, height: s32) -> Ray #foreign raylib; -GetWorldToScreen :: (position: Vector3, camera: Camera) -> Vector2 #foreign raylib; -GetWorldToScreenEx :: (position: Vector3, camera: Camera, width: s32, height: s32) -> Vector2 #foreign raylib; -GetWorldToScreen2D :: (position: Vector2, camera: Camera2D) -> Vector2 #foreign raylib; -GetScreenToWorld2D :: (position: Vector2, camera: Camera2D) -> Vector2 #foreign raylib; -GetCameraMatrix :: (camera: Camera) -> Matrix #foreign raylib; -GetCameraMatrix2D :: (camera: Camera2D) -> Matrix #foreign raylib; +GetScreenToWorldRay :: (position: Vector2, camera: Camera) -> Ray #foreign libraylib; +GetScreenToWorldRayEx :: (position: Vector2, camera: Camera, width: s32, height: s32) -> Ray #foreign libraylib; +GetWorldToScreen :: (position: Vector3, camera: Camera) -> Vector2 #foreign libraylib; +GetWorldToScreenEx :: (position: Vector3, camera: Camera, width: s32, height: s32) -> Vector2 #foreign libraylib; +GetWorldToScreen2D :: (position: Vector2, camera: Camera2D) -> Vector2 #foreign libraylib; +GetScreenToWorld2D :: (position: Vector2, camera: Camera2D) -> Vector2 #foreign libraylib; +GetCameraMatrix :: (camera: Camera) -> Matrix #foreign libraylib; +GetCameraMatrix2D :: (camera: Camera2D) -> Matrix #foreign libraylib; // Timing-related functions -SetTargetFPS :: (fps: s32) -> void #foreign raylib; -GetFrameTime :: () -> float #foreign raylib; -GetTime :: () -> float64 #foreign raylib; -GetFPS :: () -> s32 #foreign raylib; +SetTargetFPS :: (fps: s32) -> void #foreign libraylib; +GetFrameTime :: () -> float #foreign libraylib; +GetTime :: () -> float64 #foreign libraylib; +GetFPS :: () -> s32 #foreign libraylib; // Custom frame control functions // NOTE: Those functions are intended for advanced users that want full control over the frame processing // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL -SwapScreenBuffer :: () -> void #foreign raylib; -PollInputEvents :: () -> void #foreign raylib; -WaitTime :: (seconds: float64) -> void #foreign raylib; +SwapScreenBuffer :: () -> void #foreign libraylib; +PollInputEvents :: () -> void #foreign libraylib; +WaitTime :: (seconds: float64) -> void #foreign libraylib; // Random values generation functions -SetRandomSeed :: (seed: u32) -> void #foreign raylib; -GetRandomValue :: (min: s32, max: s32) -> s32 #foreign raylib; -LoadRandomSequence :: (count: u32, min: s32, max: s32) -> *s32 #foreign raylib; -UnloadRandomSequence :: (sequence: *s32) -> void #foreign raylib; +SetRandomSeed :: (seed: u32) -> void #foreign libraylib; +GetRandomValue :: (min: s32, max: s32) -> s32 #foreign libraylib; +LoadRandomSequence :: (count: u32, min: s32, max: s32) -> *s32 #foreign libraylib; +UnloadRandomSequence :: (sequence: *s32) -> void #foreign libraylib; // Misc. functions -TakeScreenshot :: (fileName: *u8) -> void #foreign raylib; -SetConfigFlags :: (flags: u32) -> void #foreign raylib; -OpenURL :: (url: *u8) -> void #foreign raylib; +TakeScreenshot :: (fileName: *u8) -> void #foreign libraylib; +SetConfigFlags :: (flags: ConfigFlags) -> void #foreign libraylib; +OpenURL :: (url: *u8) -> void #foreign libraylib; // NOTE: Following functions implemented in module [utils] //------------------------------------------------------------------ -TraceLog_CFormat :: (logLevel: s32, text: *u8, __args: ..Any) -> void #foreign raylib "TraceLog"; +TraceLog_CFormat :: (logLevel: s32, text: *u8, __args: ..Any) -> void #foreign libraylib "TraceLog"; TraceLog :: (logLevel: s32, text: string, __args: ..Any) { push_allocator(temp); formatted_text_builder: String_Builder; @@ -1221,134 +1219,134 @@ TraceLog :: (logLevel: s32, text: string, __args: ..Any) { formatted_text := builder_to_string(*formatted_text_builder); TraceLog_CFormat(logLevel, "%s", formatted_text.data); } @PrintLike -SetTraceLogLevel :: (logLevel: s32) -> void #foreign raylib; -MemAlloc :: (size: u32) -> *void #foreign raylib; -MemRealloc :: (ptr: *void, size: u32) -> *void #foreign raylib; -MemFree :: (ptr: *void) -> void #foreign raylib; +SetTraceLogLevel :: (logLevel: s32) -> void #foreign libraylib; +MemAlloc :: (size: u32) -> *void #foreign libraylib; +MemRealloc :: (ptr: *void, size: u32) -> *void #foreign libraylib; +MemFree :: (ptr: *void) -> void #foreign libraylib; // Set custom callbacks // WARNING: Callbacks setup is intended for advanced users -SetTraceLogCallback :: (callback: TraceLogCallback) -> void #foreign raylib; -SetLoadFileDataCallback :: (callback: LoadFileDataCallback) -> void #foreign raylib; -SetSaveFileDataCallback :: (callback: SaveFileDataCallback) -> void #foreign raylib; -SetLoadFileTextCallback :: (callback: LoadFileTextCallback) -> void #foreign raylib; -SetSaveFileTextCallback :: (callback: SaveFileTextCallback) -> void #foreign raylib; +SetTraceLogCallback :: (callback: TraceLogCallback) -> void #foreign libraylib; +SetLoadFileDataCallback :: (callback: LoadFileDataCallback) -> void #foreign libraylib; +SetSaveFileDataCallback :: (callback: SaveFileDataCallback) -> void #foreign libraylib; +SetLoadFileTextCallback :: (callback: LoadFileTextCallback) -> void #foreign libraylib; +SetSaveFileTextCallback :: (callback: SaveFileTextCallback) -> void #foreign libraylib; // Files management functions -LoadFileData :: (fileName: *u8, dataSize: *s32) -> *u8 #foreign raylib; -UnloadFileData :: (data: *u8) -> void #foreign raylib; -SaveFileData :: (fileName: *u8, data: *void, dataSize: s32) -> bool #foreign raylib; -ExportDataAsCode :: (data: *u8, dataSize: s32, fileName: *u8) -> bool #foreign raylib; -LoadFileText :: (fileName: *u8) -> *u8 #foreign raylib; -UnloadFileText :: (text: *u8) -> void #foreign raylib; -SaveFileText :: (fileName: *u8, text: *u8) -> bool #foreign raylib; +LoadFileData :: (fileName: *u8, dataSize: *s32) -> *u8 #foreign libraylib; +UnloadFileData :: (data: *u8) -> void #foreign libraylib; +SaveFileData :: (fileName: *u8, data: *void, dataSize: s32) -> bool #foreign libraylib; +ExportDataAsCode :: (data: *u8, dataSize: s32, fileName: *u8) -> bool #foreign libraylib; +LoadFileText :: (fileName: *u8) -> *u8 #foreign libraylib; +UnloadFileText :: (text: *u8) -> void #foreign libraylib; +SaveFileText :: (fileName: *u8, text: *u8) -> bool #foreign libraylib; // File system functions -FileExists :: (fileName: *u8) -> bool #foreign raylib; -DirectoryExists :: (dirPath: *u8) -> bool #foreign raylib; -IsFileExtension :: (fileName: *u8, ext: *u8) -> bool #foreign raylib; -GetFileLength :: (fileName: *u8) -> s32 #foreign raylib; -GetFileExtension :: (fileName: *u8) -> *u8 #foreign raylib; -GetFileName :: (filePath: *u8) -> *u8 #foreign raylib; -GetFileNameWithoutExt :: (filePath: *u8) -> *u8 #foreign raylib; -GetDirectoryPath :: (filePath: *u8) -> *u8 #foreign raylib; -GetPrevDirectoryPath :: (dirPath: *u8) -> *u8 #foreign raylib; -GetWorkingDirectory :: () -> *u8 #foreign raylib; -GetApplicationDirectory :: () -> *u8 #foreign raylib; -MakeDirectory :: (dirPath: *u8) -> s32 #foreign raylib; -ChangeDirectory :: (dir: *u8) -> bool #foreign raylib; -IsPathFile :: (path: *u8) -> bool #foreign raylib; -IsFileNameValid :: (fileName: *u8) -> bool #foreign raylib; -LoadDirectoryFiles :: (dirPath: *u8) -> FilePathList #foreign raylib; -LoadDirectoryFilesEx :: (basePath: *u8, filter: *u8, scanSubdirs: bool) -> FilePathList #foreign raylib; -UnloadDirectoryFiles :: (files: FilePathList) -> void #foreign raylib; -IsFileDropped :: () -> bool #foreign raylib; -LoadDroppedFiles :: () -> FilePathList #foreign raylib; -UnloadDroppedFiles :: (files: FilePathList) -> void #foreign raylib; -GetFileModTime :: (fileName: *u8) -> s64 #foreign raylib; +FileExists :: (fileName: *u8) -> bool #foreign libraylib; +DirectoryExists :: (dirPath: *u8) -> bool #foreign libraylib; +IsFileExtension :: (fileName: *u8, ext: *u8) -> bool #foreign libraylib; +GetFileLength :: (fileName: *u8) -> s32 #foreign libraylib; +GetFileExtension :: (fileName: *u8) -> *u8 #foreign libraylib; +GetFileName :: (filePath: *u8) -> *u8 #foreign libraylib; +GetFileNameWithoutExt :: (filePath: *u8) -> *u8 #foreign libraylib; +GetDirectoryPath :: (filePath: *u8) -> *u8 #foreign libraylib; +GetPrevDirectoryPath :: (dirPath: *u8) -> *u8 #foreign libraylib; +GetWorkingDirectory :: () -> *u8 #foreign libraylib; +GetApplicationDirectory :: () -> *u8 #foreign libraylib; +MakeDirectory :: (dirPath: *u8) -> s32 #foreign libraylib; +ChangeDirectory :: (dir: *u8) -> bool #foreign libraylib; +IsPathFile :: (path: *u8) -> bool #foreign libraylib; +IsFileNameValid :: (fileName: *u8) -> bool #foreign libraylib; +LoadDirectoryFiles :: (dirPath: *u8) -> FilePathList #foreign libraylib; +LoadDirectoryFilesEx :: (basePath: *u8, filter: *u8, scanSubdirs: bool) -> FilePathList #foreign libraylib; +UnloadDirectoryFiles :: (files: FilePathList) -> void #foreign libraylib; +IsFileDropped :: () -> bool #foreign libraylib; +LoadDroppedFiles :: () -> FilePathList #foreign libraylib; +UnloadDroppedFiles :: (files: FilePathList) -> void #foreign libraylib; +GetFileModTime :: (fileName: *u8) -> s64 #foreign libraylib; // Compression/Encoding functionality -CompressData :: (data: *u8, dataSize: s32, compDataSize: *s32) -> *u8 #foreign raylib; -DecompressData :: (compData: *u8, compDataSize: s32, dataSize: *s32) -> *u8 #foreign raylib; -EncodeDataBase64 :: (data: *u8, dataSize: s32, outputSize: *s32) -> *u8 #foreign raylib; -DecodeDataBase64 :: (data: *u8, outputSize: *s32) -> *u8 #foreign raylib; -ComputeCRC32 :: (data: *u8, dataSize: s32) -> u32 #foreign raylib; -ComputeMD5 :: (data: *u8, dataSize: s32) -> *u32 #foreign raylib; -ComputeSHA1 :: (data: *u8, dataSize: s32) -> *u32 #foreign raylib; +CompressData :: (data: *u8, dataSize: s32, compDataSize: *s32) -> *u8 #foreign libraylib; +DecompressData :: (compData: *u8, compDataSize: s32, dataSize: *s32) -> *u8 #foreign libraylib; +EncodeDataBase64 :: (data: *u8, dataSize: s32, outputSize: *s32) -> *u8 #foreign libraylib; +DecodeDataBase64 :: (data: *u8, outputSize: *s32) -> *u8 #foreign libraylib; +ComputeCRC32 :: (data: *u8, dataSize: s32) -> u32 #foreign libraylib; +ComputeMD5 :: (data: *u8, dataSize: s32) -> *u32 #foreign libraylib; +ComputeSHA1 :: (data: *u8, dataSize: s32) -> *u32 #foreign libraylib; // Automation events functionality -LoadAutomationEventList :: (fileName: *u8) -> AutomationEventList #foreign raylib; -UnloadAutomationEventList :: (list: AutomationEventList) -> void #foreign raylib; -ExportAutomationEventList :: (list: AutomationEventList, fileName: *u8) -> bool #foreign raylib; -SetAutomationEventList :: (list: *AutomationEventList) -> void #foreign raylib; -SetAutomationEventBaseFrame :: (frame: s32) -> void #foreign raylib; -StartAutomationEventRecording :: () -> void #foreign raylib; -StopAutomationEventRecording :: () -> void #foreign raylib; -PlayAutomationEvent :: (event: AutomationEvent) -> void #foreign raylib; +LoadAutomationEventList :: (fileName: *u8) -> AutomationEventList #foreign libraylib; +UnloadAutomationEventList :: (list: AutomationEventList) -> void #foreign libraylib; +ExportAutomationEventList :: (list: AutomationEventList, fileName: *u8) -> bool #foreign libraylib; +SetAutomationEventList :: (list: *AutomationEventList) -> void #foreign libraylib; +SetAutomationEventBaseFrame :: (frame: s32) -> void #foreign libraylib; +StartAutomationEventRecording :: () -> void #foreign libraylib; +StopAutomationEventRecording :: () -> void #foreign libraylib; +PlayAutomationEvent :: (event: AutomationEvent) -> void #foreign libraylib; // Input-related functions: keyboard -IsKeyPressed :: (key: KeyboardKey) -> bool #foreign raylib; -IsKeyPressedRepeat :: (key: KeyboardKey) -> bool #foreign raylib; -IsKeyDown :: (key: KeyboardKey) -> bool #foreign raylib; -IsKeyReleased :: (key: KeyboardKey) -> bool #foreign raylib; -IsKeyUp :: (key: KeyboardKey) -> bool #foreign raylib; -GetKeyPressed :: () -> s32 #foreign raylib; -GetCharPressed :: () -> s32 #foreign raylib; -SetExitKey :: (key: KeyboardKey) -> void #foreign raylib; +IsKeyPressed :: (key: KeyboardKey) -> bool #foreign libraylib; +IsKeyPressedRepeat :: (key: KeyboardKey) -> bool #foreign libraylib; +IsKeyDown :: (key: KeyboardKey) -> bool #foreign libraylib; +IsKeyReleased :: (key: KeyboardKey) -> bool #foreign libraylib; +IsKeyUp :: (key: KeyboardKey) -> bool #foreign libraylib; +GetKeyPressed :: () -> s32 #foreign libraylib; +GetCharPressed :: () -> s32 #foreign libraylib; +SetExitKey :: (key: KeyboardKey) -> void #foreign libraylib; // Input-related functions: gamepads -IsGamepadAvailable :: (gamepad: s32) -> bool #foreign raylib; -GetGamepadName :: (gamepad: s32) -> *u8 #foreign raylib; -IsGamepadButtonPressed :: (gamepad: s32, button: GamepadButton) -> bool #foreign raylib; -IsGamepadButtonDown :: (gamepad: s32, button: GamepadButton) -> bool #foreign raylib; -IsGamepadButtonReleased :: (gamepad: s32, button: GamepadButton) -> bool #foreign raylib; -IsGamepadButtonUp :: (gamepad: s32, button: GamepadButton) -> bool #foreign raylib; -GetGamepadButtonPressed :: () -> s32 #foreign raylib; -GetGamepadAxisCount :: (gamepad: s32) -> s32 #foreign raylib; -GetGamepadAxisMovement :: (gamepad: s32, axis: GamepadAxis) -> float #foreign raylib; -SetGamepadMappings :: (mappings: *u8) -> s32 #foreign raylib; -SetGamepadVibration :: (gamepad: s32, leftMotor: float, rightMotor: float, duration: float) -> void #foreign raylib; +IsGamepadAvailable :: (gamepad: s32) -> bool #foreign libraylib; +GetGamepadName :: (gamepad: s32) -> *u8 #foreign libraylib; +IsGamepadButtonPressed :: (gamepad: s32, button: GamepadButton) -> bool #foreign libraylib; +IsGamepadButtonDown :: (gamepad: s32, button: GamepadButton) -> bool #foreign libraylib; +IsGamepadButtonReleased :: (gamepad: s32, button: GamepadButton) -> bool #foreign libraylib; +IsGamepadButtonUp :: (gamepad: s32, button: GamepadButton) -> bool #foreign libraylib; +GetGamepadButtonPressed :: () -> s32 #foreign libraylib; +GetGamepadAxisCount :: (gamepad: s32) -> s32 #foreign libraylib; +GetGamepadAxisMovement :: (gamepad: s32, axis: GamepadAxis) -> float #foreign libraylib; +SetGamepadMappings :: (mappings: *u8) -> s32 #foreign libraylib; +SetGamepadVibration :: (gamepad: s32, leftMotor: float, rightMotor: float, duration: float) -> void #foreign libraylib; // Input-related functions: mouse -IsMouseButtonPressed :: (button: MouseButton) -> bool #foreign raylib; -IsMouseButtonDown :: (button: MouseButton) -> bool #foreign raylib; -IsMouseButtonReleased :: (button: MouseButton) -> bool #foreign raylib; -IsMouseButtonUp :: (button: MouseButton) -> bool #foreign raylib; -GetMouseX :: () -> s32 #foreign raylib; -GetMouseY :: () -> s32 #foreign raylib; -GetMousePosition :: () -> Vector2 #foreign raylib; -GetMouseDelta :: () -> Vector2 #foreign raylib; -SetMousePosition :: (x: s32, y: s32) -> void #foreign raylib; -SetMouseOffset :: (offsetX: s32, offsetY: s32) -> void #foreign raylib; -SetMouseScale :: (scaleX: float, scaleY: float) -> void #foreign raylib; -GetMouseWheelMove :: () -> float #foreign raylib; -GetMouseWheelMoveV :: () -> Vector2 #foreign raylib; -SetMouseCursor :: (cursor: s32) -> void #foreign raylib; +IsMouseButtonPressed :: (button: MouseButton) -> bool #foreign libraylib; +IsMouseButtonDown :: (button: MouseButton) -> bool #foreign libraylib; +IsMouseButtonReleased :: (button: MouseButton) -> bool #foreign libraylib; +IsMouseButtonUp :: (button: MouseButton) -> bool #foreign libraylib; +GetMouseX :: () -> s32 #foreign libraylib; +GetMouseY :: () -> s32 #foreign libraylib; +GetMousePosition :: () -> Vector2 #foreign libraylib; +GetMouseDelta :: () -> Vector2 #foreign libraylib; +SetMousePosition :: (x: s32, y: s32) -> void #foreign libraylib; +SetMouseOffset :: (offsetX: s32, offsetY: s32) -> void #foreign libraylib; +SetMouseScale :: (scaleX: float, scaleY: float) -> void #foreign libraylib; +GetMouseWheelMove :: () -> float #foreign libraylib; +GetMouseWheelMoveV :: () -> Vector2 #foreign libraylib; +SetMouseCursor :: (cursor: s32) -> void #foreign libraylib; // Input-related functions: touch -GetTouchX :: () -> s32 #foreign raylib; -GetTouchY :: () -> s32 #foreign raylib; -GetTouchPosition :: (index: s32) -> Vector2 #foreign raylib; -GetTouchPointId :: (index: s32) -> s32 #foreign raylib; -GetTouchPointCount :: () -> s32 #foreign raylib; +GetTouchX :: () -> s32 #foreign libraylib; +GetTouchY :: () -> s32 #foreign libraylib; +GetTouchPosition :: (index: s32) -> Vector2 #foreign libraylib; +GetTouchPointId :: (index: s32) -> s32 #foreign libraylib; +GetTouchPointCount :: () -> s32 #foreign libraylib; //------------------------------------------------------------------------------------ // Gestures and Touch Handling Functions (Module: rgestures) //------------------------------------------------------------------------------------ -SetGesturesEnabled :: (flags: Gesture) -> void #foreign raylib; -IsGestureDetected :: (gesture: Gesture) -> bool #foreign raylib; -GetGestureDetected :: () -> Gesture #foreign raylib; -GetGestureHoldDuration :: () -> float #foreign raylib; -GetGestureDragVector :: () -> Vector2 #foreign raylib; -GetGestureDragAngle :: () -> float #foreign raylib; -GetGesturePinchVector :: () -> Vector2 #foreign raylib; -GetGesturePinchAngle :: () -> float #foreign raylib; +SetGesturesEnabled :: (flags: Gesture) -> void #foreign libraylib; +IsGestureDetected :: (gesture: Gesture) -> bool #foreign libraylib; +GetGestureDetected :: () -> Gesture #foreign libraylib; +GetGestureHoldDuration :: () -> float #foreign libraylib; +GetGestureDragVector :: () -> Vector2 #foreign libraylib; +GetGestureDragAngle :: () -> float #foreign libraylib; +GetGesturePinchVector :: () -> Vector2 #foreign libraylib; +GetGesturePinchAngle :: () -> float #foreign libraylib; //------------------------------------------------------------------------------------ // Camera System Functions (Module: rcamera) //------------------------------------------------------------------------------------ -UpdateCamera :: (camera: *Camera, mode: CameraMode) -> void #foreign raylib; -UpdateCameraPro :: (camera: *Camera, movement: Vector3, rotation: Vector3, zoom: float) -> void #foreign raylib; +UpdateCamera :: (camera: *Camera, mode: CameraMode) -> void #foreign libraylib; +UpdateCameraPro :: (camera: *Camera, movement: Vector3, rotation: Vector3, zoom: float) -> void #foreign libraylib; //------------------------------------------------------------------------------------ // Basic Shapes Drawing Functions (Module: shapes) @@ -1356,261 +1354,261 @@ UpdateCameraPro :: (camera: *Camera, movement: Vector3, rotation: Vector3, zoom: // Set texture and rectangle to be used on shapes drawing // NOTE: It can be useful when using basic shapes and one single font, // defining a font char white rectangle would allow drawing everything in a single draw call -SetShapesTexture :: (texture: Texture2D, source: Rectangle) -> void #foreign raylib; -GetShapesTexture :: () -> Texture2D #foreign raylib; -GetShapesTextureRectangle :: () -> Rectangle #foreign raylib; +SetShapesTexture :: (texture: Texture2D, source: Rectangle) -> void #foreign libraylib; +GetShapesTexture :: () -> Texture2D #foreign libraylib; +GetShapesTextureRectangle :: () -> Rectangle #foreign libraylib; // Basic shapes drawing functions -DrawPixel :: (posX: s32, posY: s32, color: Color) -> void #foreign raylib; -DrawPixelV :: (position: Vector2, color: Color) -> void #foreign raylib; -DrawLine :: (startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color) -> void #foreign raylib; -DrawLineV :: (startPos: Vector2, endPos: Vector2, color: Color) -> void #foreign raylib; -DrawLineEx :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawLineStrip :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign raylib; -DrawLineBezier :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawCircle :: (centerX: s32, centerY: s32, radius: float, color: Color) -> void #foreign raylib; -DrawCircleSector :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign raylib; -DrawCircleSectorLines :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign raylib; -DrawCircleGradient :: (centerX: s32, centerY: s32, radius: float, inner: Color, outer: Color) -> void #foreign raylib; -DrawCircleV :: (center: Vector2, radius: float, color: Color) -> void #foreign raylib; -DrawCircleLines :: (centerX: s32, centerY: s32, radius: float, color: Color) -> void #foreign raylib; -DrawCircleLinesV :: (center: Vector2, radius: float, color: Color) -> void #foreign raylib; -DrawEllipse :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color) -> void #foreign raylib; -DrawEllipseLines :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color) -> void #foreign raylib; -DrawRing :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign raylib; -DrawRingLines :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign raylib; -DrawRectangle :: (posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign raylib; -DrawRectangleV :: (position: Vector2, size: Vector2, color: Color) -> void #foreign raylib; -DrawRectangleRec :: (rec: Rectangle, color: Color) -> void #foreign raylib; -DrawRectanglePro :: (rec: Rectangle, origin: Vector2, rotation: float, color: Color) -> void #foreign raylib; -DrawRectangleGradientV :: (posX: s32, posY: s32, width: s32, height: s32, top: Color, bottom: Color) -> void #foreign raylib; -DrawRectangleGradientH :: (posX: s32, posY: s32, width: s32, height: s32, left: Color, right: Color) -> void #foreign raylib; -DrawRectangleGradientEx :: (rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color) -> void #foreign raylib; -DrawRectangleLines :: (posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign raylib; -DrawRectangleLinesEx :: (rec: Rectangle, lineThick: float, color: Color) -> void #foreign raylib; -DrawRectangleRounded :: (rec: Rectangle, roundness: float, segments: s32, color: Color) -> void #foreign raylib; -DrawRectangleRoundedLines :: (rec: Rectangle, roundness: float, segments: s32, color: Color) -> void #foreign raylib; -DrawRectangleRoundedLinesEx :: (rec: Rectangle, roundness: float, segments: s32, lineThick: float, color: Color) -> void #foreign raylib; -DrawTriangle :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign raylib; -DrawTriangleLines :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign raylib; -DrawTriangleFan :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign raylib; -DrawTriangleStrip :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign raylib; -DrawPoly :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color) -> void #foreign raylib; -DrawPolyLines :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color) -> void #foreign raylib; -DrawPolyLinesEx :: (center: Vector2, sides: s32, radius: float, rotation: float, lineThick: float, color: Color) -> void #foreign raylib; +DrawPixel :: (posX: s32, posY: s32, color: Color) -> void #foreign libraylib; +DrawPixelV :: (position: Vector2, color: Color) -> void #foreign libraylib; +DrawLine :: (startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color) -> void #foreign libraylib; +DrawLineV :: (startPos: Vector2, endPos: Vector2, color: Color) -> void #foreign libraylib; +DrawLineEx :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawLineStrip :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign libraylib; +DrawLineBezier :: (startPos: Vector2, endPos: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawCircle :: (centerX: s32, centerY: s32, radius: float, color: Color) -> void #foreign libraylib; +DrawCircleSector :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawCircleSectorLines :: (center: Vector2, radius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawCircleGradient :: (centerX: s32, centerY: s32, radius: float, inner: Color, outer: Color) -> void #foreign libraylib; +DrawCircleV :: (center: Vector2, radius: float, color: Color) -> void #foreign libraylib; +DrawCircleLines :: (centerX: s32, centerY: s32, radius: float, color: Color) -> void #foreign libraylib; +DrawCircleLinesV :: (center: Vector2, radius: float, color: Color) -> void #foreign libraylib; +DrawEllipse :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color) -> void #foreign libraylib; +DrawEllipseLines :: (centerX: s32, centerY: s32, radiusH: float, radiusV: float, color: Color) -> void #foreign libraylib; +DrawRing :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawRingLines :: (center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawRectangle :: (posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign libraylib; +DrawRectangleV :: (position: Vector2, size: Vector2, color: Color) -> void #foreign libraylib; +DrawRectangleRec :: (rec: Rectangle, color: Color) -> void #foreign libraylib; +DrawRectanglePro :: (rec: Rectangle, origin: Vector2, rotation: float, color: Color) -> void #foreign libraylib; +DrawRectangleGradientV :: (posX: s32, posY: s32, width: s32, height: s32, top: Color, bottom: Color) -> void #foreign libraylib; +DrawRectangleGradientH :: (posX: s32, posY: s32, width: s32, height: s32, left: Color, right: Color) -> void #foreign libraylib; +DrawRectangleGradientEx :: (rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color) -> void #foreign libraylib; +DrawRectangleLines :: (posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign libraylib; +DrawRectangleLinesEx :: (rec: Rectangle, lineThick: float, color: Color) -> void #foreign libraylib; +DrawRectangleRounded :: (rec: Rectangle, roundness: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawRectangleRoundedLines :: (rec: Rectangle, roundness: float, segments: s32, color: Color) -> void #foreign libraylib; +DrawRectangleRoundedLinesEx :: (rec: Rectangle, roundness: float, segments: s32, lineThick: float, color: Color) -> void #foreign libraylib; +DrawTriangle :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign libraylib; +DrawTriangleLines :: (v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign libraylib; +DrawTriangleFan :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign libraylib; +DrawTriangleStrip :: (points: *Vector2, pointCount: s32, color: Color) -> void #foreign libraylib; +DrawPoly :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color) -> void #foreign libraylib; +DrawPolyLines :: (center: Vector2, sides: s32, radius: float, rotation: float, color: Color) -> void #foreign libraylib; +DrawPolyLinesEx :: (center: Vector2, sides: s32, radius: float, rotation: float, lineThick: float, color: Color) -> void #foreign libraylib; // Splines drawing functions -DrawSplineLinear :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign raylib; -DrawSplineBasis :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign raylib; -DrawSplineCatmullRom :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign raylib; -DrawSplineBezierQuadratic :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign raylib; -DrawSplineBezierCubic :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign raylib; -DrawSplineSegmentLinear :: (p1: Vector2, p2: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawSplineSegmentBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawSplineSegmentCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawSplineSegmentBezierQuadratic :: (p1: Vector2, c2: Vector2, p3: Vector2, thick: float, color: Color) -> void #foreign raylib; -DrawSplineSegmentBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign raylib; +DrawSplineLinear :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineBasis :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineCatmullRom :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineBezierQuadratic :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineBezierCubic :: (points: *Vector2, pointCount: s32, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineSegmentLinear :: (p1: Vector2, p2: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineSegmentBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineSegmentCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineSegmentBezierQuadratic :: (p1: Vector2, c2: Vector2, p3: Vector2, thick: float, color: Color) -> void #foreign libraylib; +DrawSplineSegmentBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: float, color: Color) -> void #foreign libraylib; // Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] -GetSplinePointLinear :: (startPos: Vector2, endPos: Vector2, t: float) -> Vector2 #foreign raylib; -GetSplinePointBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign raylib; -GetSplinePointCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign raylib; -GetSplinePointBezierQuad :: (p1: Vector2, c2: Vector2, p3: Vector2, t: float) -> Vector2 #foreign raylib; -GetSplinePointBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign raylib; +GetSplinePointLinear :: (startPos: Vector2, endPos: Vector2, t: float) -> Vector2 #foreign libraylib; +GetSplinePointBasis :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign libraylib; +GetSplinePointCatmullRom :: (p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign libraylib; +GetSplinePointBezierQuad :: (p1: Vector2, c2: Vector2, p3: Vector2, t: float) -> Vector2 #foreign libraylib; +GetSplinePointBezierCubic :: (p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: float) -> Vector2 #foreign libraylib; // Basic shapes collision detection functions -CheckCollisionRecs :: (rec1: Rectangle, rec2: Rectangle) -> bool #foreign raylib; -CheckCollisionCircles :: (center1: Vector2, radius1: float, center2: Vector2, radius2: float) -> bool #foreign raylib; -CheckCollisionCircleRec :: (center: Vector2, radius: float, rec: Rectangle) -> bool #foreign raylib; -CheckCollisionCircleLine :: (center: Vector2, radius: float, p1: Vector2, p2: Vector2) -> bool #foreign raylib; -CheckCollisionPointRec :: (point: Vector2, rec: Rectangle) -> bool #foreign raylib; -CheckCollisionPointCircle :: (point: Vector2, center: Vector2, radius: float) -> bool #foreign raylib; -CheckCollisionPointTriangle :: (point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) -> bool #foreign raylib; -CheckCollisionPointLine :: (point: Vector2, p1: Vector2, p2: Vector2, threshold: s32) -> bool #foreign raylib; -CheckCollisionPointPoly :: (point: Vector2, points: *Vector2, pointCount: s32) -> bool #foreign raylib; -CheckCollisionLines :: (startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: *Vector2) -> bool #foreign raylib; -GetCollisionRec :: (rec1: Rectangle, rec2: Rectangle) -> Rectangle #foreign raylib; +CheckCollisionRecs :: (rec1: Rectangle, rec2: Rectangle) -> bool #foreign libraylib; +CheckCollisionCircles :: (center1: Vector2, radius1: float, center2: Vector2, radius2: float) -> bool #foreign libraylib; +CheckCollisionCircleRec :: (center: Vector2, radius: float, rec: Rectangle) -> bool #foreign libraylib; +CheckCollisionCircleLine :: (center: Vector2, radius: float, p1: Vector2, p2: Vector2) -> bool #foreign libraylib; +CheckCollisionPointRec :: (point: Vector2, rec: Rectangle) -> bool #foreign libraylib; +CheckCollisionPointCircle :: (point: Vector2, center: Vector2, radius: float) -> bool #foreign libraylib; +CheckCollisionPointTriangle :: (point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) -> bool #foreign libraylib; +CheckCollisionPointLine :: (point: Vector2, p1: Vector2, p2: Vector2, threshold: s32) -> bool #foreign libraylib; +CheckCollisionPointPoly :: (point: Vector2, points: *Vector2, pointCount: s32) -> bool #foreign libraylib; +CheckCollisionLines :: (startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: *Vector2) -> bool #foreign libraylib; +GetCollisionRec :: (rec1: Rectangle, rec2: Rectangle) -> Rectangle #foreign libraylib; // Image loading functions // NOTE: These functions do not require GPU access -LoadImage :: (fileName: *u8) -> Image #foreign raylib; -LoadImageRaw :: (fileName: *u8, width: s32, height: s32, format: PixelFormat, headerSize: s32) -> Image #foreign raylib; -LoadImageAnim :: (fileName: *u8, frames: *s32) -> Image #foreign raylib; -LoadImageAnimFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, frames: *s32) -> Image #foreign raylib; -LoadImageFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Image #foreign raylib; -LoadImageFromTexture :: (texture: Texture2D) -> Image #foreign raylib; -LoadImageFromScreen :: () -> Image #foreign raylib; -IsImageValid :: (image: Image) -> bool #foreign raylib; -UnloadImage :: (image: Image) -> void #foreign raylib; -ExportImage :: (image: Image, fileName: *u8) -> bool #foreign raylib; -ExportImageToMemory :: (image: Image, fileType: *u8, fileSize: *s32) -> *u8 #foreign raylib; -ExportImageAsCode :: (image: Image, fileName: *u8) -> bool #foreign raylib; +LoadImage :: (fileName: *u8) -> Image #foreign libraylib; +LoadImageRaw :: (fileName: *u8, width: s32, height: s32, format: PixelFormat, headerSize: s32) -> Image #foreign libraylib; +LoadImageAnim :: (fileName: *u8, frames: *s32) -> Image #foreign libraylib; +LoadImageAnimFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, frames: *s32) -> Image #foreign libraylib; +LoadImageFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Image #foreign libraylib; +LoadImageFromTexture :: (texture: Texture2D) -> Image #foreign libraylib; +LoadImageFromScreen :: () -> Image #foreign libraylib; +IsImageValid :: (image: Image) -> bool #foreign libraylib; +UnloadImage :: (image: Image) -> void #foreign libraylib; +ExportImage :: (image: Image, fileName: *u8) -> bool #foreign libraylib; +ExportImageToMemory :: (image: Image, fileType: *u8, fileSize: *s32) -> *u8 #foreign libraylib; +ExportImageAsCode :: (image: Image, fileName: *u8) -> bool #foreign libraylib; // Image generation functions -GenImageColor :: (width: s32, height: s32, color: Color) -> Image #foreign raylib; -GenImageGradientLinear :: (width: s32, height: s32, direction: s32, start: Color, end: Color) -> Image #foreign raylib; -GenImageGradientRadial :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image #foreign raylib; -GenImageGradientSquare :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image #foreign raylib; -GenImageChecked :: (width: s32, height: s32, checksX: s32, checksY: s32, col1: Color, col2: Color) -> Image #foreign raylib; -GenImageWhiteNoise :: (width: s32, height: s32, factor: float) -> Image #foreign raylib; -GenImagePerlinNoise :: (width: s32, height: s32, offsetX: s32, offsetY: s32, scale: float) -> Image #foreign raylib; -GenImageCellular :: (width: s32, height: s32, tileSize: s32) -> Image #foreign raylib; -GenImageText :: (width: s32, height: s32, text: *u8) -> Image #foreign raylib; +GenImageColor :: (width: s32, height: s32, color: Color) -> Image #foreign libraylib; +GenImageGradientLinear :: (width: s32, height: s32, direction: s32, start: Color, end: Color) -> Image #foreign libraylib; +GenImageGradientRadial :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image #foreign libraylib; +GenImageGradientSquare :: (width: s32, height: s32, density: float, inner: Color, outer: Color) -> Image #foreign libraylib; +GenImageChecked :: (width: s32, height: s32, checksX: s32, checksY: s32, col1: Color, col2: Color) -> Image #foreign libraylib; +GenImageWhiteNoise :: (width: s32, height: s32, factor: float) -> Image #foreign libraylib; +GenImagePerlinNoise :: (width: s32, height: s32, offsetX: s32, offsetY: s32, scale: float) -> Image #foreign libraylib; +GenImageCellular :: (width: s32, height: s32, tileSize: s32) -> Image #foreign libraylib; +GenImageText :: (width: s32, height: s32, text: *u8) -> Image #foreign libraylib; // Image manipulation functions -ImageCopy :: (image: Image) -> Image #foreign raylib; -ImageFromImage :: (image: Image, rec: Rectangle) -> Image #foreign raylib; -ImageFromChannel :: (image: Image, selectedChannel: s32) -> Image #foreign raylib; -ImageText :: (text: *u8, fontSize: s32, color: Color) -> Image #foreign raylib; -ImageTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float, tint: Color) -> Image #foreign raylib; -ImageFormat :: (image: *Image, newFormat: PixelFormat) -> void #foreign raylib; -ImageToPOT :: (image: *Image, fill: Color) -> void #foreign raylib; -ImageCrop :: (image: *Image, crop: Rectangle) -> void #foreign raylib; -ImageAlphaCrop :: (image: *Image, threshold: float) -> void #foreign raylib; -ImageAlphaClear :: (image: *Image, color: Color, threshold: float) -> void #foreign raylib; -ImageAlphaMask :: (image: *Image, alphaMask: Image) -> void #foreign raylib; -ImageAlphaPremultiply :: (image: *Image) -> void #foreign raylib; -ImageBlurGaussian :: (image: *Image, blurSize: s32) -> void #foreign raylib; -ImageKernelConvolution :: (image: *Image, kernel: *float, kernelSize: s32) -> void #foreign raylib; -ImageResize :: (image: *Image, newWidth: s32, newHeight: s32) -> void #foreign raylib; -ImageResizeNN :: (image: *Image, newWidth: s32, newHeight: s32) -> void #foreign raylib; -ImageResizeCanvas :: (image: *Image, newWidth: s32, newHeight: s32, offsetX: s32, offsetY: s32, fill: Color) -> void #foreign raylib; -ImageMipmaps :: (image: *Image) -> void #foreign raylib; -ImageDither :: (image: *Image, rBpp: s32, gBpp: s32, bBpp: s32, aBpp: s32) -> void #foreign raylib; -ImageFlipVertical :: (image: *Image) -> void #foreign raylib; -ImageFlipHorizontal :: (image: *Image) -> void #foreign raylib; -ImageRotate :: (image: *Image, degrees: s32) -> void #foreign raylib; -ImageRotateCW :: (image: *Image) -> void #foreign raylib; -ImageRotateCCW :: (image: *Image) -> void #foreign raylib; -ImageColorTint :: (image: *Image, color: Color) -> void #foreign raylib; -ImageColorInvert :: (image: *Image) -> void #foreign raylib; -ImageColorGrayscale :: (image: *Image) -> void #foreign raylib; -ImageColorContrast :: (image: *Image, contrast: float) -> void #foreign raylib; -ImageColorBrightness :: (image: *Image, brightness: s32) -> void #foreign raylib; -ImageColorReplace :: (image: *Image, color: Color, replace: Color) -> void #foreign raylib; -LoadImageColors :: (image: Image) -> *Color #foreign raylib; -LoadImagePalette :: (image: Image, maxPaletteSize: s32, colorCount: *s32) -> *Color #foreign raylib; -UnloadImageColors :: (colors: *Color) -> void #foreign raylib; -UnloadImagePalette :: (colors: *Color) -> void #foreign raylib; -GetImageAlphaBorder :: (image: Image, threshold: float) -> Rectangle #foreign raylib; -GetImageColor :: (image: Image, x: s32, y: s32) -> Color #foreign raylib; +ImageCopy :: (image: Image) -> Image #foreign libraylib; +ImageFromImage :: (image: Image, rec: Rectangle) -> Image #foreign libraylib; +ImageFromChannel :: (image: Image, selectedChannel: s32) -> Image #foreign libraylib; +ImageText :: (text: *u8, fontSize: s32, color: Color) -> Image #foreign libraylib; +ImageTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float, tint: Color) -> Image #foreign libraylib; +ImageFormat :: (image: *Image, newFormat: PixelFormat) -> void #foreign libraylib; +ImageToPOT :: (image: *Image, fill: Color) -> void #foreign libraylib; +ImageCrop :: (image: *Image, crop: Rectangle) -> void #foreign libraylib; +ImageAlphaCrop :: (image: *Image, threshold: float) -> void #foreign libraylib; +ImageAlphaClear :: (image: *Image, color: Color, threshold: float) -> void #foreign libraylib; +ImageAlphaMask :: (image: *Image, alphaMask: Image) -> void #foreign libraylib; +ImageAlphaPremultiply :: (image: *Image) -> void #foreign libraylib; +ImageBlurGaussian :: (image: *Image, blurSize: s32) -> void #foreign libraylib; +ImageKernelConvolution :: (image: *Image, kernel: *float, kernelSize: s32) -> void #foreign libraylib; +ImageResize :: (image: *Image, newWidth: s32, newHeight: s32) -> void #foreign libraylib; +ImageResizeNN :: (image: *Image, newWidth: s32, newHeight: s32) -> void #foreign libraylib; +ImageResizeCanvas :: (image: *Image, newWidth: s32, newHeight: s32, offsetX: s32, offsetY: s32, fill: Color) -> void #foreign libraylib; +ImageMipmaps :: (image: *Image) -> void #foreign libraylib; +ImageDither :: (image: *Image, rBpp: s32, gBpp: s32, bBpp: s32, aBpp: s32) -> void #foreign libraylib; +ImageFlipVertical :: (image: *Image) -> void #foreign libraylib; +ImageFlipHorizontal :: (image: *Image) -> void #foreign libraylib; +ImageRotate :: (image: *Image, degrees: s32) -> void #foreign libraylib; +ImageRotateCW :: (image: *Image) -> void #foreign libraylib; +ImageRotateCCW :: (image: *Image) -> void #foreign libraylib; +ImageColorTint :: (image: *Image, color: Color) -> void #foreign libraylib; +ImageColorInvert :: (image: *Image) -> void #foreign libraylib; +ImageColorGrayscale :: (image: *Image) -> void #foreign libraylib; +ImageColorContrast :: (image: *Image, contrast: float) -> void #foreign libraylib; +ImageColorBrightness :: (image: *Image, brightness: s32) -> void #foreign libraylib; +ImageColorReplace :: (image: *Image, color: Color, replace: Color) -> void #foreign libraylib; +LoadImageColors :: (image: Image) -> *Color #foreign libraylib; +LoadImagePalette :: (image: Image, maxPaletteSize: s32, colorCount: *s32) -> *Color #foreign libraylib; +UnloadImageColors :: (colors: *Color) -> void #foreign libraylib; +UnloadImagePalette :: (colors: *Color) -> void #foreign libraylib; +GetImageAlphaBorder :: (image: Image, threshold: float) -> Rectangle #foreign libraylib; +GetImageColor :: (image: Image, x: s32, y: s32) -> Color #foreign libraylib; // Image drawing functions // NOTE: Image software-rendering functions (CPU) -ImageClearBackground :: (dst: *Image, color: Color) -> void #foreign raylib; -ImageDrawPixel :: (dst: *Image, posX: s32, posY: s32, color: Color) -> void #foreign raylib; -ImageDrawPixelV :: (dst: *Image, position: Vector2, color: Color) -> void #foreign raylib; -ImageDrawLine :: (dst: *Image, startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color) -> void #foreign raylib; -ImageDrawLineV :: (dst: *Image, start: Vector2, end: Vector2, color: Color) -> void #foreign raylib; -ImageDrawLineEx :: (dst: *Image, start: Vector2, end: Vector2, thick: s32, color: Color) -> void #foreign raylib; -ImageDrawCircle :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color) -> void #foreign raylib; -ImageDrawCircleV :: (dst: *Image, center: Vector2, radius: s32, color: Color) -> void #foreign raylib; -ImageDrawCircleLines :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color) -> void #foreign raylib; -ImageDrawCircleLinesV :: (dst: *Image, center: Vector2, radius: s32, color: Color) -> void #foreign raylib; -ImageDrawRectangle :: (dst: *Image, posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign raylib; -ImageDrawRectangleV :: (dst: *Image, position: Vector2, size: Vector2, color: Color) -> void #foreign raylib; -ImageDrawRectangleRec :: (dst: *Image, rec: Rectangle, color: Color) -> void #foreign raylib; -ImageDrawRectangleLines :: (dst: *Image, rec: Rectangle, thick: s32, color: Color) -> void #foreign raylib; -ImageDrawTriangle :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign raylib; -ImageDrawTriangleEx :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) -> void #foreign raylib; -ImageDrawTriangleLines :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign raylib; -ImageDrawTriangleFan :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color) -> void #foreign raylib; -ImageDrawTriangleStrip :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color) -> void #foreign raylib; -ImageDraw :: (dst: *Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color) -> void #foreign raylib; -ImageDrawText :: (dst: *Image, text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color) -> void #foreign raylib; -ImageDrawTextEx :: (dst: *Image, font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign raylib; +ImageClearBackground :: (dst: *Image, color: Color) -> void #foreign libraylib; +ImageDrawPixel :: (dst: *Image, posX: s32, posY: s32, color: Color) -> void #foreign libraylib; +ImageDrawPixelV :: (dst: *Image, position: Vector2, color: Color) -> void #foreign libraylib; +ImageDrawLine :: (dst: *Image, startPosX: s32, startPosY: s32, endPosX: s32, endPosY: s32, color: Color) -> void #foreign libraylib; +ImageDrawLineV :: (dst: *Image, start: Vector2, end: Vector2, color: Color) -> void #foreign libraylib; +ImageDrawLineEx :: (dst: *Image, start: Vector2, end: Vector2, thick: s32, color: Color) -> void #foreign libraylib; +ImageDrawCircle :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color) -> void #foreign libraylib; +ImageDrawCircleV :: (dst: *Image, center: Vector2, radius: s32, color: Color) -> void #foreign libraylib; +ImageDrawCircleLines :: (dst: *Image, centerX: s32, centerY: s32, radius: s32, color: Color) -> void #foreign libraylib; +ImageDrawCircleLinesV :: (dst: *Image, center: Vector2, radius: s32, color: Color) -> void #foreign libraylib; +ImageDrawRectangle :: (dst: *Image, posX: s32, posY: s32, width: s32, height: s32, color: Color) -> void #foreign libraylib; +ImageDrawRectangleV :: (dst: *Image, position: Vector2, size: Vector2, color: Color) -> void #foreign libraylib; +ImageDrawRectangleRec :: (dst: *Image, rec: Rectangle, color: Color) -> void #foreign libraylib; +ImageDrawRectangleLines :: (dst: *Image, rec: Rectangle, thick: s32, color: Color) -> void #foreign libraylib; +ImageDrawTriangle :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign libraylib; +ImageDrawTriangleEx :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) -> void #foreign libraylib; +ImageDrawTriangleLines :: (dst: *Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) -> void #foreign libraylib; +ImageDrawTriangleFan :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color) -> void #foreign libraylib; +ImageDrawTriangleStrip :: (dst: *Image, points: *Vector2, pointCount: s32, color: Color) -> void #foreign libraylib; +ImageDraw :: (dst: *Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color) -> void #foreign libraylib; +ImageDrawText :: (dst: *Image, text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color) -> void #foreign libraylib; +ImageDrawTextEx :: (dst: *Image, font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign libraylib; // Texture loading functions // NOTE: These functions require GPU access -LoadTexture :: (fileName: *u8) -> Texture2D #foreign raylib; -LoadTextureFromImage :: (image: Image) -> Texture2D #foreign raylib; -LoadTextureCubemap :: (image: Image, layout: CubemapLayout) -> TextureCubemap #foreign raylib; -LoadRenderTexture :: (width: s32, height: s32) -> RenderTexture2D #foreign raylib; -IsTextureValid :: (texture: Texture2D) -> bool #foreign raylib; -UnloadTexture :: (texture: Texture2D) -> void #foreign raylib; -IsRenderTextureValid :: (target: RenderTexture2D) -> bool #foreign raylib; -UnloadRenderTexture :: (target: RenderTexture2D) -> void #foreign raylib; -UpdateTexture :: (texture: Texture2D, pixels: *void) -> void #foreign raylib; -UpdateTextureRec :: (texture: Texture2D, rec: Rectangle, pixels: *void) -> void #foreign raylib; +LoadTexture :: (fileName: *u8) -> Texture2D #foreign libraylib; +LoadTextureFromImage :: (image: Image) -> Texture2D #foreign libraylib; +LoadTextureCubemap :: (image: Image, layout: CubemapLayout) -> TextureCubemap #foreign libraylib; +LoadRenderTexture :: (width: s32, height: s32) -> RenderTexture2D #foreign libraylib; +IsTextureValid :: (texture: Texture2D) -> bool #foreign libraylib; +UnloadTexture :: (texture: Texture2D) -> void #foreign libraylib; +IsRenderTextureValid :: (target: RenderTexture2D) -> bool #foreign libraylib; +UnloadRenderTexture :: (target: RenderTexture2D) -> void #foreign libraylib; +UpdateTexture :: (texture: Texture2D, pixels: *void) -> void #foreign libraylib; +UpdateTextureRec :: (texture: Texture2D, rec: Rectangle, pixels: *void) -> void #foreign libraylib; // Texture configuration functions -GenTextureMipmaps :: (texture: *Texture2D) -> void #foreign raylib; -SetTextureFilter :: (texture: Texture2D, filter: TextureFilter) -> void #foreign raylib; -SetTextureWrap :: (texture: Texture2D, wrap: TextureWrap) -> void #foreign raylib; +GenTextureMipmaps :: (texture: *Texture2D) -> void #foreign libraylib; +SetTextureFilter :: (texture: Texture2D, filter: TextureFilter) -> void #foreign libraylib; +SetTextureWrap :: (texture: Texture2D, wrap: TextureWrap) -> void #foreign libraylib; // Texture drawing functions -DrawTexture :: (texture: Texture2D, posX: s32, posY: s32, tint: Color) -> void #foreign raylib; -DrawTextureV :: (texture: Texture2D, position: Vector2, tint: Color) -> void #foreign raylib; -DrawTextureEx :: (texture: Texture2D, position: Vector2, rotation: float, scale: float, tint: Color) -> void #foreign raylib; -DrawTextureRec :: (texture: Texture2D, source: Rectangle, position: Vector2, tint: Color) -> void #foreign raylib; -DrawTexturePro :: (texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, tint: Color) -> void #foreign raylib; -DrawTextureNPatch :: (texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: float, tint: Color) -> void #foreign raylib; +DrawTexture :: (texture: Texture2D, posX: s32, posY: s32, tint: Color) -> void #foreign libraylib; +DrawTextureV :: (texture: Texture2D, position: Vector2, tint: Color) -> void #foreign libraylib; +DrawTextureEx :: (texture: Texture2D, position: Vector2, rotation: float, scale: float, tint: Color) -> void #foreign libraylib; +DrawTextureRec :: (texture: Texture2D, source: Rectangle, position: Vector2, tint: Color) -> void #foreign libraylib; +DrawTexturePro :: (texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, tint: Color) -> void #foreign libraylib; +DrawTextureNPatch :: (texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: float, tint: Color) -> void #foreign libraylib; // Color/pixel related functions -ColorIsEqual :: (col1: Color, col2: Color) -> bool #foreign raylib; -Fade :: (color: Color, alpha: float) -> Color #foreign raylib; -ColorToInt :: (color: Color) -> s32 #foreign raylib; -ColorNormalize :: (color: Color) -> Vector4 #foreign raylib; -ColorFromNormalized :: (normalized: Vector4) -> Color #foreign raylib; -ColorToHSV :: (color: Color) -> Vector3 #foreign raylib; -ColorFromHSV :: (hue: float, saturation: float, value: float) -> Color #foreign raylib; -ColorTint :: (color: Color, tint: Color) -> Color #foreign raylib; -ColorBrightness :: (color: Color, factor: float) -> Color #foreign raylib; -ColorContrast :: (color: Color, contrast: float) -> Color #foreign raylib; -ColorAlpha :: (color: Color, alpha: float) -> Color #foreign raylib; -ColorAlphaBlend :: (dst: Color, src: Color, tint: Color) -> Color #foreign raylib; -ColorLerp :: (color1: Color, color2: Color, factor: float) -> Color #foreign raylib; -GetColor :: (hexValue: u32) -> Color #foreign raylib; -GetPixelColor :: (srcPtr: *void, format: PixelFormat) -> Color #foreign raylib; -SetPixelColor :: (dstPtr: *void, color: Color, format: PixelFormat) -> void #foreign raylib; -GetPixelDataSize :: (width: s32, height: s32, format: PixelFormat) -> s32 #foreign raylib; +ColorIsEqual :: (col1: Color, col2: Color) -> bool #foreign libraylib; +Fade :: (color: Color, alpha: float) -> Color #foreign libraylib; +ColorToInt :: (color: Color) -> s32 #foreign libraylib; +ColorNormalize :: (color: Color) -> Vector4 #foreign libraylib; +ColorFromNormalized :: (normalized: Vector4) -> Color #foreign libraylib; +ColorToHSV :: (color: Color) -> Vector3 #foreign libraylib; +ColorFromHSV :: (hue: float, saturation: float, value: float) -> Color #foreign libraylib; +ColorTint :: (color: Color, tint: Color) -> Color #foreign libraylib; +ColorBrightness :: (color: Color, factor: float) -> Color #foreign libraylib; +ColorContrast :: (color: Color, contrast: float) -> Color #foreign libraylib; +ColorAlpha :: (color: Color, alpha: float) -> Color #foreign libraylib; +ColorAlphaBlend :: (dst: Color, src: Color, tint: Color) -> Color #foreign libraylib; +ColorLerp :: (color1: Color, color2: Color, factor: float) -> Color #foreign libraylib; +GetColor :: (hexValue: u32) -> Color #foreign libraylib; +GetPixelColor :: (srcPtr: *void, format: PixelFormat) -> Color #foreign libraylib; +SetPixelColor :: (dstPtr: *void, color: Color, format: PixelFormat) -> void #foreign libraylib; +GetPixelDataSize :: (width: s32, height: s32, format: PixelFormat) -> s32 #foreign libraylib; // Font loading/unloading functions -GetFontDefault :: () -> Font #foreign raylib; -LoadFont :: (fileName: *u8) -> Font #foreign raylib; -LoadFontEx :: (fileName: *u8, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font #foreign raylib; -LoadFontFromImage :: (image: Image, key: Color, firstChar: s32) -> Font #foreign raylib; -LoadFontFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font #foreign raylib; -IsFontValid :: (font: Font) -> bool #foreign raylib; -LoadFontData :: (fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32, type: s32) -> *GlyphInfo #foreign raylib; -GenImageFontAtlas :: (glyphs: *GlyphInfo, glyphRecs: **Rectangle, glyphCount: s32, fontSize: s32, padding: s32, packMethod: s32) -> Image #foreign raylib; -UnloadFontData :: (glyphs: *GlyphInfo, glyphCount: s32) -> void #foreign raylib; -UnloadFont :: (font: Font) -> void #foreign raylib; -ExportFontAsCode :: (font: Font, fileName: *u8) -> bool #foreign raylib; +GetFontDefault :: () -> Font #foreign libraylib; +LoadFont :: (fileName: *u8) -> Font #foreign libraylib; +LoadFontEx :: (fileName: *u8, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font #foreign libraylib; +LoadFontFromImage :: (image: Image, key: Color, firstChar: s32) -> Font #foreign libraylib; +LoadFontFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32) -> Font #foreign libraylib; +IsFontValid :: (font: Font) -> bool #foreign libraylib; +LoadFontData :: (fileData: *u8, dataSize: s32, fontSize: s32, codepoints: *s32, codepointCount: s32, type: s32) -> *GlyphInfo #foreign libraylib; +GenImageFontAtlas :: (glyphs: *GlyphInfo, glyphRecs: **Rectangle, glyphCount: s32, fontSize: s32, padding: s32, packMethod: s32) -> Image #foreign libraylib; +UnloadFontData :: (glyphs: *GlyphInfo, glyphCount: s32) -> void #foreign libraylib; +UnloadFont :: (font: Font) -> void #foreign libraylib; +ExportFontAsCode :: (font: Font, fileName: *u8) -> bool #foreign libraylib; // Text drawing functions -DrawFPS :: (posX: s32, posY: s32) -> void #foreign raylib; -DrawText :: (text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color) -> void #foreign raylib; -DrawTextEx :: (font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign raylib; -DrawTextPro :: (font: Font, text: *u8, position: Vector2, origin: Vector2, rotation: float, fontSize: float, spacing: float, tint: Color) -> void #foreign raylib; -DrawTextCodepoint :: (font: Font, codepoint: s32, position: Vector2, fontSize: float, tint: Color) -> void #foreign raylib; -DrawTextCodepoints :: (font: Font, codepoints: *s32, codepointCount: s32, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign raylib; +DrawFPS :: (posX: s32, posY: s32) -> void #foreign libraylib; +DrawText :: (text: *u8, posX: s32, posY: s32, fontSize: s32, color: Color) -> void #foreign libraylib; +DrawTextEx :: (font: Font, text: *u8, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign libraylib; +DrawTextPro :: (font: Font, text: *u8, position: Vector2, origin: Vector2, rotation: float, fontSize: float, spacing: float, tint: Color) -> void #foreign libraylib; +DrawTextCodepoint :: (font: Font, codepoint: s32, position: Vector2, fontSize: float, tint: Color) -> void #foreign libraylib; +DrawTextCodepoints :: (font: Font, codepoints: *s32, codepointCount: s32, position: Vector2, fontSize: float, spacing: float, tint: Color) -> void #foreign libraylib; // Text font info functions -SetTextLineSpacing :: (spacing: s32) -> void #foreign raylib; -MeasureText :: (text: *u8, fontSize: s32) -> s32 #foreign raylib; -MeasureTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float) -> Vector2 #foreign raylib; -GetGlyphIndex :: (font: Font, codepoint: s32) -> s32 #foreign raylib; -GetGlyphInfo :: (font: Font, codepoint: s32) -> GlyphInfo #foreign raylib; -GetGlyphAtlasRec :: (font: Font, codepoint: s32) -> Rectangle #foreign raylib; +SetTextLineSpacing :: (spacing: s32) -> void #foreign libraylib; +MeasureText :: (text: *u8, fontSize: s32) -> s32 #foreign libraylib; +MeasureTextEx :: (font: Font, text: *u8, fontSize: float, spacing: float) -> Vector2 #foreign libraylib; +GetGlyphIndex :: (font: Font, codepoint: s32) -> s32 #foreign libraylib; +GetGlyphInfo :: (font: Font, codepoint: s32) -> GlyphInfo #foreign libraylib; +GetGlyphAtlasRec :: (font: Font, codepoint: s32) -> Rectangle #foreign libraylib; // Text codepoints management functions (unicode characters) -LoadUTF8 :: (codepoints: *s32, length: s32) -> *u8 #foreign raylib; -UnloadUTF8 :: (text: *u8) -> void #foreign raylib; -LoadCodepoints :: (text: *u8, count: *s32) -> *s32 #foreign raylib; -UnloadCodepoints :: (codepoints: *s32) -> void #foreign raylib; -GetCodepointCount :: (text: *u8) -> s32 #foreign raylib; -GetCodepoint :: (text: *u8, codepointSize: *s32) -> s32 #foreign raylib; -GetCodepointNext :: (text: *u8, codepointSize: *s32) -> s32 #foreign raylib; -GetCodepointPrevious :: (text: *u8, codepointSize: *s32) -> s32 #foreign raylib; -CodepointToUTF8 :: (codepoint: s32, utf8Size: *s32) -> *u8 #foreign raylib; +LoadUTF8 :: (codepoints: *s32, length: s32) -> *u8 #foreign libraylib; +UnloadUTF8 :: (text: *u8) -> void #foreign libraylib; +LoadCodepoints :: (text: *u8, count: *s32) -> *s32 #foreign libraylib; +UnloadCodepoints :: (codepoints: *s32) -> void #foreign libraylib; +GetCodepointCount :: (text: *u8) -> s32 #foreign libraylib; +GetCodepoint :: (text: *u8, codepointSize: *s32) -> s32 #foreign libraylib; +GetCodepointNext :: (text: *u8, codepointSize: *s32) -> s32 #foreign libraylib; +GetCodepointPrevious :: (text: *u8, codepointSize: *s32) -> s32 #foreign libraylib; +CodepointToUTF8 :: (codepoint: s32, utf8Size: *s32) -> *u8 #foreign libraylib; // Text strings management functions (no UTF-8 strings, only byte chars) // NOTE: Some strings allocate memory internally for returned strings, just be careful! -TextCopy :: (dst: *u8, src: *u8) -> s32 #foreign raylib; -TextIsEqual :: (text1: *u8, text2: *u8) -> bool #foreign raylib; -TextLength :: (text: *u8) -> u32 #foreign raylib; -TextFormat_CFormat :: (text: *u8, __args: ..Any) -> *u8 #foreign raylib "TextFormat"; +TextCopy :: (dst: *u8, src: *u8) -> s32 #foreign libraylib; +TextIsEqual :: (text1: *u8, text2: *u8) -> bool #foreign libraylib; +TextLength :: (text: *u8) -> u32 #foreign libraylib; +TextFormat_CFormat :: (text: *u8, __args: ..Any) -> *u8 #foreign libraylib "TextFormat"; TextFormat :: (text: string, __args: ..Any) -> *u8 { push_allocator(temp); formatted_text_builder: String_Builder; @@ -1619,113 +1617,113 @@ TextFormat :: (text: string, __args: ..Any) -> *u8 { formatted_text := builder_to_string(*formatted_text_builder); return TextFormat_CFormat("%s", formatted_text.data); } @PrintLike -TextSubtext :: (text: *u8, position: s32, length: s32) -> *u8 #foreign raylib; -TextReplace :: (text: *u8, replace: *u8, by: *u8) -> *u8 #foreign raylib; -TextInsert :: (text: *u8, insert: *u8, position: s32) -> *u8 #foreign raylib; -TextJoin :: (textList: **u8, count: s32, delimiter: *u8) -> *u8 #foreign raylib; -TextSplit :: (text: *u8, delimiter: u8, count: *s32) -> **u8 #foreign raylib; -TextAppend :: (text: *u8, append: *u8, position: *s32) -> void #foreign raylib; -TextFindIndex :: (text: *u8, find: *u8) -> s32 #foreign raylib; -TextToUpper :: (text: *u8) -> *u8 #foreign raylib; -TextToLower :: (text: *u8) -> *u8 #foreign raylib; -TextToPascal :: (text: *u8) -> *u8 #foreign raylib; -TextToSnake :: (text: *u8) -> *u8 #foreign raylib; -TextToCamel :: (text: *u8) -> *u8 #foreign raylib; +TextSubtext :: (text: *u8, position: s32, length: s32) -> *u8 #foreign libraylib; +TextReplace :: (text: *u8, replace: *u8, by: *u8) -> *u8 #foreign libraylib; +TextInsert :: (text: *u8, insert: *u8, position: s32) -> *u8 #foreign libraylib; +TextJoin :: (textList: **u8, count: s32, delimiter: *u8) -> *u8 #foreign libraylib; +TextSplit :: (text: *u8, delimiter: u8, count: *s32) -> **u8 #foreign libraylib; +TextAppend :: (text: *u8, append: *u8, position: *s32) -> void #foreign libraylib; +TextFindIndex :: (text: *u8, find: *u8) -> s32 #foreign libraylib; +TextToUpper :: (text: *u8) -> *u8 #foreign libraylib; +TextToLower :: (text: *u8) -> *u8 #foreign libraylib; +TextToPascal :: (text: *u8) -> *u8 #foreign libraylib; +TextToSnake :: (text: *u8) -> *u8 #foreign libraylib; +TextToCamel :: (text: *u8) -> *u8 #foreign libraylib; -TextToInteger :: (text: *u8) -> s32 #foreign raylib; -TextToFloat :: (text: *u8) -> float #foreign raylib; +TextToInteger :: (text: *u8) -> s32 #foreign libraylib; +TextToFloat :: (text: *u8) -> float #foreign libraylib; // Basic geometric 3D shapes drawing functions -DrawLine3D :: (startPos: Vector3, endPos: Vector3, color: Color) -> void #foreign raylib; -DrawPoint3D :: (position: Vector3, color: Color) -> void #foreign raylib; -DrawCircle3D :: (center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color) -> void #foreign raylib; -DrawTriangle3D :: (v1: Vector3, v2: Vector3, v3: Vector3, color: Color) -> void #foreign raylib; -DrawTriangleStrip3D :: (points: *Vector3, pointCount: s32, color: Color) -> void #foreign raylib; -DrawCube :: (position: Vector3, width: float, height: float, length: float, color: Color) -> void #foreign raylib; -DrawCubeV :: (position: Vector3, size: Vector3, color: Color) -> void #foreign raylib; -DrawCubeWires :: (position: Vector3, width: float, height: float, length: float, color: Color) -> void #foreign raylib; -DrawCubeWiresV :: (position: Vector3, size: Vector3, color: Color) -> void #foreign raylib; -DrawSphere :: (centerPos: Vector3, radius: float, color: Color) -> void #foreign raylib; -DrawSphereEx :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color) -> void #foreign raylib; -DrawSphereWires :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color) -> void #foreign raylib; -DrawCylinder :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color) -> void #foreign raylib; -DrawCylinderEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color) -> void #foreign raylib; -DrawCylinderWires :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color) -> void #foreign raylib; -DrawCylinderWiresEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color) -> void #foreign raylib; -DrawCapsule :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color) -> void #foreign raylib; -DrawCapsuleWires :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color) -> void #foreign raylib; -DrawPlane :: (centerPos: Vector3, size: Vector2, color: Color) -> void #foreign raylib; -DrawRay :: (ray: Ray, color: Color) -> void #foreign raylib; -DrawGrid :: (slices: s32, spacing: float) -> void #foreign raylib; +DrawLine3D :: (startPos: Vector3, endPos: Vector3, color: Color) -> void #foreign libraylib; +DrawPoint3D :: (position: Vector3, color: Color) -> void #foreign libraylib; +DrawCircle3D :: (center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color) -> void #foreign libraylib; +DrawTriangle3D :: (v1: Vector3, v2: Vector3, v3: Vector3, color: Color) -> void #foreign libraylib; +DrawTriangleStrip3D :: (points: *Vector3, pointCount: s32, color: Color) -> void #foreign libraylib; +DrawCube :: (position: Vector3, width: float, height: float, length: float, color: Color) -> void #foreign libraylib; +DrawCubeV :: (position: Vector3, size: Vector3, color: Color) -> void #foreign libraylib; +DrawCubeWires :: (position: Vector3, width: float, height: float, length: float, color: Color) -> void #foreign libraylib; +DrawCubeWiresV :: (position: Vector3, size: Vector3, color: Color) -> void #foreign libraylib; +DrawSphere :: (centerPos: Vector3, radius: float, color: Color) -> void #foreign libraylib; +DrawSphereEx :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color) -> void #foreign libraylib; +DrawSphereWires :: (centerPos: Vector3, radius: float, rings: s32, slices: s32, color: Color) -> void #foreign libraylib; +DrawCylinder :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color) -> void #foreign libraylib; +DrawCylinderEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color) -> void #foreign libraylib; +DrawCylinderWires :: (position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: s32, color: Color) -> void #foreign libraylib; +DrawCylinderWiresEx :: (startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: s32, color: Color) -> void #foreign libraylib; +DrawCapsule :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color) -> void #foreign libraylib; +DrawCapsuleWires :: (startPos: Vector3, endPos: Vector3, radius: float, slices: s32, rings: s32, color: Color) -> void #foreign libraylib; +DrawPlane :: (centerPos: Vector3, size: Vector2, color: Color) -> void #foreign libraylib; +DrawRay :: (ray: Ray, color: Color) -> void #foreign libraylib; +DrawGrid :: (slices: s32, spacing: float) -> void #foreign libraylib; // Model management functions -LoadModel :: (fileName: *u8) -> Model #foreign raylib; -LoadModelFromMesh :: (mesh: Mesh) -> Model #foreign raylib; -IsModelValid :: (model: Model) -> bool #foreign raylib; -UnloadModel :: (model: Model) -> void #foreign raylib; -GetModelBoundingBox :: (model: Model) -> BoundingBox #foreign raylib; +LoadModel :: (fileName: *u8) -> Model #foreign libraylib; +LoadModelFromMesh :: (mesh: Mesh) -> Model #foreign libraylib; +IsModelValid :: (model: Model) -> bool #foreign libraylib; +UnloadModel :: (model: Model) -> void #foreign libraylib; +GetModelBoundingBox :: (model: Model) -> BoundingBox #foreign libraylib; // Model drawing functions -DrawModel :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign raylib; -DrawModelEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign raylib; -DrawModelWires :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign raylib; -DrawModelWiresEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign raylib; -DrawModelPoints :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign raylib; -DrawModelPointsEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign raylib; -DrawBoundingBox :: (box: BoundingBox, color: Color) -> void #foreign raylib; -DrawBillboard :: (camera: Camera, texture: Texture2D, position: Vector3, scale: float, tint: Color) -> void #foreign raylib; -DrawBillboardRec :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, size: Vector2, tint: Color) -> void #foreign raylib; -DrawBillboardPro :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: float, tint: Color) -> void #foreign raylib; +DrawModel :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign libraylib; +DrawModelEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign libraylib; +DrawModelWires :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign libraylib; +DrawModelWiresEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign libraylib; +DrawModelPoints :: (model: Model, position: Vector3, scale: float, tint: Color) -> void #foreign libraylib; +DrawModelPointsEx :: (model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color) -> void #foreign libraylib; +DrawBoundingBox :: (box: BoundingBox, color: Color) -> void #foreign libraylib; +DrawBillboard :: (camera: Camera, texture: Texture2D, position: Vector3, scale: float, tint: Color) -> void #foreign libraylib; +DrawBillboardRec :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, size: Vector2, tint: Color) -> void #foreign libraylib; +DrawBillboardPro :: (camera: Camera, texture: Texture2D, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: float, tint: Color) -> void #foreign libraylib; // Mesh management functions -UploadMesh :: (mesh: *Mesh, dynamic: bool) -> void #foreign raylib; -UpdateMeshBuffer :: (mesh: Mesh, index: s32, data: *void, dataSize: s32, offset: s32) -> void #foreign raylib; -UnloadMesh :: (mesh: Mesh) -> void #foreign raylib; -DrawMesh :: (mesh: Mesh, material: Material, transform: Matrix) -> void #foreign raylib; -DrawMeshInstanced :: (mesh: Mesh, material: Material, transforms: *Matrix, instances: s32) -> void #foreign raylib; -GetMeshBoundingBox :: (mesh: Mesh) -> BoundingBox #foreign raylib; -GenMeshTangents :: (mesh: *Mesh) -> void #foreign raylib; -ExportMesh :: (mesh: Mesh, fileName: *u8) -> bool #foreign raylib; -ExportMeshAsCode :: (mesh: Mesh, fileName: *u8) -> bool #foreign raylib; +UploadMesh :: (mesh: *Mesh, dynamic: bool) -> void #foreign libraylib; +UpdateMeshBuffer :: (mesh: Mesh, index: s32, data: *void, dataSize: s32, offset: s32) -> void #foreign libraylib; +UnloadMesh :: (mesh: Mesh) -> void #foreign libraylib; +DrawMesh :: (mesh: Mesh, material: Material, transform: Matrix) -> void #foreign libraylib; +DrawMeshInstanced :: (mesh: Mesh, material: Material, transforms: *Matrix, instances: s32) -> void #foreign libraylib; +GetMeshBoundingBox :: (mesh: Mesh) -> BoundingBox #foreign libraylib; +GenMeshTangents :: (mesh: *Mesh) -> void #foreign libraylib; +ExportMesh :: (mesh: Mesh, fileName: *u8) -> bool #foreign libraylib; +ExportMeshAsCode :: (mesh: Mesh, fileName: *u8) -> bool #foreign libraylib; // Mesh generation functions -GenMeshPoly :: (sides: s32, radius: float) -> Mesh #foreign raylib; -GenMeshPlane :: (width: float, length: float, resX: s32, resZ: s32) -> Mesh #foreign raylib; -GenMeshCube :: (width: float, height: float, length: float) -> Mesh #foreign raylib; -GenMeshSphere :: (radius: float, rings: s32, slices: s32) -> Mesh #foreign raylib; -GenMeshHemiSphere :: (radius: float, rings: s32, slices: s32) -> Mesh #foreign raylib; -GenMeshCylinder :: (radius: float, height: float, slices: s32) -> Mesh #foreign raylib; -GenMeshCone :: (radius: float, height: float, slices: s32) -> Mesh #foreign raylib; -GenMeshTorus :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh #foreign raylib; -GenMeshKnot :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh #foreign raylib; -GenMeshHeightmap :: (heightmap: Image, size: Vector3) -> Mesh #foreign raylib; -GenMeshCubicmap :: (cubicmap: Image, cubeSize: Vector3) -> Mesh #foreign raylib; +GenMeshPoly :: (sides: s32, radius: float) -> Mesh #foreign libraylib; +GenMeshPlane :: (width: float, length: float, resX: s32, resZ: s32) -> Mesh #foreign libraylib; +GenMeshCube :: (width: float, height: float, length: float) -> Mesh #foreign libraylib; +GenMeshSphere :: (radius: float, rings: s32, slices: s32) -> Mesh #foreign libraylib; +GenMeshHemiSphere :: (radius: float, rings: s32, slices: s32) -> Mesh #foreign libraylib; +GenMeshCylinder :: (radius: float, height: float, slices: s32) -> Mesh #foreign libraylib; +GenMeshCone :: (radius: float, height: float, slices: s32) -> Mesh #foreign libraylib; +GenMeshTorus :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh #foreign libraylib; +GenMeshKnot :: (radius: float, size: float, radSeg: s32, sides: s32) -> Mesh #foreign libraylib; +GenMeshHeightmap :: (heightmap: Image, size: Vector3) -> Mesh #foreign libraylib; +GenMeshCubicmap :: (cubicmap: Image, cubeSize: Vector3) -> Mesh #foreign libraylib; // Material loading/unloading functions -LoadMaterials :: (fileName: *u8, materialCount: *s32) -> *Material #foreign raylib; -LoadMaterialDefault :: () -> Material #foreign raylib; -IsMaterialValid :: (material: Material) -> bool #foreign raylib; -UnloadMaterial :: (material: Material) -> void #foreign raylib; -SetMaterialTexture :: (material: *Material, mapType: MaterialMapIndex, texture: Texture2D) -> void #foreign raylib; -SetModelMeshMaterial :: (model: *Model, meshId: s32, materialId: s32) -> void #foreign raylib; +LoadMaterials :: (fileName: *u8, materialCount: *s32) -> *Material #foreign libraylib; +LoadMaterialDefault :: () -> Material #foreign libraylib; +IsMaterialValid :: (material: Material) -> bool #foreign libraylib; +UnloadMaterial :: (material: Material) -> void #foreign libraylib; +SetMaterialTexture :: (material: *Material, mapType: MaterialMapIndex, texture: Texture2D) -> void #foreign libraylib; +SetModelMeshMaterial :: (model: *Model, meshId: s32, materialId: s32) -> void #foreign libraylib; // Model animations loading/unloading functions -LoadModelAnimations :: (fileName: *u8, animCount: *s32) -> *ModelAnimation #foreign raylib; -UpdateModelAnimation :: (model: Model, anim: ModelAnimation, frame: s32) -> void #foreign raylib; -UpdateModelAnimationBones :: (model: Model, anim: ModelAnimation, frame: s32) -> void #foreign raylib; -UnloadModelAnimation :: (anim: ModelAnimation) -> void #foreign raylib; -UnloadModelAnimations :: (animations: *ModelAnimation, animCount: s32) -> void #foreign raylib; -IsModelAnimationValid :: (model: Model, anim: ModelAnimation) -> bool #foreign raylib; +LoadModelAnimations :: (fileName: *u8, animCount: *s32) -> *ModelAnimation #foreign libraylib; +UpdateModelAnimation :: (model: Model, anim: ModelAnimation, frame: s32) -> void #foreign libraylib; +UpdateModelAnimationBones :: (model: Model, anim: ModelAnimation, frame: s32) -> void #foreign libraylib; +UnloadModelAnimation :: (anim: ModelAnimation) -> void #foreign libraylib; +UnloadModelAnimations :: (animations: *ModelAnimation, animCount: s32) -> void #foreign libraylib; +IsModelAnimationValid :: (model: Model, anim: ModelAnimation) -> bool #foreign libraylib; // Collision detection functions -CheckCollisionSpheres :: (center1: Vector3, radius1: float, center2: Vector3, radius2: float) -> bool #foreign raylib; -CheckCollisionBoxes :: (box1: BoundingBox, box2: BoundingBox) -> bool #foreign raylib; -CheckCollisionBoxSphere :: (box: BoundingBox, center: Vector3, radius: float) -> bool #foreign raylib; -GetRayCollisionSphere :: (ray: Ray, center: Vector3, radius: float) -> RayCollision #foreign raylib; -GetRayCollisionBox :: (ray: Ray, box: BoundingBox) -> RayCollision #foreign raylib; -GetRayCollisionMesh :: (ray: Ray, mesh: Mesh, transform: Matrix) -> RayCollision #foreign raylib; -GetRayCollisionTriangle :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3) -> RayCollision #foreign raylib; -GetRayCollisionQuad :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3) -> RayCollision #foreign raylib; +CheckCollisionSpheres :: (center1: Vector3, radius1: float, center2: Vector3, radius2: float) -> bool #foreign libraylib; +CheckCollisionBoxes :: (box1: BoundingBox, box2: BoundingBox) -> bool #foreign libraylib; +CheckCollisionBoxSphere :: (box: BoundingBox, center: Vector3, radius: float) -> bool #foreign libraylib; +GetRayCollisionSphere :: (ray: Ray, center: Vector3, radius: float) -> RayCollision #foreign libraylib; +GetRayCollisionBox :: (ray: Ray, box: BoundingBox) -> RayCollision #foreign libraylib; +GetRayCollisionMesh :: (ray: Ray, mesh: Mesh, transform: Matrix) -> RayCollision #foreign libraylib; +GetRayCollisionTriangle :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3) -> RayCollision #foreign libraylib; +GetRayCollisionQuad :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3) -> RayCollision #foreign libraylib; //------------------------------------------------------------------------------------ // Audio Loading and Playing Functions (Module: audio) @@ -1733,82 +1731,82 @@ GetRayCollisionQuad :: (ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vec AudioCallback :: #type (bufferData: *void, frames: u32) -> void #c_call; // Audio device management functions -InitAudioDevice :: () -> void #foreign raylib; -CloseAudioDevice :: () -> void #foreign raylib; -IsAudioDeviceReady :: () -> bool #foreign raylib; -SetMasterVolume :: (volume: float) -> void #foreign raylib; -GetMasterVolume :: () -> float #foreign raylib; +InitAudioDevice :: () -> void #foreign libraylib; +CloseAudioDevice :: () -> void #foreign libraylib; +IsAudioDeviceReady :: () -> bool #foreign libraylib; +SetMasterVolume :: (volume: float) -> void #foreign libraylib; +GetMasterVolume :: () -> float #foreign libraylib; // Wave/Sound loading/unloading functions -LoadWave :: (fileName: *u8) -> Wave #foreign raylib; -LoadWaveFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Wave #foreign raylib; -IsWaveValid :: (wave: Wave) -> bool #foreign raylib; -LoadSound :: (fileName: *u8) -> Sound #foreign raylib; -LoadSoundFromWave :: (wave: Wave) -> Sound #foreign raylib; -LoadSoundAlias :: (source: Sound) -> Sound #foreign raylib; -IsSoundValid :: (sound: Sound) -> bool #foreign raylib; -UpdateSound :: (sound: Sound, data: *void, sampleCount: s32) -> void #foreign raylib; -UnloadWave :: (wave: Wave) -> void #foreign raylib; -UnloadSound :: (sound: Sound) -> void #foreign raylib; -UnloadSoundAlias :: (alias: Sound) -> void #foreign raylib; -ExportWave :: (wave: Wave, fileName: *u8) -> bool #foreign raylib; -ExportWaveAsCode :: (wave: Wave, fileName: *u8) -> bool #foreign raylib; +LoadWave :: (fileName: *u8) -> Wave #foreign libraylib; +LoadWaveFromMemory :: (fileType: *u8, fileData: *u8, dataSize: s32) -> Wave #foreign libraylib; +IsWaveValid :: (wave: Wave) -> bool #foreign libraylib; +LoadSound :: (fileName: *u8) -> Sound #foreign libraylib; +LoadSoundFromWave :: (wave: Wave) -> Sound #foreign libraylib; +LoadSoundAlias :: (source: Sound) -> Sound #foreign libraylib; +IsSoundValid :: (sound: Sound) -> bool #foreign libraylib; +UpdateSound :: (sound: Sound, data: *void, sampleCount: s32) -> void #foreign libraylib; +UnloadWave :: (wave: Wave) -> void #foreign libraylib; +UnloadSound :: (sound: Sound) -> void #foreign libraylib; +UnloadSoundAlias :: (alias: Sound) -> void #foreign libraylib; +ExportWave :: (wave: Wave, fileName: *u8) -> bool #foreign libraylib; +ExportWaveAsCode :: (wave: Wave, fileName: *u8) -> bool #foreign libraylib; // Wave/Sound management functions -PlaySound :: (sound: Sound) -> void #foreign raylib; -StopSound :: (sound: Sound) -> void #foreign raylib; -PauseSound :: (sound: Sound) -> void #foreign raylib; -ResumeSound :: (sound: Sound) -> void #foreign raylib; -IsSoundPlaying :: (sound: Sound) -> bool #foreign raylib; -SetSoundVolume :: (sound: Sound, volume: float) -> void #foreign raylib; -SetSoundPitch :: (sound: Sound, pitch: float) -> void #foreign raylib; -SetSoundPan :: (sound: Sound, pan: float) -> void #foreign raylib; -WaveCopy :: (wave: Wave) -> Wave #foreign raylib; -WaveCrop :: (wave: *Wave, initFrame: s32, finalFrame: s32) -> void #foreign raylib; -WaveFormat :: (wave: *Wave, sampleRate: s32, sampleSize: s32, channels: s32) -> void #foreign raylib; -LoadWaveSamples :: (wave: Wave) -> *float #foreign raylib; -UnloadWaveSamples :: (samples: *float) -> void #foreign raylib; +PlaySound :: (sound: Sound) -> void #foreign libraylib; +StopSound :: (sound: Sound) -> void #foreign libraylib; +PauseSound :: (sound: Sound) -> void #foreign libraylib; +ResumeSound :: (sound: Sound) -> void #foreign libraylib; +IsSoundPlaying :: (sound: Sound) -> bool #foreign libraylib; +SetSoundVolume :: (sound: Sound, volume: float) -> void #foreign libraylib; +SetSoundPitch :: (sound: Sound, pitch: float) -> void #foreign libraylib; +SetSoundPan :: (sound: Sound, pan: float) -> void #foreign libraylib; +WaveCopy :: (wave: Wave) -> Wave #foreign libraylib; +WaveCrop :: (wave: *Wave, initFrame: s32, finalFrame: s32) -> void #foreign libraylib; +WaveFormat :: (wave: *Wave, sampleRate: s32, sampleSize: s32, channels: s32) -> void #foreign libraylib; +LoadWaveSamples :: (wave: Wave) -> *float #foreign libraylib; +UnloadWaveSamples :: (samples: *float) -> void #foreign libraylib; // Music management functions -LoadMusicStream :: (fileName: *u8) -> Music #foreign raylib; -LoadMusicStreamFromMemory :: (fileType: *u8, data: *u8, dataSize: s32) -> Music #foreign raylib; -IsMusicValid :: (music: Music) -> bool #foreign raylib; -UnloadMusicStream :: (music: Music) -> void #foreign raylib; -PlayMusicStream :: (music: Music) -> void #foreign raylib; -IsMusicStreamPlaying :: (music: Music) -> bool #foreign raylib; -UpdateMusicStream :: (music: Music) -> void #foreign raylib; -StopMusicStream :: (music: Music) -> void #foreign raylib; -PauseMusicStream :: (music: Music) -> void #foreign raylib; -ResumeMusicStream :: (music: Music) -> void #foreign raylib; -SeekMusicStream :: (music: Music, position: float) -> void #foreign raylib; -SetMusicVolume :: (music: Music, volume: float) -> void #foreign raylib; -SetMusicPitch :: (music: Music, pitch: float) -> void #foreign raylib; -SetMusicPan :: (music: Music, pan: float) -> void #foreign raylib; -GetMusicTimeLength :: (music: Music) -> float #foreign raylib; -GetMusicTimePlayed :: (music: Music) -> float #foreign raylib; +LoadMusicStream :: (fileName: *u8) -> Music #foreign libraylib; +LoadMusicStreamFromMemory :: (fileType: *u8, data: *u8, dataSize: s32) -> Music #foreign libraylib; +IsMusicValid :: (music: Music) -> bool #foreign libraylib; +UnloadMusicStream :: (music: Music) -> void #foreign libraylib; +PlayMusicStream :: (music: Music) -> void #foreign libraylib; +IsMusicStreamPlaying :: (music: Music) -> bool #foreign libraylib; +UpdateMusicStream :: (music: Music) -> void #foreign libraylib; +StopMusicStream :: (music: Music) -> void #foreign libraylib; +PauseMusicStream :: (music: Music) -> void #foreign libraylib; +ResumeMusicStream :: (music: Music) -> void #foreign libraylib; +SeekMusicStream :: (music: Music, position: float) -> void #foreign libraylib; +SetMusicVolume :: (music: Music, volume: float) -> void #foreign libraylib; +SetMusicPitch :: (music: Music, pitch: float) -> void #foreign libraylib; +SetMusicPan :: (music: Music, pan: float) -> void #foreign libraylib; +GetMusicTimeLength :: (music: Music) -> float #foreign libraylib; +GetMusicTimePlayed :: (music: Music) -> float #foreign libraylib; // AudioStream management functions -LoadAudioStream :: (sampleRate: u32, sampleSize: u32, channels: u32) -> AudioStream #foreign raylib; -IsAudioStreamValid :: (stream: AudioStream) -> bool #foreign raylib; -UnloadAudioStream :: (stream: AudioStream) -> void #foreign raylib; -UpdateAudioStream :: (stream: AudioStream, data: *void, frameCount: s32) -> void #foreign raylib; -IsAudioStreamProcessed :: (stream: AudioStream) -> bool #foreign raylib; -PlayAudioStream :: (stream: AudioStream) -> void #foreign raylib; -PauseAudioStream :: (stream: AudioStream) -> void #foreign raylib; -ResumeAudioStream :: (stream: AudioStream) -> void #foreign raylib; -IsAudioStreamPlaying :: (stream: AudioStream) -> bool #foreign raylib; -StopAudioStream :: (stream: AudioStream) -> void #foreign raylib; -SetAudioStreamVolume :: (stream: AudioStream, volume: float) -> void #foreign raylib; -SetAudioStreamPitch :: (stream: AudioStream, pitch: float) -> void #foreign raylib; -SetAudioStreamPan :: (stream: AudioStream, pan: float) -> void #foreign raylib; -SetAudioStreamBufferSizeDefault :: (size: s32) -> void #foreign raylib; -SetAudioStreamCallback :: (stream: AudioStream, callback: AudioCallback) -> void #foreign raylib; +LoadAudioStream :: (sampleRate: u32, sampleSize: u32, channels: u32) -> AudioStream #foreign libraylib; +IsAudioStreamValid :: (stream: AudioStream) -> bool #foreign libraylib; +UnloadAudioStream :: (stream: AudioStream) -> void #foreign libraylib; +UpdateAudioStream :: (stream: AudioStream, data: *void, frameCount: s32) -> void #foreign libraylib; +IsAudioStreamProcessed :: (stream: AudioStream) -> bool #foreign libraylib; +PlayAudioStream :: (stream: AudioStream) -> void #foreign libraylib; +PauseAudioStream :: (stream: AudioStream) -> void #foreign libraylib; +ResumeAudioStream :: (stream: AudioStream) -> void #foreign libraylib; +IsAudioStreamPlaying :: (stream: AudioStream) -> bool #foreign libraylib; +StopAudioStream :: (stream: AudioStream) -> void #foreign libraylib; +SetAudioStreamVolume :: (stream: AudioStream, volume: float) -> void #foreign libraylib; +SetAudioStreamPitch :: (stream: AudioStream, pitch: float) -> void #foreign libraylib; +SetAudioStreamPan :: (stream: AudioStream, pan: float) -> void #foreign libraylib; +SetAudioStreamBufferSizeDefault :: (size: s32) -> void #foreign libraylib; +SetAudioStreamCallback :: (stream: AudioStream, callback: AudioCallback) -> void #foreign libraylib; -AttachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback) -> void #foreign raylib; -DetachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback) -> void #foreign raylib; +AttachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback) -> void #foreign libraylib; +DetachAudioStreamProcessor :: (stream: AudioStream, processor: AudioCallback) -> void #foreign libraylib; -AttachAudioMixedProcessor :: (processor: AudioCallback) -> void #foreign raylib; -DetachAudioMixedProcessor :: (processor: AudioCallback) -> void #foreign raylib; +AttachAudioMixedProcessor :: (processor: AudioCallback) -> void #foreign libraylib; +DetachAudioMixedProcessor :: (processor: AudioCallback) -> void #foreign libraylib; // NOTE: Helper types to be used instead of array return types for *ToFloat functions float3 :: struct { @@ -1820,456 +1818,456 @@ float16 :: struct { } // Clamp float value -Clamp :: (value: float, min: float, max: float) -> float #foreign raylib; +Clamp :: (value: float, min: float, max: float) -> float #foreign libraylib; // Calculate linear interpolation between two floats -Lerp :: (start: float, end: float, amount: float) -> float #foreign raylib; +Lerp :: (start: float, end: float, amount: float) -> float #foreign libraylib; // Normalize input value within input range -Normalize :: (value: float, start: float, end: float) -> float #foreign raylib; +Normalize :: (value: float, start: float, end: float) -> float #foreign libraylib; // Remap input value within input range to output range -Remap :: (value: float, inputStart: float, inputEnd: float, outputStart: float, outputEnd: float) -> float #foreign raylib; +Remap :: (value: float, inputStart: float, inputEnd: float, outputStart: float, outputEnd: float) -> float #foreign libraylib; // Wrap input value from min to max -Wrap :: (value: float, min: float, max: float) -> float #foreign raylib; +Wrap :: (value: float, min: float, max: float) -> float #foreign libraylib; // Check whether two given floats are almost equal -FloatEquals :: (x: float, y: float) -> s32 #foreign raylib; +FloatEquals :: (x: float, y: float) -> s32 #foreign libraylib; // Vector with components value 0.0f -Vector2Zero :: () -> Vector2 #foreign raylib; +Vector2Zero :: () -> Vector2 #foreign libraylib; // Vector with components value 1.0f -Vector2One :: () -> Vector2 #foreign raylib; +Vector2One :: () -> Vector2 #foreign libraylib; // Add two vectors (v1 + v2) -Vector2Add :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Add :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Add vector and float value -Vector2AddValue :: (v: Vector2, add: float) -> Vector2 #foreign raylib; +Vector2AddValue :: (v: Vector2, add: float) -> Vector2 #foreign libraylib; // Subtract two vectors (v1 - v2) -Vector2Subtract :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Subtract :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Subtract vector by float value -Vector2SubtractValue :: (v: Vector2, sub: float) -> Vector2 #foreign raylib; +Vector2SubtractValue :: (v: Vector2, sub: float) -> Vector2 #foreign libraylib; // Calculate vector length -Vector2Length :: (v: Vector2) -> float #foreign raylib; +Vector2Length :: (v: Vector2) -> float #foreign libraylib; // Calculate vector square length -Vector2LengthSqr :: (v: Vector2) -> float #foreign raylib; +Vector2LengthSqr :: (v: Vector2) -> float #foreign libraylib; // Calculate two vectors dot product -Vector2DotProduct :: (v1: Vector2, v2: Vector2) -> float #foreign raylib; +Vector2DotProduct :: (v1: Vector2, v2: Vector2) -> float #foreign libraylib; // Calculate distance between two vectors -Vector2Distance :: (v1: Vector2, v2: Vector2) -> float #foreign raylib; +Vector2Distance :: (v1: Vector2, v2: Vector2) -> float #foreign libraylib; // Calculate square distance between two vectors -Vector2DistanceSqr :: (v1: Vector2, v2: Vector2) -> float #foreign raylib; +Vector2DistanceSqr :: (v1: Vector2, v2: Vector2) -> float #foreign libraylib; // Calculate angle between two vectors // NOTE: Angle is calculated from origin point (0, 0) -Vector2Angle :: (v1: Vector2, v2: Vector2) -> float #foreign raylib; +Vector2Angle :: (v1: Vector2, v2: Vector2) -> float #foreign libraylib; // Calculate angle defined by a two vectors line // NOTE: Parameters need to be normalized // Current implementation should be aligned with glm::angle -Vector2LineAngle :: (start: Vector2, end: Vector2) -> float #foreign raylib; +Vector2LineAngle :: (start: Vector2, end: Vector2) -> float #foreign libraylib; // Scale vector (multiply by value) -Vector2Scale :: (v: Vector2, scale: float) -> Vector2 #foreign raylib; +Vector2Scale :: (v: Vector2, scale: float) -> Vector2 #foreign libraylib; // Multiply vector by vector -Vector2Multiply :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Multiply :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Negate vector -Vector2Negate :: (v: Vector2) -> Vector2 #foreign raylib; +Vector2Negate :: (v: Vector2) -> Vector2 #foreign libraylib; // Divide vector by vector -Vector2Divide :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Divide :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Normalize provided vector -Vector2Normalize :: (v: Vector2) -> Vector2 #foreign raylib; +Vector2Normalize :: (v: Vector2) -> Vector2 #foreign libraylib; // Transforms a Vector2 by a given Matrix -Vector2Transform :: (v: Vector2, mat: Matrix) -> Vector2 #foreign raylib; +Vector2Transform :: (v: Vector2, mat: Matrix) -> Vector2 #foreign libraylib; // Calculate linear interpolation between two vectors -Vector2Lerp :: (v1: Vector2, v2: Vector2, amount: float) -> Vector2 #foreign raylib; +Vector2Lerp :: (v1: Vector2, v2: Vector2, amount: float) -> Vector2 #foreign libraylib; // Calculate reflected vector to normal -Vector2Reflect :: (v: Vector2, normal: Vector2) -> Vector2 #foreign raylib; +Vector2Reflect :: (v: Vector2, normal: Vector2) -> Vector2 #foreign libraylib; // Get min value for each pair of components -Vector2Min :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Min :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Get max value for each pair of components -Vector2Max :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign raylib; +Vector2Max :: (v1: Vector2, v2: Vector2) -> Vector2 #foreign libraylib; // Rotate vector by angle -Vector2Rotate :: (v: Vector2, angle: float) -> Vector2 #foreign raylib; +Vector2Rotate :: (v: Vector2, angle: float) -> Vector2 #foreign libraylib; // Move Vector towards target -Vector2MoveTowards :: (v: Vector2, target: Vector2, maxDistance: float) -> Vector2 #foreign raylib; +Vector2MoveTowards :: (v: Vector2, target: Vector2, maxDistance: float) -> Vector2 #foreign libraylib; // Invert the given vector -Vector2Invert :: (v: Vector2) -> Vector2 #foreign raylib; +Vector2Invert :: (v: Vector2) -> Vector2 #foreign libraylib; // Clamp the components of the vector between // min and max values specified by the given vectors -Vector2Clamp :: (v: Vector2, min: Vector2, max: Vector2) -> Vector2 #foreign raylib; +Vector2Clamp :: (v: Vector2, min: Vector2, max: Vector2) -> Vector2 #foreign libraylib; // Clamp the magnitude of the vector between two min and max values -Vector2ClampValue :: (v: Vector2, min: float, max: float) -> Vector2 #foreign raylib; +Vector2ClampValue :: (v: Vector2, min: float, max: float) -> Vector2 #foreign libraylib; // Check whether two given vectors are almost equal -Vector2Equals :: (p: Vector2, q: Vector2) -> s32 #foreign raylib; +Vector2Equals :: (p: Vector2, q: Vector2) -> s32 #foreign libraylib; // Compute the direction of a refracted ray // v: normalized direction of the incoming ray // n: normalized normal vector of the interface of two optical media // r: ratio of the refractive index of the medium from where the ray comes // to the refractive index of the medium on the other side of the surface -Vector2Refract :: (v: Vector2, n: Vector2, r: float) -> Vector2 #foreign raylib; +Vector2Refract :: (v: Vector2, n: Vector2, r: float) -> Vector2 #foreign libraylib; // Vector with components value 0.0f -Vector3Zero :: () -> Vector3 #foreign raylib; +Vector3Zero :: () -> Vector3 #foreign libraylib; // Vector with components value 1.0f -Vector3One :: () -> Vector3 #foreign raylib; +Vector3One :: () -> Vector3 #foreign libraylib; // Add two vectors -Vector3Add :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Add :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Add vector and float value -Vector3AddValue :: (v: Vector3, add: float) -> Vector3 #foreign raylib; +Vector3AddValue :: (v: Vector3, add: float) -> Vector3 #foreign libraylib; // Subtract two vectors -Vector3Subtract :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Subtract :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Subtract vector by float value -Vector3SubtractValue :: (v: Vector3, sub: float) -> Vector3 #foreign raylib; +Vector3SubtractValue :: (v: Vector3, sub: float) -> Vector3 #foreign libraylib; // Multiply vector by scalar -Vector3Scale :: (v: Vector3, scalar: float) -> Vector3 #foreign raylib; +Vector3Scale :: (v: Vector3, scalar: float) -> Vector3 #foreign libraylib; // Multiply vector by vector -Vector3Multiply :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Multiply :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Calculate two vectors cross product -Vector3CrossProduct :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3CrossProduct :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Calculate one vector perpendicular vector -Vector3Perpendicular :: (v: Vector3) -> Vector3 #foreign raylib; +Vector3Perpendicular :: (v: Vector3) -> Vector3 #foreign libraylib; // Calculate vector length -Vector3Length :: (v: Vector3) -> float #foreign raylib; +Vector3Length :: (v: Vector3) -> float #foreign libraylib; // Calculate vector square length -Vector3LengthSqr :: (v: Vector3) -> float #foreign raylib; +Vector3LengthSqr :: (v: Vector3) -> float #foreign libraylib; // Calculate two vectors dot product -Vector3DotProduct :: (v1: Vector3, v2: Vector3) -> float #foreign raylib; +Vector3DotProduct :: (v1: Vector3, v2: Vector3) -> float #foreign libraylib; // Calculate distance between two vectors -Vector3Distance :: (v1: Vector3, v2: Vector3) -> float #foreign raylib; +Vector3Distance :: (v1: Vector3, v2: Vector3) -> float #foreign libraylib; // Calculate square distance between two vectors -Vector3DistanceSqr :: (v1: Vector3, v2: Vector3) -> float #foreign raylib; +Vector3DistanceSqr :: (v1: Vector3, v2: Vector3) -> float #foreign libraylib; // Calculate angle between two vectors -Vector3Angle :: (v1: Vector3, v2: Vector3) -> float #foreign raylib; +Vector3Angle :: (v1: Vector3, v2: Vector3) -> float #foreign libraylib; // Negate provided vector (invert direction) -Vector3Negate :: (v: Vector3) -> Vector3 #foreign raylib; +Vector3Negate :: (v: Vector3) -> Vector3 #foreign libraylib; // Divide vector by vector -Vector3Divide :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Divide :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Normalize provided vector -Vector3Normalize :: (v: Vector3) -> Vector3 #foreign raylib; +Vector3Normalize :: (v: Vector3) -> Vector3 #foreign libraylib; //Calculate the projection of the vector v1 on to v2 -Vector3Project :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Project :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; //Calculate the rejection of the vector v1 on to v2 -Vector3Reject :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Reject :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Orthonormalize provided vectors // Makes vectors normalized and orthogonal to each other // Gram-Schmidt function implementation -Vector3OrthoNormalize :: (v1: *Vector3, v2: *Vector3) -> void #foreign raylib; +Vector3OrthoNormalize :: (v1: *Vector3, v2: *Vector3) -> void #foreign libraylib; // Transforms a Vector3 by a given Matrix -Vector3Transform :: (v: Vector3, mat: Matrix) -> Vector3 #foreign raylib; +Vector3Transform :: (v: Vector3, mat: Matrix) -> Vector3 #foreign libraylib; // Transform a vector by quaternion rotation -Vector3RotateByQuaternion :: (v: Vector3, q: Quaternion) -> Vector3 #foreign raylib; +Vector3RotateByQuaternion :: (v: Vector3, q: Quaternion) -> Vector3 #foreign libraylib; // Rotates a vector around an axis -Vector3RotateByAxisAngle :: (v: Vector3, axis: Vector3, angle: float) -> Vector3 #foreign raylib; +Vector3RotateByAxisAngle :: (v: Vector3, axis: Vector3, angle: float) -> Vector3 #foreign libraylib; // Move Vector towards target -Vector3MoveTowards :: (v: Vector3, target: Vector3, maxDistance: float) -> Vector3 #foreign raylib; +Vector3MoveTowards :: (v: Vector3, target: Vector3, maxDistance: float) -> Vector3 #foreign libraylib; // Calculate linear interpolation between two vectors -Vector3Lerp :: (v1: Vector3, v2: Vector3, amount: float) -> Vector3 #foreign raylib; +Vector3Lerp :: (v1: Vector3, v2: Vector3, amount: float) -> Vector3 #foreign libraylib; // Calculate cubic hermite interpolation between two vectors and their tangents // as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic -Vector3CubicHermite :: (v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: float) -> Vector3 #foreign raylib; +Vector3CubicHermite :: (v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: float) -> Vector3 #foreign libraylib; // Calculate reflected vector to normal -Vector3Reflect :: (v: Vector3, normal: Vector3) -> Vector3 #foreign raylib; +Vector3Reflect :: (v: Vector3, normal: Vector3) -> Vector3 #foreign libraylib; // Get min value for each pair of components -Vector3Min :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Min :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Get max value for each pair of components -Vector3Max :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign raylib; +Vector3Max :: (v1: Vector3, v2: Vector3) -> Vector3 #foreign libraylib; // Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) // NOTE: Assumes P is on the plane of the triangle -Vector3Barycenter :: (p: Vector3, a: Vector3, b: Vector3, c: Vector3) -> Vector3 #foreign raylib; +Vector3Barycenter :: (p: Vector3, a: Vector3, b: Vector3, c: Vector3) -> Vector3 #foreign libraylib; // Projects a Vector3 from screen space into object space // NOTE: We are avoiding calling other raymath functions despite available -Vector3Unproject :: (source: Vector3, projection: Matrix, view: Matrix) -> Vector3 #foreign raylib; +Vector3Unproject :: (source: Vector3, projection: Matrix, view: Matrix) -> Vector3 #foreign libraylib; // Get Vector3 as float array -Vector3ToFloatV :: (v: Vector3) -> float3 #foreign raylib; +Vector3ToFloatV :: (v: Vector3) -> float3 #foreign libraylib; // Invert the given vector -Vector3Invert :: (v: Vector3) -> Vector3 #foreign raylib; +Vector3Invert :: (v: Vector3) -> Vector3 #foreign libraylib; // Clamp the components of the vector between // min and max values specified by the given vectors -Vector3Clamp :: (v: Vector3, min: Vector3, max: Vector3) -> Vector3 #foreign raylib; +Vector3Clamp :: (v: Vector3, min: Vector3, max: Vector3) -> Vector3 #foreign libraylib; // Clamp the magnitude of the vector between two values -Vector3ClampValue :: (v: Vector3, min: float, max: float) -> Vector3 #foreign raylib; +Vector3ClampValue :: (v: Vector3, min: float, max: float) -> Vector3 #foreign libraylib; // Check whether two given vectors are almost equal -Vector3Equals :: (p: Vector3, q: Vector3) -> s32 #foreign raylib; +Vector3Equals :: (p: Vector3, q: Vector3) -> s32 #foreign libraylib; // Compute the direction of a refracted ray // v: normalized direction of the incoming ray // n: normalized normal vector of the interface of two optical media // r: ratio of the refractive index of the medium from where the ray comes // to the refractive index of the medium on the other side of the surface -Vector3Refract :: (v: Vector3, n: Vector3, r: float) -> Vector3 #foreign raylib; +Vector3Refract :: (v: Vector3, n: Vector3, r: float) -> Vector3 #foreign libraylib; //---------------------------------------------------------------------------------- // Module Functions Definition - Vector4 math //---------------------------------------------------------------------------------- -Vector4Zero :: () -> Vector4 #foreign raylib; +Vector4Zero :: () -> Vector4 #foreign libraylib; -Vector4One :: () -> Vector4 #foreign raylib; +Vector4One :: () -> Vector4 #foreign libraylib; -Vector4Add :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Add :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; -Vector4AddValue :: (v: Vector4, add: float) -> Vector4 #foreign raylib; +Vector4AddValue :: (v: Vector4, add: float) -> Vector4 #foreign libraylib; -Vector4Subtract :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Subtract :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; -Vector4SubtractValue :: (v: Vector4, add: float) -> Vector4 #foreign raylib; +Vector4SubtractValue :: (v: Vector4, add: float) -> Vector4 #foreign libraylib; -Vector4Length :: (v: Vector4) -> float #foreign raylib; +Vector4Length :: (v: Vector4) -> float #foreign libraylib; -Vector4LengthSqr :: (v: Vector4) -> float #foreign raylib; +Vector4LengthSqr :: (v: Vector4) -> float #foreign libraylib; -Vector4DotProduct :: (v1: Vector4, v2: Vector4) -> float #foreign raylib; +Vector4DotProduct :: (v1: Vector4, v2: Vector4) -> float #foreign libraylib; // Calculate distance between two vectors -Vector4Distance :: (v1: Vector4, v2: Vector4) -> float #foreign raylib; +Vector4Distance :: (v1: Vector4, v2: Vector4) -> float #foreign libraylib; // Calculate square distance between two vectors -Vector4DistanceSqr :: (v1: Vector4, v2: Vector4) -> float #foreign raylib; +Vector4DistanceSqr :: (v1: Vector4, v2: Vector4) -> float #foreign libraylib; -Vector4Scale :: (v: Vector4, scale: float) -> Vector4 #foreign raylib; +Vector4Scale :: (v: Vector4, scale: float) -> Vector4 #foreign libraylib; // Multiply vector by vector -Vector4Multiply :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Multiply :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; // Negate vector -Vector4Negate :: (v: Vector4) -> Vector4 #foreign raylib; +Vector4Negate :: (v: Vector4) -> Vector4 #foreign libraylib; // Divide vector by vector -Vector4Divide :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Divide :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; // Normalize provided vector -Vector4Normalize :: (v: Vector4) -> Vector4 #foreign raylib; +Vector4Normalize :: (v: Vector4) -> Vector4 #foreign libraylib; // Get min value for each pair of components -Vector4Min :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Min :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; // Get max value for each pair of components -Vector4Max :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign raylib; +Vector4Max :: (v1: Vector4, v2: Vector4) -> Vector4 #foreign libraylib; // Calculate linear interpolation between two vectors -Vector4Lerp :: (v1: Vector4, v2: Vector4, amount: float) -> Vector4 #foreign raylib; +Vector4Lerp :: (v1: Vector4, v2: Vector4, amount: float) -> Vector4 #foreign libraylib; // Move Vector towards target -Vector4MoveTowards :: (v: Vector4, target: Vector4, maxDistance: float) -> Vector4 #foreign raylib; +Vector4MoveTowards :: (v: Vector4, target: Vector4, maxDistance: float) -> Vector4 #foreign libraylib; // Invert the given vector -Vector4Invert :: (v: Vector4) -> Vector4 #foreign raylib; +Vector4Invert :: (v: Vector4) -> Vector4 #foreign libraylib; // Check whether two given vectors are almost equal -Vector4Equals :: (p: Vector4, q: Vector4) -> s32 #foreign raylib; +Vector4Equals :: (p: Vector4, q: Vector4) -> s32 #foreign libraylib; // Compute matrix determinant -MatrixDeterminant :: (mat: Matrix) -> float #foreign raylib; +MatrixDeterminant :: (mat: Matrix) -> float #foreign libraylib; // Get the trace of the matrix (sum of the values along the diagonal) -MatrixTrace :: (mat: Matrix) -> float #foreign raylib; +MatrixTrace :: (mat: Matrix) -> float #foreign libraylib; // Transposes provided matrix -MatrixTranspose :: (mat: Matrix) -> Matrix #foreign raylib; +MatrixTranspose :: (mat: Matrix) -> Matrix #foreign libraylib; // Invert provided matrix -MatrixInvert :: (mat: Matrix) -> Matrix #foreign raylib; +MatrixInvert :: (mat: Matrix) -> Matrix #foreign libraylib; // Get identity matrix -MatrixIdentity :: () -> Matrix #foreign raylib; +MatrixIdentity :: () -> Matrix #foreign libraylib; // Add two matrices -MatrixAdd :: (left: Matrix, right: Matrix) -> Matrix #foreign raylib; +MatrixAdd :: (left: Matrix, right: Matrix) -> Matrix #foreign libraylib; // Subtract two matrices (left - right) -MatrixSubtract :: (left: Matrix, right: Matrix) -> Matrix #foreign raylib; +MatrixSubtract :: (left: Matrix, right: Matrix) -> Matrix #foreign libraylib; // Get two matrix multiplication // NOTE: When multiplying matrices... the order matters! -MatrixMultiply :: (left: Matrix, right: Matrix) -> Matrix #foreign raylib; +MatrixMultiply :: (left: Matrix, right: Matrix) -> Matrix #foreign libraylib; // Get translation matrix -MatrixTranslate :: (x: float, y: float, z: float) -> Matrix #foreign raylib; +MatrixTranslate :: (x: float, y: float, z: float) -> Matrix #foreign libraylib; // Create rotation matrix from axis and angle // NOTE: Angle should be provided in radians -MatrixRotate :: (axis: Vector3, angle: float) -> Matrix #foreign raylib; +MatrixRotate :: (axis: Vector3, angle: float) -> Matrix #foreign libraylib; // Get x-rotation matrix // NOTE: Angle must be provided in radians -MatrixRotateX :: (angle: float) -> Matrix #foreign raylib; +MatrixRotateX :: (angle: float) -> Matrix #foreign libraylib; // Get y-rotation matrix // NOTE: Angle must be provided in radians -MatrixRotateY :: (angle: float) -> Matrix #foreign raylib; +MatrixRotateY :: (angle: float) -> Matrix #foreign libraylib; // Get z-rotation matrix // NOTE: Angle must be provided in radians -MatrixRotateZ :: (angle: float) -> Matrix #foreign raylib; +MatrixRotateZ :: (angle: float) -> Matrix #foreign libraylib; // Get xyz-rotation matrix // NOTE: Angle must be provided in radians -MatrixRotateXYZ :: (angle: Vector3) -> Matrix #foreign raylib; +MatrixRotateXYZ :: (angle: Vector3) -> Matrix #foreign libraylib; // Get zyx-rotation matrix // NOTE: Angle must be provided in radians -MatrixRotateZYX :: (angle: Vector3) -> Matrix #foreign raylib; +MatrixRotateZYX :: (angle: Vector3) -> Matrix #foreign libraylib; // Get scaling matrix -MatrixScale :: (x: float, y: float, z: float) -> Matrix #foreign raylib; +MatrixScale :: (x: float, y: float, z: float) -> Matrix #foreign libraylib; // Get perspective projection matrix -MatrixFrustum :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign raylib; +MatrixFrustum :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign libraylib; // Get perspective projection matrix // NOTE: Fovy angle must be provided in radians -MatrixPerspective :: (fovY: float64, aspect: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign raylib; +MatrixPerspective :: (fovY: float64, aspect: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign libraylib; // Get orthographic projection matrix -MatrixOrtho :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign raylib; +MatrixOrtho :: (left: float64, right: float64, bottom: float64, top: float64, nearPlane: float64, farPlane: float64) -> Matrix #foreign libraylib; // Get camera look-at matrix (view matrix) -MatrixLookAt :: (eye: Vector3, target: Vector3, up: Vector3) -> Matrix #foreign raylib; +MatrixLookAt :: (eye: Vector3, target: Vector3, up: Vector3) -> Matrix #foreign libraylib; // Get float array of matrix data -MatrixToFloatV :: (mat: Matrix) -> float16 #foreign raylib; +MatrixToFloatV :: (mat: Matrix) -> float16 #foreign libraylib; // Add two quaternions -QuaternionAdd :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign raylib; +QuaternionAdd :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign libraylib; // Add quaternion and float value -QuaternionAddValue :: (q: Quaternion, add: float) -> Quaternion #foreign raylib; +QuaternionAddValue :: (q: Quaternion, add: float) -> Quaternion #foreign libraylib; // Subtract two quaternions -QuaternionSubtract :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign raylib; +QuaternionSubtract :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign libraylib; // Subtract quaternion and float value -QuaternionSubtractValue :: (q: Quaternion, sub: float) -> Quaternion #foreign raylib; +QuaternionSubtractValue :: (q: Quaternion, sub: float) -> Quaternion #foreign libraylib; // Get identity quaternion -QuaternionIdentity :: () -> Quaternion #foreign raylib; +QuaternionIdentity :: () -> Quaternion #foreign libraylib; // Computes the length of a quaternion -QuaternionLength :: (q: Quaternion) -> float #foreign raylib; +QuaternionLength :: (q: Quaternion) -> float #foreign libraylib; // Normalize provided quaternion -QuaternionNormalize :: (q: Quaternion) -> Quaternion #foreign raylib; +QuaternionNormalize :: (q: Quaternion) -> Quaternion #foreign libraylib; // Invert provided quaternion -QuaternionInvert :: (q: Quaternion) -> Quaternion #foreign raylib; +QuaternionInvert :: (q: Quaternion) -> Quaternion #foreign libraylib; // Calculate two quaternion multiplication -QuaternionMultiply :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign raylib; +QuaternionMultiply :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign libraylib; // Scale quaternion by float value -QuaternionScale :: (q: Quaternion, mul: float) -> Quaternion #foreign raylib; +QuaternionScale :: (q: Quaternion, mul: float) -> Quaternion #foreign libraylib; // Divide two quaternions -QuaternionDivide :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign raylib; +QuaternionDivide :: (q1: Quaternion, q2: Quaternion) -> Quaternion #foreign libraylib; // Calculate linear interpolation between two quaternions -QuaternionLerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign raylib; +QuaternionLerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign libraylib; // Calculate slerp-optimized interpolation between two quaternions -QuaternionNlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign raylib; +QuaternionNlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign libraylib; // Calculates spherical linear interpolation between two quaternions -QuaternionSlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign raylib; +QuaternionSlerp :: (q1: Quaternion, q2: Quaternion, amount: float) -> Quaternion #foreign libraylib; // Calculate quaternion cubic spline interpolation using Cubic Hermite Spline algorithm // as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic -QuaternionCubicHermiteSpline :: (q1: Quaternion, outTangent1: Quaternion, q2: Quaternion, inTangent2: Quaternion, t: float) -> Quaternion #foreign raylib; +QuaternionCubicHermiteSpline :: (q1: Quaternion, outTangent1: Quaternion, q2: Quaternion, inTangent2: Quaternion, t: float) -> Quaternion #foreign libraylib; // Calculate quaternion based on the rotation from one vector to another -QuaternionFromVector3ToVector3 :: (from: Vector3, to: Vector3) -> Quaternion #foreign raylib; +QuaternionFromVector3ToVector3 :: (from: Vector3, to: Vector3) -> Quaternion #foreign libraylib; // Get a quaternion for a given rotation matrix -QuaternionFromMatrix :: (mat: Matrix) -> Quaternion #foreign raylib; +QuaternionFromMatrix :: (mat: Matrix) -> Quaternion #foreign libraylib; // Get a matrix for a given quaternion -QuaternionToMatrix :: (q: Quaternion) -> Matrix #foreign raylib; +QuaternionToMatrix :: (q: Quaternion) -> Matrix #foreign libraylib; // Get rotation quaternion for an angle and axis // NOTE: Angle must be provided in radians -QuaternionFromAxisAngle :: (axis: Vector3, angle: float) -> Quaternion #foreign raylib; +QuaternionFromAxisAngle :: (axis: Vector3, angle: float) -> Quaternion #foreign libraylib; // Get the rotation angle and axis for a given quaternion -QuaternionToAxisAngle :: (q: Quaternion, outAxis: *Vector3, outAngle: *float) -> void #foreign raylib; +QuaternionToAxisAngle :: (q: Quaternion, outAxis: *Vector3, outAngle: *float) -> void #foreign libraylib; // Get the quaternion equivalent to Euler angles // NOTE: Rotation order is ZYX -QuaternionFromEuler :: (pitch: float, yaw: float, roll: float) -> Quaternion #foreign raylib; +QuaternionFromEuler :: (pitch: float, yaw: float, roll: float) -> Quaternion #foreign libraylib; // Get the Euler angles equivalent to quaternion (roll, pitch, yaw) // NOTE: Angles are returned in a Vector3 struct in radians -QuaternionToEuler :: (q: Quaternion) -> Vector3 #foreign raylib; +QuaternionToEuler :: (q: Quaternion) -> Vector3 #foreign libraylib; // Transform a quaternion given a transformation matrix -QuaternionTransform :: (q: Quaternion, mat: Matrix) -> Quaternion #foreign raylib; +QuaternionTransform :: (q: Quaternion, mat: Matrix) -> Quaternion #foreign libraylib; // Check whether two given quaternions are almost equal -QuaternionEquals :: (p: Quaternion, q: Quaternion) -> s32 #foreign raylib; +QuaternionEquals :: (p: Quaternion, q: Quaternion) -> s32 #foreign libraylib; // Decompose a transformation matrix into its rotational, translational and scaling components -MatrixDecompose :: (mat: Matrix, translation: *Vector3, rotation: *Quaternion, scale: *Vector3) -> void #foreign raylib; +MatrixDecompose :: (mat: Matrix, translation: *Vector3, rotation: *Quaternion, scale: *Vector3) -> void #foreign libraylib; #scope_file @@ -2278,520 +2276,833 @@ MatrixDecompose :: (mat: Matrix, translation: *Vector3, rotation: *Quaternion, s #run { { - instance: Vector2; - assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "Vector2.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector2.x)) == 4, "Vector2.x has unexpected size % instead of 4", size_of(type_of(Vector2.x))); - assert(((cast(*void)(*instance.y)) - cast(*void)(*instance)) == 4, "Vector2.y has unexpected offset % instead of 4", ((cast(*void)(*instance.y)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector2.y)) == 4, "Vector2.y has unexpected size % instead of 4", size_of(type_of(Vector2.y))); + info := type_info(Vector2); + for info.members { + if it.name == { + case "x"; + assert(it.offset_in_bytes == 0, "Vector2.x has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector2.x has unexpected size % instead of 4", it.type.runtime_size); + case "y"; + assert(it.offset_in_bytes == 4, "Vector2.y has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector2.y has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Vector2) == 8, "Vector2 has size % instead of 8", size_of(Vector2)); } { - instance: Vector3; - assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "Vector3.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector3.x)) == 4, "Vector3.x has unexpected size % instead of 4", size_of(type_of(Vector3.x))); - assert(((cast(*void)(*instance.y)) - cast(*void)(*instance)) == 4, "Vector3.y has unexpected offset % instead of 4", ((cast(*void)(*instance.y)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector3.y)) == 4, "Vector3.y has unexpected size % instead of 4", size_of(type_of(Vector3.y))); - assert(((cast(*void)(*instance.z)) - cast(*void)(*instance)) == 8, "Vector3.z has unexpected offset % instead of 8", ((cast(*void)(*instance.z)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector3.z)) == 4, "Vector3.z has unexpected size % instead of 4", size_of(type_of(Vector3.z))); + info := type_info(Vector3); + for info.members { + if it.name == { + case "x"; + assert(it.offset_in_bytes == 0, "Vector3.x has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector3.x has unexpected size % instead of 4", it.type.runtime_size); + case "y"; + assert(it.offset_in_bytes == 4, "Vector3.y has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector3.y has unexpected size % instead of 4", it.type.runtime_size); + case "z"; + assert(it.offset_in_bytes == 8, "Vector3.z has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector3.z has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Vector3) == 12, "Vector3 has size % instead of 12", size_of(Vector3)); } { - instance: Vector4; - assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "Vector4.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector4.x)) == 4, "Vector4.x has unexpected size % instead of 4", size_of(type_of(Vector4.x))); - assert(((cast(*void)(*instance.y)) - cast(*void)(*instance)) == 4, "Vector4.y has unexpected offset % instead of 4", ((cast(*void)(*instance.y)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector4.y)) == 4, "Vector4.y has unexpected size % instead of 4", size_of(type_of(Vector4.y))); - assert(((cast(*void)(*instance.z)) - cast(*void)(*instance)) == 8, "Vector4.z has unexpected offset % instead of 8", ((cast(*void)(*instance.z)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector4.z)) == 4, "Vector4.z has unexpected size % instead of 4", size_of(type_of(Vector4.z))); - assert(((cast(*void)(*instance.w)) - cast(*void)(*instance)) == 12, "Vector4.w has unexpected offset % instead of 12", ((cast(*void)(*instance.w)) - cast(*void)(*instance))); - assert(size_of(type_of(Vector4.w)) == 4, "Vector4.w has unexpected size % instead of 4", size_of(type_of(Vector4.w))); + info := type_info(Vector4); + for info.members { + if it.name == { + case "x"; + assert(it.offset_in_bytes == 0, "Vector4.x has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector4.x has unexpected size % instead of 4", it.type.runtime_size); + case "y"; + assert(it.offset_in_bytes == 4, "Vector4.y has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector4.y has unexpected size % instead of 4", it.type.runtime_size); + case "z"; + assert(it.offset_in_bytes == 8, "Vector4.z has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector4.z has unexpected size % instead of 4", it.type.runtime_size); + case "w"; + assert(it.offset_in_bytes == 12, "Vector4.w has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Vector4.w has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Vector4) == 16, "Vector4 has size % instead of 16", size_of(Vector4)); } { - instance: Matrix; - assert(((cast(*void)(*instance.m0)) - cast(*void)(*instance)) == 0, "Matrix.m0 has unexpected offset % instead of 0", ((cast(*void)(*instance.m0)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m0)) == 4, "Matrix.m0 has unexpected size % instead of 4", size_of(type_of(Matrix.m0))); - assert(((cast(*void)(*instance.m4)) - cast(*void)(*instance)) == 4, "Matrix.m4 has unexpected offset % instead of 4", ((cast(*void)(*instance.m4)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m4)) == 4, "Matrix.m4 has unexpected size % instead of 4", size_of(type_of(Matrix.m4))); - assert(((cast(*void)(*instance.m8)) - cast(*void)(*instance)) == 8, "Matrix.m8 has unexpected offset % instead of 8", ((cast(*void)(*instance.m8)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m8)) == 4, "Matrix.m8 has unexpected size % instead of 4", size_of(type_of(Matrix.m8))); - assert(((cast(*void)(*instance.m12)) - cast(*void)(*instance)) == 12, "Matrix.m12 has unexpected offset % instead of 12", ((cast(*void)(*instance.m12)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m12)) == 4, "Matrix.m12 has unexpected size % instead of 4", size_of(type_of(Matrix.m12))); - assert(((cast(*void)(*instance.m1)) - cast(*void)(*instance)) == 16, "Matrix.m1 has unexpected offset % instead of 16", ((cast(*void)(*instance.m1)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m1)) == 4, "Matrix.m1 has unexpected size % instead of 4", size_of(type_of(Matrix.m1))); - assert(((cast(*void)(*instance.m5)) - cast(*void)(*instance)) == 20, "Matrix.m5 has unexpected offset % instead of 20", ((cast(*void)(*instance.m5)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m5)) == 4, "Matrix.m5 has unexpected size % instead of 4", size_of(type_of(Matrix.m5))); - assert(((cast(*void)(*instance.m9)) - cast(*void)(*instance)) == 24, "Matrix.m9 has unexpected offset % instead of 24", ((cast(*void)(*instance.m9)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m9)) == 4, "Matrix.m9 has unexpected size % instead of 4", size_of(type_of(Matrix.m9))); - assert(((cast(*void)(*instance.m13)) - cast(*void)(*instance)) == 28, "Matrix.m13 has unexpected offset % instead of 28", ((cast(*void)(*instance.m13)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m13)) == 4, "Matrix.m13 has unexpected size % instead of 4", size_of(type_of(Matrix.m13))); - assert(((cast(*void)(*instance.m2)) - cast(*void)(*instance)) == 32, "Matrix.m2 has unexpected offset % instead of 32", ((cast(*void)(*instance.m2)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m2)) == 4, "Matrix.m2 has unexpected size % instead of 4", size_of(type_of(Matrix.m2))); - assert(((cast(*void)(*instance.m6)) - cast(*void)(*instance)) == 36, "Matrix.m6 has unexpected offset % instead of 36", ((cast(*void)(*instance.m6)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m6)) == 4, "Matrix.m6 has unexpected size % instead of 4", size_of(type_of(Matrix.m6))); - assert(((cast(*void)(*instance.m10)) - cast(*void)(*instance)) == 40, "Matrix.m10 has unexpected offset % instead of 40", ((cast(*void)(*instance.m10)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m10)) == 4, "Matrix.m10 has unexpected size % instead of 4", size_of(type_of(Matrix.m10))); - assert(((cast(*void)(*instance.m14)) - cast(*void)(*instance)) == 44, "Matrix.m14 has unexpected offset % instead of 44", ((cast(*void)(*instance.m14)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m14)) == 4, "Matrix.m14 has unexpected size % instead of 4", size_of(type_of(Matrix.m14))); - assert(((cast(*void)(*instance.m3)) - cast(*void)(*instance)) == 48, "Matrix.m3 has unexpected offset % instead of 48", ((cast(*void)(*instance.m3)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m3)) == 4, "Matrix.m3 has unexpected size % instead of 4", size_of(type_of(Matrix.m3))); - assert(((cast(*void)(*instance.m7)) - cast(*void)(*instance)) == 52, "Matrix.m7 has unexpected offset % instead of 52", ((cast(*void)(*instance.m7)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m7)) == 4, "Matrix.m7 has unexpected size % instead of 4", size_of(type_of(Matrix.m7))); - assert(((cast(*void)(*instance.m11)) - cast(*void)(*instance)) == 56, "Matrix.m11 has unexpected offset % instead of 56", ((cast(*void)(*instance.m11)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m11)) == 4, "Matrix.m11 has unexpected size % instead of 4", size_of(type_of(Matrix.m11))); - assert(((cast(*void)(*instance.m15)) - cast(*void)(*instance)) == 60, "Matrix.m15 has unexpected offset % instead of 60", ((cast(*void)(*instance.m15)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m15)) == 4, "Matrix.m15 has unexpected size % instead of 4", size_of(type_of(Matrix.m15))); + info := type_info(Matrix); + for info.members { + if it.name == { + case "m0"; + assert(it.offset_in_bytes == 0, "Matrix.m0 has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m0 has unexpected size % instead of 4", it.type.runtime_size); + case "m4"; + assert(it.offset_in_bytes == 4, "Matrix.m4 has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m4 has unexpected size % instead of 4", it.type.runtime_size); + case "m8"; + assert(it.offset_in_bytes == 8, "Matrix.m8 has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m8 has unexpected size % instead of 4", it.type.runtime_size); + case "m12"; + assert(it.offset_in_bytes == 12, "Matrix.m12 has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m12 has unexpected size % instead of 4", it.type.runtime_size); + case "m1"; + assert(it.offset_in_bytes == 16, "Matrix.m1 has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m1 has unexpected size % instead of 4", it.type.runtime_size); + case "m5"; + assert(it.offset_in_bytes == 20, "Matrix.m5 has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m5 has unexpected size % instead of 4", it.type.runtime_size); + case "m9"; + assert(it.offset_in_bytes == 24, "Matrix.m9 has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m9 has unexpected size % instead of 4", it.type.runtime_size); + case "m13"; + assert(it.offset_in_bytes == 28, "Matrix.m13 has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m13 has unexpected size % instead of 4", it.type.runtime_size); + case "m2"; + assert(it.offset_in_bytes == 32, "Matrix.m2 has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m2 has unexpected size % instead of 4", it.type.runtime_size); + case "m6"; + assert(it.offset_in_bytes == 36, "Matrix.m6 has unexpected offset % instead of 36", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m6 has unexpected size % instead of 4", it.type.runtime_size); + case "m10"; + assert(it.offset_in_bytes == 40, "Matrix.m10 has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m10 has unexpected size % instead of 4", it.type.runtime_size); + case "m14"; + assert(it.offset_in_bytes == 44, "Matrix.m14 has unexpected offset % instead of 44", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m14 has unexpected size % instead of 4", it.type.runtime_size); + case "m3"; + assert(it.offset_in_bytes == 48, "Matrix.m3 has unexpected offset % instead of 48", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m3 has unexpected size % instead of 4", it.type.runtime_size); + case "m7"; + assert(it.offset_in_bytes == 52, "Matrix.m7 has unexpected offset % instead of 52", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m7 has unexpected size % instead of 4", it.type.runtime_size); + case "m11"; + assert(it.offset_in_bytes == 56, "Matrix.m11 has unexpected offset % instead of 56", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m11 has unexpected size % instead of 4", it.type.runtime_size); + case "m15"; + assert(it.offset_in_bytes == 60, "Matrix.m15 has unexpected offset % instead of 60", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m15 has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Matrix) == 64, "Matrix has size % instead of 64", size_of(Matrix)); } { - 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))); - assert(size_of(type_of(Color.r)) == 1, "Color.r has unexpected size % instead of 1", size_of(type_of(Color.r))); - assert(((cast(*void)(*instance.g)) - cast(*void)(*instance)) == 1, "Color.g has unexpected offset % instead of 1", ((cast(*void)(*instance.g)) - cast(*void)(*instance))); - assert(size_of(type_of(Color.g)) == 1, "Color.g has unexpected size % instead of 1", size_of(type_of(Color.g))); - assert(((cast(*void)(*instance.b)) - cast(*void)(*instance)) == 2, "Color.b has unexpected offset % instead of 2", ((cast(*void)(*instance.b)) - cast(*void)(*instance))); - assert(size_of(type_of(Color.b)) == 1, "Color.b has unexpected size % instead of 1", size_of(type_of(Color.b))); - assert(((cast(*void)(*instance.a)) - cast(*void)(*instance)) == 3, "Color.a has unexpected offset % instead of 3", ((cast(*void)(*instance.a)) - cast(*void)(*instance))); - assert(size_of(type_of(Color.a)) == 1, "Color.a has unexpected size % instead of 1", size_of(type_of(Color.a))); + info := type_info(Color); + for info.members { + if it.name == { + case "r"; + assert(it.offset_in_bytes == 0, "Color.r has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "Color.r has unexpected size % instead of 1", it.type.runtime_size); + case "g"; + assert(it.offset_in_bytes == 1, "Color.g has unexpected offset % instead of 1", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "Color.g has unexpected size % instead of 1", it.type.runtime_size); + case "b"; + assert(it.offset_in_bytes == 2, "Color.b has unexpected offset % instead of 2", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "Color.b has unexpected size % instead of 1", it.type.runtime_size); + case "a"; + assert(it.offset_in_bytes == 3, "Color.a has unexpected offset % instead of 3", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "Color.a has unexpected size % instead of 1", it.type.runtime_size); + } + } assert(size_of(Color) == 4, "Color has size % instead of 4", size_of(Color)); } { - instance: Rectangle; - assert(((cast(*void)(*instance.x)) - cast(*void)(*instance)) == 0, "Rectangle.x has unexpected offset % instead of 0", ((cast(*void)(*instance.x)) - cast(*void)(*instance))); - assert(size_of(type_of(Rectangle.x)) == 4, "Rectangle.x has unexpected size % instead of 4", size_of(type_of(Rectangle.x))); - assert(((cast(*void)(*instance.y)) - cast(*void)(*instance)) == 4, "Rectangle.y has unexpected offset % instead of 4", ((cast(*void)(*instance.y)) - cast(*void)(*instance))); - assert(size_of(type_of(Rectangle.y)) == 4, "Rectangle.y has unexpected size % instead of 4", size_of(type_of(Rectangle.y))); - assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 8, "Rectangle.width has unexpected offset % instead of 8", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); - assert(size_of(type_of(Rectangle.width)) == 4, "Rectangle.width has unexpected size % instead of 4", size_of(type_of(Rectangle.width))); - assert(((cast(*void)(*instance.height)) - cast(*void)(*instance)) == 12, "Rectangle.height has unexpected offset % instead of 12", ((cast(*void)(*instance.height)) - cast(*void)(*instance))); - assert(size_of(type_of(Rectangle.height)) == 4, "Rectangle.height has unexpected size % instead of 4", size_of(type_of(Rectangle.height))); + info := type_info(Rectangle); + for info.members { + if it.name == { + case "x"; + assert(it.offset_in_bytes == 0, "Rectangle.x has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Rectangle.x has unexpected size % instead of 4", it.type.runtime_size); + case "y"; + assert(it.offset_in_bytes == 4, "Rectangle.y has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Rectangle.y has unexpected size % instead of 4", it.type.runtime_size); + case "width"; + assert(it.offset_in_bytes == 8, "Rectangle.width has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Rectangle.width has unexpected size % instead of 4", it.type.runtime_size); + case "height"; + assert(it.offset_in_bytes == 12, "Rectangle.height has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Rectangle.height has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Rectangle) == 16, "Rectangle has size % instead of 16", size_of(Rectangle)); } { - instance: Image; - assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 0, "Image.data has unexpected offset % instead of 0", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); - assert(size_of(type_of(Image.data)) == 8, "Image.data has unexpected size % instead of 8", size_of(type_of(Image.data))); - assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 8, "Image.width has unexpected offset % instead of 8", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); - assert(size_of(type_of(Image.width)) == 4, "Image.width has unexpected size % instead of 4", size_of(type_of(Image.width))); - assert(((cast(*void)(*instance.height)) - cast(*void)(*instance)) == 12, "Image.height has unexpected offset % instead of 12", ((cast(*void)(*instance.height)) - cast(*void)(*instance))); - assert(size_of(type_of(Image.height)) == 4, "Image.height has unexpected size % instead of 4", size_of(type_of(Image.height))); - assert(((cast(*void)(*instance.mipmaps)) - cast(*void)(*instance)) == 16, "Image.mipmaps has unexpected offset % instead of 16", ((cast(*void)(*instance.mipmaps)) - cast(*void)(*instance))); - assert(size_of(type_of(Image.mipmaps)) == 4, "Image.mipmaps has unexpected size % instead of 4", size_of(type_of(Image.mipmaps))); - assert(((cast(*void)(*instance.format)) - cast(*void)(*instance)) == 20, "Image.format has unexpected offset % instead of 20", ((cast(*void)(*instance.format)) - cast(*void)(*instance))); - assert(size_of(type_of(Image.format)) == 4, "Image.format has unexpected size % instead of 4", size_of(type_of(Image.format))); + info := type_info(Image); + for info.members { + if it.name == { + case "data"; + assert(it.offset_in_bytes == 0, "Image.data has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Image.data has unexpected size % instead of 8", it.type.runtime_size); + case "width"; + assert(it.offset_in_bytes == 8, "Image.width has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Image.width has unexpected size % instead of 4", it.type.runtime_size); + case "height"; + assert(it.offset_in_bytes == 12, "Image.height has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Image.height has unexpected size % instead of 4", it.type.runtime_size); + case "mipmaps"; + assert(it.offset_in_bytes == 16, "Image.mipmaps has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Image.mipmaps has unexpected size % instead of 4", it.type.runtime_size); + case "format"; + assert(it.offset_in_bytes == 20, "Image.format has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Image.format has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Image) == 24, "Image has size % instead of 24", size_of(Image)); } { - instance: Texture; - assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "Texture.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); - assert(size_of(type_of(Texture.id)) == 4, "Texture.id has unexpected size % instead of 4", size_of(type_of(Texture.id))); - assert(((cast(*void)(*instance.width)) - cast(*void)(*instance)) == 4, "Texture.width has unexpected offset % instead of 4", ((cast(*void)(*instance.width)) - cast(*void)(*instance))); - assert(size_of(type_of(Texture.width)) == 4, "Texture.width has unexpected size % instead of 4", size_of(type_of(Texture.width))); - assert(((cast(*void)(*instance.height)) - cast(*void)(*instance)) == 8, "Texture.height has unexpected offset % instead of 8", ((cast(*void)(*instance.height)) - cast(*void)(*instance))); - assert(size_of(type_of(Texture.height)) == 4, "Texture.height has unexpected size % instead of 4", size_of(type_of(Texture.height))); - assert(((cast(*void)(*instance.mipmaps)) - cast(*void)(*instance)) == 12, "Texture.mipmaps has unexpected offset % instead of 12", ((cast(*void)(*instance.mipmaps)) - cast(*void)(*instance))); - assert(size_of(type_of(Texture.mipmaps)) == 4, "Texture.mipmaps has unexpected size % instead of 4", size_of(type_of(Texture.mipmaps))); - assert(((cast(*void)(*instance.format)) - cast(*void)(*instance)) == 16, "Texture.format has unexpected offset % instead of 16", ((cast(*void)(*instance.format)) - cast(*void)(*instance))); - assert(size_of(type_of(Texture.format)) == 4, "Texture.format has unexpected size % instead of 4", size_of(type_of(Texture.format))); + info := type_info(Texture); + for info.members { + if it.name == { + case "id"; + assert(it.offset_in_bytes == 0, "Texture.id has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Texture.id has unexpected size % instead of 4", it.type.runtime_size); + case "width"; + assert(it.offset_in_bytes == 4, "Texture.width has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Texture.width has unexpected size % instead of 4", it.type.runtime_size); + case "height"; + assert(it.offset_in_bytes == 8, "Texture.height has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Texture.height has unexpected size % instead of 4", it.type.runtime_size); + case "mipmaps"; + assert(it.offset_in_bytes == 12, "Texture.mipmaps has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Texture.mipmaps has unexpected size % instead of 4", it.type.runtime_size); + case "format"; + assert(it.offset_in_bytes == 16, "Texture.format has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Texture.format has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Texture) == 20, "Texture has size % instead of 20", size_of(Texture)); } { - instance: RenderTexture; - assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "RenderTexture.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderTexture.id)) == 4, "RenderTexture.id has unexpected size % instead of 4", size_of(type_of(RenderTexture.id))); - assert(((cast(*void)(*instance.texture)) - cast(*void)(*instance)) == 4, "RenderTexture.texture has unexpected offset % instead of 4", ((cast(*void)(*instance.texture)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderTexture.texture)) == 20, "RenderTexture.texture has unexpected size % instead of 20", size_of(type_of(RenderTexture.texture))); - assert(((cast(*void)(*instance.depth)) - cast(*void)(*instance)) == 24, "RenderTexture.depth has unexpected offset % instead of 24", ((cast(*void)(*instance.depth)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderTexture.depth)) == 20, "RenderTexture.depth has unexpected size % instead of 20", size_of(type_of(RenderTexture.depth))); + info := type_info(RenderTexture); + for info.members { + if it.name == { + case "id"; + assert(it.offset_in_bytes == 0, "RenderTexture.id has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RenderTexture.id has unexpected size % instead of 4", it.type.runtime_size); + case "texture"; + assert(it.offset_in_bytes == 4, "RenderTexture.texture has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 20, "RenderTexture.texture has unexpected size % instead of 20", it.type.runtime_size); + case "depth"; + assert(it.offset_in_bytes == 24, "RenderTexture.depth has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 20, "RenderTexture.depth has unexpected size % instead of 20", it.type.runtime_size); + } + } assert(size_of(RenderTexture) == 44, "RenderTexture has size % instead of 44", size_of(RenderTexture)); } { - instance: NPatchInfo; - assert(((cast(*void)(*instance.source)) - cast(*void)(*instance)) == 0, "NPatchInfo.source has unexpected offset % instead of 0", ((cast(*void)(*instance.source)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.source)) == 16, "NPatchInfo.source has unexpected size % instead of 16", size_of(type_of(NPatchInfo.source))); - assert(((cast(*void)(*instance.left)) - cast(*void)(*instance)) == 16, "NPatchInfo.left has unexpected offset % instead of 16", ((cast(*void)(*instance.left)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.left)) == 4, "NPatchInfo.left has unexpected size % instead of 4", size_of(type_of(NPatchInfo.left))); - assert(((cast(*void)(*instance.top)) - cast(*void)(*instance)) == 20, "NPatchInfo.top has unexpected offset % instead of 20", ((cast(*void)(*instance.top)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.top)) == 4, "NPatchInfo.top has unexpected size % instead of 4", size_of(type_of(NPatchInfo.top))); - assert(((cast(*void)(*instance.right)) - cast(*void)(*instance)) == 24, "NPatchInfo.right has unexpected offset % instead of 24", ((cast(*void)(*instance.right)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.right)) == 4, "NPatchInfo.right has unexpected size % instead of 4", size_of(type_of(NPatchInfo.right))); - assert(((cast(*void)(*instance.bottom)) - cast(*void)(*instance)) == 28, "NPatchInfo.bottom has unexpected offset % instead of 28", ((cast(*void)(*instance.bottom)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.bottom)) == 4, "NPatchInfo.bottom has unexpected size % instead of 4", size_of(type_of(NPatchInfo.bottom))); - assert(((cast(*void)(*instance.layout)) - cast(*void)(*instance)) == 32, "NPatchInfo.layout has unexpected offset % instead of 32", ((cast(*void)(*instance.layout)) - cast(*void)(*instance))); - assert(size_of(type_of(NPatchInfo.layout)) == 4, "NPatchInfo.layout has unexpected size % instead of 4", size_of(type_of(NPatchInfo.layout))); + info := type_info(NPatchInfo); + for info.members { + if it.name == { + case "source"; + assert(it.offset_in_bytes == 0, "NPatchInfo.source has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "NPatchInfo.source has unexpected size % instead of 16", it.type.runtime_size); + case "left"; + assert(it.offset_in_bytes == 16, "NPatchInfo.left has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "NPatchInfo.left has unexpected size % instead of 4", it.type.runtime_size); + case "top"; + assert(it.offset_in_bytes == 20, "NPatchInfo.top has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "NPatchInfo.top has unexpected size % instead of 4", it.type.runtime_size); + case "right"; + assert(it.offset_in_bytes == 24, "NPatchInfo.right has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "NPatchInfo.right has unexpected size % instead of 4", it.type.runtime_size); + case "bottom"; + assert(it.offset_in_bytes == 28, "NPatchInfo.bottom has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "NPatchInfo.bottom has unexpected size % instead of 4", it.type.runtime_size); + case "layout"; + assert(it.offset_in_bytes == 32, "NPatchInfo.layout has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "NPatchInfo.layout has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(NPatchInfo) == 36, "NPatchInfo has size % instead of 36", size_of(NPatchInfo)); } { - instance: GlyphInfo; - assert(((cast(*void)(*instance.value)) - cast(*void)(*instance)) == 0, "GlyphInfo.value has unexpected offset % instead of 0", ((cast(*void)(*instance.value)) - cast(*void)(*instance))); - assert(size_of(type_of(GlyphInfo.value)) == 4, "GlyphInfo.value has unexpected size % instead of 4", size_of(type_of(GlyphInfo.value))); - assert(((cast(*void)(*instance.offsetX)) - cast(*void)(*instance)) == 4, "GlyphInfo.offsetX has unexpected offset % instead of 4", ((cast(*void)(*instance.offsetX)) - cast(*void)(*instance))); - assert(size_of(type_of(GlyphInfo.offsetX)) == 4, "GlyphInfo.offsetX has unexpected size % instead of 4", size_of(type_of(GlyphInfo.offsetX))); - assert(((cast(*void)(*instance.offsetY)) - cast(*void)(*instance)) == 8, "GlyphInfo.offsetY has unexpected offset % instead of 8", ((cast(*void)(*instance.offsetY)) - cast(*void)(*instance))); - assert(size_of(type_of(GlyphInfo.offsetY)) == 4, "GlyphInfo.offsetY has unexpected size % instead of 4", size_of(type_of(GlyphInfo.offsetY))); - assert(((cast(*void)(*instance.advanceX)) - cast(*void)(*instance)) == 12, "GlyphInfo.advanceX has unexpected offset % instead of 12", ((cast(*void)(*instance.advanceX)) - cast(*void)(*instance))); - assert(size_of(type_of(GlyphInfo.advanceX)) == 4, "GlyphInfo.advanceX has unexpected size % instead of 4", size_of(type_of(GlyphInfo.advanceX))); - assert(((cast(*void)(*instance.image)) - cast(*void)(*instance)) == 16, "GlyphInfo.image has unexpected offset % instead of 16", ((cast(*void)(*instance.image)) - cast(*void)(*instance))); - assert(size_of(type_of(GlyphInfo.image)) == 24, "GlyphInfo.image has unexpected size % instead of 24", size_of(type_of(GlyphInfo.image))); + info := type_info(GlyphInfo); + for info.members { + if it.name == { + case "value"; + assert(it.offset_in_bytes == 0, "GlyphInfo.value has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "GlyphInfo.value has unexpected size % instead of 4", it.type.runtime_size); + case "offsetX"; + assert(it.offset_in_bytes == 4, "GlyphInfo.offsetX has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "GlyphInfo.offsetX has unexpected size % instead of 4", it.type.runtime_size); + case "offsetY"; + assert(it.offset_in_bytes == 8, "GlyphInfo.offsetY has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "GlyphInfo.offsetY has unexpected size % instead of 4", it.type.runtime_size); + case "advanceX"; + assert(it.offset_in_bytes == 12, "GlyphInfo.advanceX has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "GlyphInfo.advanceX has unexpected size % instead of 4", it.type.runtime_size); + case "image"; + assert(it.offset_in_bytes == 16, "GlyphInfo.image has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 24, "GlyphInfo.image has unexpected size % instead of 24", it.type.runtime_size); + } + } assert(size_of(GlyphInfo) == 40, "GlyphInfo has size % instead of 40", size_of(GlyphInfo)); } { - instance: Font; - assert(((cast(*void)(*instance.baseSize)) - cast(*void)(*instance)) == 0, "Font.baseSize has unexpected offset % instead of 0", ((cast(*void)(*instance.baseSize)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.baseSize)) == 4, "Font.baseSize has unexpected size % instead of 4", size_of(type_of(Font.baseSize))); - assert(((cast(*void)(*instance.glyphCount)) - cast(*void)(*instance)) == 4, "Font.glyphCount has unexpected offset % instead of 4", ((cast(*void)(*instance.glyphCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.glyphCount)) == 4, "Font.glyphCount has unexpected size % instead of 4", size_of(type_of(Font.glyphCount))); - assert(((cast(*void)(*instance.glyphPadding)) - cast(*void)(*instance)) == 8, "Font.glyphPadding has unexpected offset % instead of 8", ((cast(*void)(*instance.glyphPadding)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.glyphPadding)) == 4, "Font.glyphPadding has unexpected size % instead of 4", size_of(type_of(Font.glyphPadding))); - assert(((cast(*void)(*instance.texture)) - cast(*void)(*instance)) == 12, "Font.texture has unexpected offset % instead of 12", ((cast(*void)(*instance.texture)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.texture)) == 20, "Font.texture has unexpected size % instead of 20", size_of(type_of(Font.texture))); - assert(((cast(*void)(*instance.recs)) - cast(*void)(*instance)) == 32, "Font.recs has unexpected offset % instead of 32", ((cast(*void)(*instance.recs)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.recs)) == 8, "Font.recs has unexpected size % instead of 8", size_of(type_of(Font.recs))); - assert(((cast(*void)(*instance.glyphs)) - cast(*void)(*instance)) == 40, "Font.glyphs has unexpected offset % instead of 40", ((cast(*void)(*instance.glyphs)) - cast(*void)(*instance))); - assert(size_of(type_of(Font.glyphs)) == 8, "Font.glyphs has unexpected size % instead of 8", size_of(type_of(Font.glyphs))); + info := type_info(Font); + for info.members { + if it.name == { + case "baseSize"; + assert(it.offset_in_bytes == 0, "Font.baseSize has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Font.baseSize has unexpected size % instead of 4", it.type.runtime_size); + case "glyphCount"; + assert(it.offset_in_bytes == 4, "Font.glyphCount has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Font.glyphCount has unexpected size % instead of 4", it.type.runtime_size); + case "glyphPadding"; + assert(it.offset_in_bytes == 8, "Font.glyphPadding has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Font.glyphPadding has unexpected size % instead of 4", it.type.runtime_size); + case "texture"; + assert(it.offset_in_bytes == 12, "Font.texture has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 20, "Font.texture has unexpected size % instead of 20", it.type.runtime_size); + case "recs"; + assert(it.offset_in_bytes == 32, "Font.recs has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Font.recs has unexpected size % instead of 8", it.type.runtime_size); + case "glyphs"; + assert(it.offset_in_bytes == 40, "Font.glyphs has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Font.glyphs has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Font) == 48, "Font has size % instead of 48", size_of(Font)); } { - instance: Camera3D; - assert(((cast(*void)(*instance.position)) - cast(*void)(*instance)) == 0, "Camera3D.position has unexpected offset % instead of 0", ((cast(*void)(*instance.position)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera3D.position)) == 12, "Camera3D.position has unexpected size % instead of 12", size_of(type_of(Camera3D.position))); - assert(((cast(*void)(*instance.target)) - cast(*void)(*instance)) == 12, "Camera3D.target has unexpected offset % instead of 12", ((cast(*void)(*instance.target)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera3D.target)) == 12, "Camera3D.target has unexpected size % instead of 12", size_of(type_of(Camera3D.target))); - assert(((cast(*void)(*instance.up)) - cast(*void)(*instance)) == 24, "Camera3D.up has unexpected offset % instead of 24", ((cast(*void)(*instance.up)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera3D.up)) == 12, "Camera3D.up has unexpected size % instead of 12", size_of(type_of(Camera3D.up))); - assert(((cast(*void)(*instance.fovy)) - cast(*void)(*instance)) == 36, "Camera3D.fovy has unexpected offset % instead of 36", ((cast(*void)(*instance.fovy)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera3D.fovy)) == 4, "Camera3D.fovy has unexpected size % instead of 4", size_of(type_of(Camera3D.fovy))); - assert(((cast(*void)(*instance.projection)) - cast(*void)(*instance)) == 40, "Camera3D.projection has unexpected offset % instead of 40", ((cast(*void)(*instance.projection)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera3D.projection)) == 4, "Camera3D.projection has unexpected size % instead of 4", size_of(type_of(Camera3D.projection))); + info := type_info(Camera3D); + for info.members { + if it.name == { + case "position"; + assert(it.offset_in_bytes == 0, "Camera3D.position has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Camera3D.position has unexpected size % instead of 12", it.type.runtime_size); + case "target"; + assert(it.offset_in_bytes == 12, "Camera3D.target has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Camera3D.target has unexpected size % instead of 12", it.type.runtime_size); + case "up"; + assert(it.offset_in_bytes == 24, "Camera3D.up has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Camera3D.up has unexpected size % instead of 12", it.type.runtime_size); + case "fovy"; + assert(it.offset_in_bytes == 36, "Camera3D.fovy has unexpected offset % instead of 36", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Camera3D.fovy has unexpected size % instead of 4", it.type.runtime_size); + case "projection"; + assert(it.offset_in_bytes == 40, "Camera3D.projection has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Camera3D.projection has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Camera3D) == 44, "Camera3D has size % instead of 44", size_of(Camera3D)); } { - instance: Camera2D; - assert(((cast(*void)(*instance.offset)) - cast(*void)(*instance)) == 0, "Camera2D.offset has unexpected offset % instead of 0", ((cast(*void)(*instance.offset)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera2D.offset)) == 8, "Camera2D.offset has unexpected size % instead of 8", size_of(type_of(Camera2D.offset))); - assert(((cast(*void)(*instance.target)) - cast(*void)(*instance)) == 8, "Camera2D.target has unexpected offset % instead of 8", ((cast(*void)(*instance.target)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera2D.target)) == 8, "Camera2D.target has unexpected size % instead of 8", size_of(type_of(Camera2D.target))); - assert(((cast(*void)(*instance.rotation)) - cast(*void)(*instance)) == 16, "Camera2D.rotation has unexpected offset % instead of 16", ((cast(*void)(*instance.rotation)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera2D.rotation)) == 4, "Camera2D.rotation has unexpected size % instead of 4", size_of(type_of(Camera2D.rotation))); - assert(((cast(*void)(*instance.zoom)) - cast(*void)(*instance)) == 20, "Camera2D.zoom has unexpected offset % instead of 20", ((cast(*void)(*instance.zoom)) - cast(*void)(*instance))); - assert(size_of(type_of(Camera2D.zoom)) == 4, "Camera2D.zoom has unexpected size % instead of 4", size_of(type_of(Camera2D.zoom))); + info := type_info(Camera2D); + for info.members { + if it.name == { + case "offset"; + assert(it.offset_in_bytes == 0, "Camera2D.offset has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Camera2D.offset has unexpected size % instead of 8", it.type.runtime_size); + case "target"; + assert(it.offset_in_bytes == 8, "Camera2D.target has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Camera2D.target has unexpected size % instead of 8", it.type.runtime_size); + case "rotation"; + assert(it.offset_in_bytes == 16, "Camera2D.rotation has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Camera2D.rotation has unexpected size % instead of 4", it.type.runtime_size); + case "zoom"; + assert(it.offset_in_bytes == 20, "Camera2D.zoom has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Camera2D.zoom has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Camera2D) == 24, "Camera2D has size % instead of 24", size_of(Camera2D)); } { - instance: Mesh; - assert(((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance)) == 0, "Mesh.vertexCount has unexpected offset % instead of 0", ((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.vertexCount)) == 4, "Mesh.vertexCount has unexpected size % instead of 4", size_of(type_of(Mesh.vertexCount))); - assert(((cast(*void)(*instance.triangleCount)) - cast(*void)(*instance)) == 4, "Mesh.triangleCount has unexpected offset % instead of 4", ((cast(*void)(*instance.triangleCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.triangleCount)) == 4, "Mesh.triangleCount has unexpected size % instead of 4", size_of(type_of(Mesh.triangleCount))); - assert(((cast(*void)(*instance.vertices)) - cast(*void)(*instance)) == 8, "Mesh.vertices has unexpected offset % instead of 8", ((cast(*void)(*instance.vertices)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.vertices)) == 8, "Mesh.vertices has unexpected size % instead of 8", size_of(type_of(Mesh.vertices))); - assert(((cast(*void)(*instance.texcoords)) - cast(*void)(*instance)) == 16, "Mesh.texcoords has unexpected offset % instead of 16", ((cast(*void)(*instance.texcoords)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.texcoords)) == 8, "Mesh.texcoords has unexpected size % instead of 8", size_of(type_of(Mesh.texcoords))); - assert(((cast(*void)(*instance.texcoords2)) - cast(*void)(*instance)) == 24, "Mesh.texcoords2 has unexpected offset % instead of 24", ((cast(*void)(*instance.texcoords2)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.texcoords2)) == 8, "Mesh.texcoords2 has unexpected size % instead of 8", size_of(type_of(Mesh.texcoords2))); - assert(((cast(*void)(*instance.normals)) - cast(*void)(*instance)) == 32, "Mesh.normals has unexpected offset % instead of 32", ((cast(*void)(*instance.normals)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.normals)) == 8, "Mesh.normals has unexpected size % instead of 8", size_of(type_of(Mesh.normals))); - assert(((cast(*void)(*instance.tangents)) - cast(*void)(*instance)) == 40, "Mesh.tangents has unexpected offset % instead of 40", ((cast(*void)(*instance.tangents)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.tangents)) == 8, "Mesh.tangents has unexpected size % instead of 8", size_of(type_of(Mesh.tangents))); - assert(((cast(*void)(*instance.colors)) - cast(*void)(*instance)) == 48, "Mesh.colors has unexpected offset % instead of 48", ((cast(*void)(*instance.colors)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.colors)) == 8, "Mesh.colors has unexpected size % instead of 8", size_of(type_of(Mesh.colors))); - assert(((cast(*void)(*instance.indices)) - cast(*void)(*instance)) == 56, "Mesh.indices has unexpected offset % instead of 56", ((cast(*void)(*instance.indices)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.indices)) == 8, "Mesh.indices has unexpected size % instead of 8", size_of(type_of(Mesh.indices))); - assert(((cast(*void)(*instance.animVertices)) - cast(*void)(*instance)) == 64, "Mesh.animVertices has unexpected offset % instead of 64", ((cast(*void)(*instance.animVertices)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.animVertices)) == 8, "Mesh.animVertices has unexpected size % instead of 8", size_of(type_of(Mesh.animVertices))); - assert(((cast(*void)(*instance.animNormals)) - cast(*void)(*instance)) == 72, "Mesh.animNormals has unexpected offset % instead of 72", ((cast(*void)(*instance.animNormals)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.animNormals)) == 8, "Mesh.animNormals has unexpected size % instead of 8", size_of(type_of(Mesh.animNormals))); - assert(((cast(*void)(*instance.boneIds)) - cast(*void)(*instance)) == 80, "Mesh.boneIds has unexpected offset % instead of 80", ((cast(*void)(*instance.boneIds)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.boneIds)) == 8, "Mesh.boneIds has unexpected size % instead of 8", size_of(type_of(Mesh.boneIds))); - assert(((cast(*void)(*instance.boneWeights)) - cast(*void)(*instance)) == 88, "Mesh.boneWeights has unexpected offset % instead of 88", ((cast(*void)(*instance.boneWeights)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.boneWeights)) == 8, "Mesh.boneWeights has unexpected size % instead of 8", size_of(type_of(Mesh.boneWeights))); - assert(((cast(*void)(*instance.boneMatrices)) - cast(*void)(*instance)) == 96, "Mesh.boneMatrices has unexpected offset % instead of 96", ((cast(*void)(*instance.boneMatrices)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.boneMatrices)) == 8, "Mesh.boneMatrices has unexpected size % instead of 8", size_of(type_of(Mesh.boneMatrices))); - assert(((cast(*void)(*instance.boneCount)) - cast(*void)(*instance)) == 104, "Mesh.boneCount has unexpected offset % instead of 104", ((cast(*void)(*instance.boneCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.boneCount)) == 4, "Mesh.boneCount has unexpected size % instead of 4", size_of(type_of(Mesh.boneCount))); - assert(((cast(*void)(*instance.vaoId)) - cast(*void)(*instance)) == 108, "Mesh.vaoId has unexpected offset % instead of 108", ((cast(*void)(*instance.vaoId)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.vaoId)) == 4, "Mesh.vaoId has unexpected size % instead of 4", size_of(type_of(Mesh.vaoId))); - assert(((cast(*void)(*instance.vboId)) - cast(*void)(*instance)) == 112, "Mesh.vboId has unexpected offset % instead of 112", ((cast(*void)(*instance.vboId)) - cast(*void)(*instance))); - assert(size_of(type_of(Mesh.vboId)) == 8, "Mesh.vboId has unexpected size % instead of 8", size_of(type_of(Mesh.vboId))); + info := type_info(Mesh); + for info.members { + if it.name == { + case "vertexCount"; + assert(it.offset_in_bytes == 0, "Mesh.vertexCount has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Mesh.vertexCount has unexpected size % instead of 4", it.type.runtime_size); + case "triangleCount"; + assert(it.offset_in_bytes == 4, "Mesh.triangleCount has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Mesh.triangleCount has unexpected size % instead of 4", it.type.runtime_size); + case "vertices"; + assert(it.offset_in_bytes == 8, "Mesh.vertices has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.vertices has unexpected size % instead of 8", it.type.runtime_size); + case "texcoords"; + assert(it.offset_in_bytes == 16, "Mesh.texcoords has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.texcoords has unexpected size % instead of 8", it.type.runtime_size); + case "texcoords2"; + assert(it.offset_in_bytes == 24, "Mesh.texcoords2 has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.texcoords2 has unexpected size % instead of 8", it.type.runtime_size); + case "normals"; + assert(it.offset_in_bytes == 32, "Mesh.normals has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.normals has unexpected size % instead of 8", it.type.runtime_size); + case "tangents"; + assert(it.offset_in_bytes == 40, "Mesh.tangents has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.tangents has unexpected size % instead of 8", it.type.runtime_size); + case "colors"; + assert(it.offset_in_bytes == 48, "Mesh.colors has unexpected offset % instead of 48", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.colors has unexpected size % instead of 8", it.type.runtime_size); + case "indices"; + assert(it.offset_in_bytes == 56, "Mesh.indices has unexpected offset % instead of 56", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.indices has unexpected size % instead of 8", it.type.runtime_size); + case "animVertices"; + assert(it.offset_in_bytes == 64, "Mesh.animVertices has unexpected offset % instead of 64", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.animVertices has unexpected size % instead of 8", it.type.runtime_size); + case "animNormals"; + assert(it.offset_in_bytes == 72, "Mesh.animNormals has unexpected offset % instead of 72", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.animNormals has unexpected size % instead of 8", it.type.runtime_size); + case "boneIds"; + assert(it.offset_in_bytes == 80, "Mesh.boneIds has unexpected offset % instead of 80", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.boneIds has unexpected size % instead of 8", it.type.runtime_size); + case "boneWeights"; + assert(it.offset_in_bytes == 88, "Mesh.boneWeights has unexpected offset % instead of 88", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.boneWeights has unexpected size % instead of 8", it.type.runtime_size); + case "boneMatrices"; + assert(it.offset_in_bytes == 96, "Mesh.boneMatrices has unexpected offset % instead of 96", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.boneMatrices has unexpected size % instead of 8", it.type.runtime_size); + case "boneCount"; + assert(it.offset_in_bytes == 104, "Mesh.boneCount has unexpected offset % instead of 104", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Mesh.boneCount has unexpected size % instead of 4", it.type.runtime_size); + case "vaoId"; + assert(it.offset_in_bytes == 108, "Mesh.vaoId has unexpected offset % instead of 108", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Mesh.vaoId has unexpected size % instead of 4", it.type.runtime_size); + case "vboId"; + assert(it.offset_in_bytes == 112, "Mesh.vboId has unexpected offset % instead of 112", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Mesh.vboId has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Mesh) == 120, "Mesh has size % instead of 120", size_of(Mesh)); } { - instance: Shader; - assert(((cast(*void)(*instance.id)) - cast(*void)(*instance)) == 0, "Shader.id has unexpected offset % instead of 0", ((cast(*void)(*instance.id)) - cast(*void)(*instance))); - assert(size_of(type_of(Shader.id)) == 4, "Shader.id has unexpected size % instead of 4", size_of(type_of(Shader.id))); - assert(((cast(*void)(*instance.locs)) - cast(*void)(*instance)) == 8, "Shader.locs has unexpected offset % instead of 8", ((cast(*void)(*instance.locs)) - cast(*void)(*instance))); - assert(size_of(type_of(Shader.locs)) == 8, "Shader.locs has unexpected size % instead of 8", size_of(type_of(Shader.locs))); + info := type_info(Shader); + for info.members { + if it.name == { + case "id"; + assert(it.offset_in_bytes == 0, "Shader.id has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Shader.id has unexpected size % instead of 4", it.type.runtime_size); + case "locs"; + assert(it.offset_in_bytes == 8, "Shader.locs has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Shader.locs has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Shader) == 16, "Shader has size % instead of 16", size_of(Shader)); } { - instance: MaterialMap; - assert(((cast(*void)(*instance.texture)) - cast(*void)(*instance)) == 0, "MaterialMap.texture has unexpected offset % instead of 0", ((cast(*void)(*instance.texture)) - cast(*void)(*instance))); - assert(size_of(type_of(MaterialMap.texture)) == 20, "MaterialMap.texture has unexpected size % instead of 20", size_of(type_of(MaterialMap.texture))); - assert(((cast(*void)(*instance.color)) - cast(*void)(*instance)) == 20, "MaterialMap.color has unexpected offset % instead of 20", ((cast(*void)(*instance.color)) - cast(*void)(*instance))); - assert(size_of(type_of(MaterialMap.color)) == 4, "MaterialMap.color has unexpected size % instead of 4", size_of(type_of(MaterialMap.color))); - assert(((cast(*void)(*instance.value)) - cast(*void)(*instance)) == 24, "MaterialMap.value has unexpected offset % instead of 24", ((cast(*void)(*instance.value)) - cast(*void)(*instance))); - assert(size_of(type_of(MaterialMap.value)) == 4, "MaterialMap.value has unexpected size % instead of 4", size_of(type_of(MaterialMap.value))); + info := type_info(MaterialMap); + for info.members { + if it.name == { + case "texture"; + assert(it.offset_in_bytes == 0, "MaterialMap.texture has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 20, "MaterialMap.texture has unexpected size % instead of 20", it.type.runtime_size); + case "color"; + assert(it.offset_in_bytes == 20, "MaterialMap.color has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "MaterialMap.color has unexpected size % instead of 4", it.type.runtime_size); + case "value"; + assert(it.offset_in_bytes == 24, "MaterialMap.value has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "MaterialMap.value has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(MaterialMap) == 28, "MaterialMap has size % instead of 28", size_of(MaterialMap)); } { - instance: Material; - assert(((cast(*void)(*instance.shader)) - cast(*void)(*instance)) == 0, "Material.shader has unexpected offset % instead of 0", ((cast(*void)(*instance.shader)) - cast(*void)(*instance))); - assert(size_of(type_of(Material.shader)) == 16, "Material.shader has unexpected size % instead of 16", size_of(type_of(Material.shader))); - assert(((cast(*void)(*instance.maps)) - cast(*void)(*instance)) == 16, "Material.maps has unexpected offset % instead of 16", ((cast(*void)(*instance.maps)) - cast(*void)(*instance))); - assert(size_of(type_of(Material.maps)) == 8, "Material.maps has unexpected size % instead of 8", size_of(type_of(Material.maps))); - assert(((cast(*void)(*instance.params)) - cast(*void)(*instance)) == 24, "Material.params has unexpected offset % instead of 24", ((cast(*void)(*instance.params)) - cast(*void)(*instance))); - assert(size_of(type_of(Material.params)) == 16, "Material.params has unexpected size % instead of 16", size_of(type_of(Material.params))); + info := type_info(Material); + for info.members { + if it.name == { + case "shader"; + assert(it.offset_in_bytes == 0, "Material.shader has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "Material.shader has unexpected size % instead of 16", it.type.runtime_size); + case "maps"; + assert(it.offset_in_bytes == 16, "Material.maps has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Material.maps has unexpected size % instead of 8", it.type.runtime_size); + case "params"; + assert(it.offset_in_bytes == 24, "Material.params has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "Material.params has unexpected size % instead of 16", it.type.runtime_size); + } + } assert(size_of(Material) == 40, "Material has size % instead of 40", size_of(Material)); } { - instance: Transform; - assert(((cast(*void)(*instance.translation)) - cast(*void)(*instance)) == 0, "Transform.translation has unexpected offset % instead of 0", ((cast(*void)(*instance.translation)) - cast(*void)(*instance))); - assert(size_of(type_of(Transform.translation)) == 12, "Transform.translation has unexpected size % instead of 12", size_of(type_of(Transform.translation))); - assert(((cast(*void)(*instance.rotation)) - cast(*void)(*instance)) == 12, "Transform.rotation has unexpected offset % instead of 12", ((cast(*void)(*instance.rotation)) - cast(*void)(*instance))); - assert(size_of(type_of(Transform.rotation)) == 16, "Transform.rotation has unexpected size % instead of 16", size_of(type_of(Transform.rotation))); - assert(((cast(*void)(*instance.scale)) - cast(*void)(*instance)) == 28, "Transform.scale has unexpected offset % instead of 28", ((cast(*void)(*instance.scale)) - cast(*void)(*instance))); - assert(size_of(type_of(Transform.scale)) == 12, "Transform.scale has unexpected size % instead of 12", size_of(type_of(Transform.scale))); + info := type_info(Transform); + for info.members { + if it.name == { + case "translation"; + assert(it.offset_in_bytes == 0, "Transform.translation has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Transform.translation has unexpected size % instead of 12", it.type.runtime_size); + case "rotation"; + assert(it.offset_in_bytes == 12, "Transform.rotation has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "Transform.rotation has unexpected size % instead of 16", it.type.runtime_size); + case "scale"; + assert(it.offset_in_bytes == 28, "Transform.scale has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Transform.scale has unexpected size % instead of 12", it.type.runtime_size); + } + } assert(size_of(Transform) == 40, "Transform has size % instead of 40", size_of(Transform)); } { - instance: BoneInfo; - assert(((cast(*void)(*instance.name)) - cast(*void)(*instance)) == 0, "BoneInfo.name has unexpected offset % instead of 0", ((cast(*void)(*instance.name)) - cast(*void)(*instance))); - assert(size_of(type_of(BoneInfo.name)) == 32, "BoneInfo.name has unexpected size % instead of 32", size_of(type_of(BoneInfo.name))); - assert(((cast(*void)(*instance.parent)) - cast(*void)(*instance)) == 32, "BoneInfo.parent has unexpected offset % instead of 32", ((cast(*void)(*instance.parent)) - cast(*void)(*instance))); - assert(size_of(type_of(BoneInfo.parent)) == 4, "BoneInfo.parent has unexpected size % instead of 4", size_of(type_of(BoneInfo.parent))); + info := type_info(BoneInfo); + for info.members { + if it.name == { + case "name"; + assert(it.offset_in_bytes == 0, "BoneInfo.name has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 32, "BoneInfo.name has unexpected size % instead of 32", it.type.runtime_size); + case "parent"; + assert(it.offset_in_bytes == 32, "BoneInfo.parent has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "BoneInfo.parent has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(BoneInfo) == 36, "BoneInfo has size % instead of 36", size_of(BoneInfo)); } { - instance: Model; - assert(((cast(*void)(*instance.transform)) - cast(*void)(*instance)) == 0, "Model.transform has unexpected offset % instead of 0", ((cast(*void)(*instance.transform)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.transform)) == 64, "Model.transform has unexpected size % instead of 64", size_of(type_of(Model.transform))); - assert(((cast(*void)(*instance.meshCount)) - cast(*void)(*instance)) == 64, "Model.meshCount has unexpected offset % instead of 64", ((cast(*void)(*instance.meshCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.meshCount)) == 4, "Model.meshCount has unexpected size % instead of 4", size_of(type_of(Model.meshCount))); - assert(((cast(*void)(*instance.materialCount)) - cast(*void)(*instance)) == 68, "Model.materialCount has unexpected offset % instead of 68", ((cast(*void)(*instance.materialCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.materialCount)) == 4, "Model.materialCount has unexpected size % instead of 4", size_of(type_of(Model.materialCount))); - assert(((cast(*void)(*instance.meshes)) - cast(*void)(*instance)) == 72, "Model.meshes has unexpected offset % instead of 72", ((cast(*void)(*instance.meshes)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.meshes)) == 8, "Model.meshes has unexpected size % instead of 8", size_of(type_of(Model.meshes))); - assert(((cast(*void)(*instance.materials)) - cast(*void)(*instance)) == 80, "Model.materials has unexpected offset % instead of 80", ((cast(*void)(*instance.materials)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.materials)) == 8, "Model.materials has unexpected size % instead of 8", size_of(type_of(Model.materials))); - assert(((cast(*void)(*instance.meshMaterial)) - cast(*void)(*instance)) == 88, "Model.meshMaterial has unexpected offset % instead of 88", ((cast(*void)(*instance.meshMaterial)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.meshMaterial)) == 8, "Model.meshMaterial has unexpected size % instead of 8", size_of(type_of(Model.meshMaterial))); - assert(((cast(*void)(*instance.boneCount)) - cast(*void)(*instance)) == 96, "Model.boneCount has unexpected offset % instead of 96", ((cast(*void)(*instance.boneCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.boneCount)) == 4, "Model.boneCount has unexpected size % instead of 4", size_of(type_of(Model.boneCount))); - assert(((cast(*void)(*instance.bones)) - cast(*void)(*instance)) == 104, "Model.bones has unexpected offset % instead of 104", ((cast(*void)(*instance.bones)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.bones)) == 8, "Model.bones has unexpected size % instead of 8", size_of(type_of(Model.bones))); - assert(((cast(*void)(*instance.bindPose)) - cast(*void)(*instance)) == 112, "Model.bindPose has unexpected offset % instead of 112", ((cast(*void)(*instance.bindPose)) - cast(*void)(*instance))); - assert(size_of(type_of(Model.bindPose)) == 8, "Model.bindPose has unexpected size % instead of 8", size_of(type_of(Model.bindPose))); + info := type_info(Model); + for info.members { + if it.name == { + case "transform"; + assert(it.offset_in_bytes == 0, "Model.transform has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 64, "Model.transform has unexpected size % instead of 64", it.type.runtime_size); + case "meshCount"; + assert(it.offset_in_bytes == 64, "Model.meshCount has unexpected offset % instead of 64", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Model.meshCount has unexpected size % instead of 4", it.type.runtime_size); + case "materialCount"; + assert(it.offset_in_bytes == 68, "Model.materialCount has unexpected offset % instead of 68", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Model.materialCount has unexpected size % instead of 4", it.type.runtime_size); + case "meshes"; + assert(it.offset_in_bytes == 72, "Model.meshes has unexpected offset % instead of 72", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Model.meshes has unexpected size % instead of 8", it.type.runtime_size); + case "materials"; + assert(it.offset_in_bytes == 80, "Model.materials has unexpected offset % instead of 80", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Model.materials has unexpected size % instead of 8", it.type.runtime_size); + case "meshMaterial"; + assert(it.offset_in_bytes == 88, "Model.meshMaterial has unexpected offset % instead of 88", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Model.meshMaterial has unexpected size % instead of 8", it.type.runtime_size); + case "boneCount"; + assert(it.offset_in_bytes == 96, "Model.boneCount has unexpected offset % instead of 96", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Model.boneCount has unexpected size % instead of 4", it.type.runtime_size); + case "bones"; + assert(it.offset_in_bytes == 104, "Model.bones has unexpected offset % instead of 104", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Model.bones has unexpected size % instead of 8", it.type.runtime_size); + case "bindPose"; + assert(it.offset_in_bytes == 112, "Model.bindPose has unexpected offset % instead of 112", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Model.bindPose has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Model) == 120, "Model has size % instead of 120", size_of(Model)); } { - instance: ModelAnimation; - assert(((cast(*void)(*instance.boneCount)) - cast(*void)(*instance)) == 0, "ModelAnimation.boneCount has unexpected offset % instead of 0", ((cast(*void)(*instance.boneCount)) - cast(*void)(*instance))); - assert(size_of(type_of(ModelAnimation.boneCount)) == 4, "ModelAnimation.boneCount has unexpected size % instead of 4", size_of(type_of(ModelAnimation.boneCount))); - assert(((cast(*void)(*instance.frameCount)) - cast(*void)(*instance)) == 4, "ModelAnimation.frameCount has unexpected offset % instead of 4", ((cast(*void)(*instance.frameCount)) - cast(*void)(*instance))); - assert(size_of(type_of(ModelAnimation.frameCount)) == 4, "ModelAnimation.frameCount has unexpected size % instead of 4", size_of(type_of(ModelAnimation.frameCount))); - assert(((cast(*void)(*instance.bones)) - cast(*void)(*instance)) == 8, "ModelAnimation.bones has unexpected offset % instead of 8", ((cast(*void)(*instance.bones)) - cast(*void)(*instance))); - assert(size_of(type_of(ModelAnimation.bones)) == 8, "ModelAnimation.bones has unexpected size % instead of 8", size_of(type_of(ModelAnimation.bones))); - assert(((cast(*void)(*instance.framePoses)) - cast(*void)(*instance)) == 16, "ModelAnimation.framePoses has unexpected offset % instead of 16", ((cast(*void)(*instance.framePoses)) - cast(*void)(*instance))); - assert(size_of(type_of(ModelAnimation.framePoses)) == 8, "ModelAnimation.framePoses has unexpected size % instead of 8", size_of(type_of(ModelAnimation.framePoses))); - assert(((cast(*void)(*instance.name)) - cast(*void)(*instance)) == 24, "ModelAnimation.name has unexpected offset % instead of 24", ((cast(*void)(*instance.name)) - cast(*void)(*instance))); - assert(size_of(type_of(ModelAnimation.name)) == 32, "ModelAnimation.name has unexpected size % instead of 32", size_of(type_of(ModelAnimation.name))); + info := type_info(ModelAnimation); + for info.members { + if it.name == { + case "boneCount"; + assert(it.offset_in_bytes == 0, "ModelAnimation.boneCount has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "ModelAnimation.boneCount has unexpected size % instead of 4", it.type.runtime_size); + case "frameCount"; + assert(it.offset_in_bytes == 4, "ModelAnimation.frameCount has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "ModelAnimation.frameCount has unexpected size % instead of 4", it.type.runtime_size); + case "bones"; + assert(it.offset_in_bytes == 8, "ModelAnimation.bones has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "ModelAnimation.bones has unexpected size % instead of 8", it.type.runtime_size); + case "framePoses"; + assert(it.offset_in_bytes == 16, "ModelAnimation.framePoses has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "ModelAnimation.framePoses has unexpected size % instead of 8", it.type.runtime_size); + case "name"; + assert(it.offset_in_bytes == 24, "ModelAnimation.name has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 32, "ModelAnimation.name has unexpected size % instead of 32", it.type.runtime_size); + } + } assert(size_of(ModelAnimation) == 56, "ModelAnimation has size % instead of 56", size_of(ModelAnimation)); } { - instance: Ray; - assert(((cast(*void)(*instance.position)) - cast(*void)(*instance)) == 0, "Ray.position has unexpected offset % instead of 0", ((cast(*void)(*instance.position)) - cast(*void)(*instance))); - assert(size_of(type_of(Ray.position)) == 12, "Ray.position has unexpected size % instead of 12", size_of(type_of(Ray.position))); - assert(((cast(*void)(*instance.direction)) - cast(*void)(*instance)) == 12, "Ray.direction has unexpected offset % instead of 12", ((cast(*void)(*instance.direction)) - cast(*void)(*instance))); - assert(size_of(type_of(Ray.direction)) == 12, "Ray.direction has unexpected size % instead of 12", size_of(type_of(Ray.direction))); + info := type_info(Ray); + for info.members { + if it.name == { + case "position"; + assert(it.offset_in_bytes == 0, "Ray.position has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Ray.position has unexpected size % instead of 12", it.type.runtime_size); + case "direction"; + assert(it.offset_in_bytes == 12, "Ray.direction has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "Ray.direction has unexpected size % instead of 12", it.type.runtime_size); + } + } assert(size_of(Ray) == 24, "Ray has size % instead of 24", size_of(Ray)); } { - instance: RayCollision; - assert(((cast(*void)(*instance.hit)) - cast(*void)(*instance)) == 0, "RayCollision.hit has unexpected offset % instead of 0", ((cast(*void)(*instance.hit)) - cast(*void)(*instance))); - assert(size_of(type_of(RayCollision.hit)) == 1, "RayCollision.hit has unexpected size % instead of 1", size_of(type_of(RayCollision.hit))); - assert(((cast(*void)(*instance.distance)) - cast(*void)(*instance)) == 4, "RayCollision.distance has unexpected offset % instead of 4", ((cast(*void)(*instance.distance)) - cast(*void)(*instance))); - assert(size_of(type_of(RayCollision.distance)) == 4, "RayCollision.distance has unexpected size % instead of 4", size_of(type_of(RayCollision.distance))); - assert(((cast(*void)(*instance.point)) - cast(*void)(*instance)) == 8, "RayCollision.point has unexpected offset % instead of 8", ((cast(*void)(*instance.point)) - cast(*void)(*instance))); - assert(size_of(type_of(RayCollision.point)) == 12, "RayCollision.point has unexpected size % instead of 12", size_of(type_of(RayCollision.point))); - assert(((cast(*void)(*instance.normal)) - cast(*void)(*instance)) == 20, "RayCollision.normal has unexpected offset % instead of 20", ((cast(*void)(*instance.normal)) - cast(*void)(*instance))); - assert(size_of(type_of(RayCollision.normal)) == 12, "RayCollision.normal has unexpected size % instead of 12", size_of(type_of(RayCollision.normal))); + info := type_info(RayCollision); + for info.members { + if it.name == { + case "hit"; + assert(it.offset_in_bytes == 0, "RayCollision.hit has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "RayCollision.hit has unexpected size % instead of 1", it.type.runtime_size); + case "distance"; + assert(it.offset_in_bytes == 4, "RayCollision.distance has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RayCollision.distance has unexpected size % instead of 4", it.type.runtime_size); + case "point"; + assert(it.offset_in_bytes == 8, "RayCollision.point has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "RayCollision.point has unexpected size % instead of 12", it.type.runtime_size); + case "normal"; + assert(it.offset_in_bytes == 20, "RayCollision.normal has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "RayCollision.normal has unexpected size % instead of 12", it.type.runtime_size); + } + } assert(size_of(RayCollision) == 32, "RayCollision has size % instead of 32", size_of(RayCollision)); } { - instance: BoundingBox; - assert(((cast(*void)(*instance.min)) - cast(*void)(*instance)) == 0, "BoundingBox.min has unexpected offset % instead of 0", ((cast(*void)(*instance.min)) - cast(*void)(*instance))); - assert(size_of(type_of(BoundingBox.min)) == 12, "BoundingBox.min has unexpected size % instead of 12", size_of(type_of(BoundingBox.min))); - assert(((cast(*void)(*instance.max)) - cast(*void)(*instance)) == 12, "BoundingBox.max has unexpected offset % instead of 12", ((cast(*void)(*instance.max)) - cast(*void)(*instance))); - assert(size_of(type_of(BoundingBox.max)) == 12, "BoundingBox.max has unexpected size % instead of 12", size_of(type_of(BoundingBox.max))); + info := type_info(BoundingBox); + for info.members { + if it.name == { + case "min"; + assert(it.offset_in_bytes == 0, "BoundingBox.min has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "BoundingBox.min has unexpected size % instead of 12", it.type.runtime_size); + case "max"; + assert(it.offset_in_bytes == 12, "BoundingBox.max has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "BoundingBox.max has unexpected size % instead of 12", it.type.runtime_size); + } + } assert(size_of(BoundingBox) == 24, "BoundingBox has size % instead of 24", size_of(BoundingBox)); } { - instance: Wave; - assert(((cast(*void)(*instance.frameCount)) - cast(*void)(*instance)) == 0, "Wave.frameCount has unexpected offset % instead of 0", ((cast(*void)(*instance.frameCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Wave.frameCount)) == 4, "Wave.frameCount has unexpected size % instead of 4", size_of(type_of(Wave.frameCount))); - assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 4, "Wave.sampleRate has unexpected offset % instead of 4", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); - assert(size_of(type_of(Wave.sampleRate)) == 4, "Wave.sampleRate has unexpected size % instead of 4", size_of(type_of(Wave.sampleRate))); - assert(((cast(*void)(*instance.sampleSize)) - cast(*void)(*instance)) == 8, "Wave.sampleSize has unexpected offset % instead of 8", ((cast(*void)(*instance.sampleSize)) - cast(*void)(*instance))); - assert(size_of(type_of(Wave.sampleSize)) == 4, "Wave.sampleSize has unexpected size % instead of 4", size_of(type_of(Wave.sampleSize))); - assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 12, "Wave.channels has unexpected offset % instead of 12", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); - assert(size_of(type_of(Wave.channels)) == 4, "Wave.channels has unexpected size % instead of 4", size_of(type_of(Wave.channels))); - assert(((cast(*void)(*instance.data)) - cast(*void)(*instance)) == 16, "Wave.data has unexpected offset % instead of 16", ((cast(*void)(*instance.data)) - cast(*void)(*instance))); - assert(size_of(type_of(Wave.data)) == 8, "Wave.data has unexpected size % instead of 8", size_of(type_of(Wave.data))); + info := type_info(Wave); + for info.members { + if it.name == { + case "frameCount"; + assert(it.offset_in_bytes == 0, "Wave.frameCount has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Wave.frameCount has unexpected size % instead of 4", it.type.runtime_size); + case "sampleRate"; + assert(it.offset_in_bytes == 4, "Wave.sampleRate has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Wave.sampleRate has unexpected size % instead of 4", it.type.runtime_size); + case "sampleSize"; + assert(it.offset_in_bytes == 8, "Wave.sampleSize has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Wave.sampleSize has unexpected size % instead of 4", it.type.runtime_size); + case "channels"; + assert(it.offset_in_bytes == 12, "Wave.channels has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Wave.channels has unexpected size % instead of 4", it.type.runtime_size); + case "data"; + assert(it.offset_in_bytes == 16, "Wave.data has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Wave.data has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Wave) == 24, "Wave has size % instead of 24", size_of(Wave)); } { - instance: AudioStream; - assert(((cast(*void)(*instance.buffer)) - cast(*void)(*instance)) == 0, "AudioStream.buffer has unexpected offset % instead of 0", ((cast(*void)(*instance.buffer)) - cast(*void)(*instance))); - assert(size_of(type_of(AudioStream.buffer)) == 8, "AudioStream.buffer has unexpected size % instead of 8", size_of(type_of(AudioStream.buffer))); - assert(((cast(*void)(*instance.processor)) - cast(*void)(*instance)) == 8, "AudioStream.processor has unexpected offset % instead of 8", ((cast(*void)(*instance.processor)) - cast(*void)(*instance))); - assert(size_of(type_of(AudioStream.processor)) == 8, "AudioStream.processor has unexpected size % instead of 8", size_of(type_of(AudioStream.processor))); - assert(((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance)) == 16, "AudioStream.sampleRate has unexpected offset % instead of 16", ((cast(*void)(*instance.sampleRate)) - cast(*void)(*instance))); - assert(size_of(type_of(AudioStream.sampleRate)) == 4, "AudioStream.sampleRate has unexpected size % instead of 4", size_of(type_of(AudioStream.sampleRate))); - assert(((cast(*void)(*instance.sampleSize)) - cast(*void)(*instance)) == 20, "AudioStream.sampleSize has unexpected offset % instead of 20", ((cast(*void)(*instance.sampleSize)) - cast(*void)(*instance))); - assert(size_of(type_of(AudioStream.sampleSize)) == 4, "AudioStream.sampleSize has unexpected size % instead of 4", size_of(type_of(AudioStream.sampleSize))); - assert(((cast(*void)(*instance.channels)) - cast(*void)(*instance)) == 24, "AudioStream.channels has unexpected offset % instead of 24", ((cast(*void)(*instance.channels)) - cast(*void)(*instance))); - assert(size_of(type_of(AudioStream.channels)) == 4, "AudioStream.channels has unexpected size % instead of 4", size_of(type_of(AudioStream.channels))); + info := type_info(AudioStream); + for info.members { + if it.name == { + case "buffer"; + assert(it.offset_in_bytes == 0, "AudioStream.buffer has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "AudioStream.buffer has unexpected size % instead of 8", it.type.runtime_size); + case "processor"; + assert(it.offset_in_bytes == 8, "AudioStream.processor has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "AudioStream.processor has unexpected size % instead of 8", it.type.runtime_size); + case "sampleRate"; + assert(it.offset_in_bytes == 16, "AudioStream.sampleRate has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AudioStream.sampleRate has unexpected size % instead of 4", it.type.runtime_size); + case "sampleSize"; + assert(it.offset_in_bytes == 20, "AudioStream.sampleSize has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AudioStream.sampleSize has unexpected size % instead of 4", it.type.runtime_size); + case "channels"; + assert(it.offset_in_bytes == 24, "AudioStream.channels has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AudioStream.channels has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(AudioStream) == 32, "AudioStream has size % instead of 32", size_of(AudioStream)); } { - instance: Sound; - assert(((cast(*void)(*instance.stream)) - cast(*void)(*instance)) == 0, "Sound.stream has unexpected offset % instead of 0", ((cast(*void)(*instance.stream)) - cast(*void)(*instance))); - assert(size_of(type_of(Sound.stream)) == 32, "Sound.stream has unexpected size % instead of 32", size_of(type_of(Sound.stream))); - assert(((cast(*void)(*instance.frameCount)) - cast(*void)(*instance)) == 32, "Sound.frameCount has unexpected offset % instead of 32", ((cast(*void)(*instance.frameCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Sound.frameCount)) == 4, "Sound.frameCount has unexpected size % instead of 4", size_of(type_of(Sound.frameCount))); + info := type_info(Sound); + for info.members { + if it.name == { + case "stream"; + assert(it.offset_in_bytes == 0, "Sound.stream has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 32, "Sound.stream has unexpected size % instead of 32", it.type.runtime_size); + case "frameCount"; + assert(it.offset_in_bytes == 32, "Sound.frameCount has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Sound.frameCount has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Sound) == 40, "Sound has size % instead of 40", size_of(Sound)); } { - instance: Music; - assert(((cast(*void)(*instance.stream)) - cast(*void)(*instance)) == 0, "Music.stream has unexpected offset % instead of 0", ((cast(*void)(*instance.stream)) - cast(*void)(*instance))); - assert(size_of(type_of(Music.stream)) == 32, "Music.stream has unexpected size % instead of 32", size_of(type_of(Music.stream))); - assert(((cast(*void)(*instance.frameCount)) - cast(*void)(*instance)) == 32, "Music.frameCount has unexpected offset % instead of 32", ((cast(*void)(*instance.frameCount)) - cast(*void)(*instance))); - assert(size_of(type_of(Music.frameCount)) == 4, "Music.frameCount has unexpected size % instead of 4", size_of(type_of(Music.frameCount))); - assert(((cast(*void)(*instance.looping)) - cast(*void)(*instance)) == 36, "Music.looping has unexpected offset % instead of 36", ((cast(*void)(*instance.looping)) - cast(*void)(*instance))); - assert(size_of(type_of(Music.looping)) == 1, "Music.looping has unexpected size % instead of 1", size_of(type_of(Music.looping))); - assert(((cast(*void)(*instance.ctxType)) - cast(*void)(*instance)) == 40, "Music.ctxType has unexpected offset % instead of 40", ((cast(*void)(*instance.ctxType)) - cast(*void)(*instance))); - assert(size_of(type_of(Music.ctxType)) == 4, "Music.ctxType has unexpected size % instead of 4", size_of(type_of(Music.ctxType))); - assert(((cast(*void)(*instance.ctxData)) - cast(*void)(*instance)) == 48, "Music.ctxData has unexpected offset % instead of 48", ((cast(*void)(*instance.ctxData)) - cast(*void)(*instance))); - assert(size_of(type_of(Music.ctxData)) == 8, "Music.ctxData has unexpected size % instead of 8", size_of(type_of(Music.ctxData))); + info := type_info(Music); + for info.members { + if it.name == { + case "stream"; + assert(it.offset_in_bytes == 0, "Music.stream has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 32, "Music.stream has unexpected size % instead of 32", it.type.runtime_size); + case "frameCount"; + assert(it.offset_in_bytes == 32, "Music.frameCount has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Music.frameCount has unexpected size % instead of 4", it.type.runtime_size); + case "looping"; + assert(it.offset_in_bytes == 36, "Music.looping has unexpected offset % instead of 36", it.offset_in_bytes); + assert(it.type.runtime_size == 1, "Music.looping has unexpected size % instead of 1", it.type.runtime_size); + case "ctxType"; + assert(it.offset_in_bytes == 40, "Music.ctxType has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Music.ctxType has unexpected size % instead of 4", it.type.runtime_size); + case "ctxData"; + assert(it.offset_in_bytes == 48, "Music.ctxData has unexpected offset % instead of 48", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "Music.ctxData has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(Music) == 56, "Music has size % instead of 56", size_of(Music)); } { - instance: VrDeviceInfo; - assert(((cast(*void)(*instance.hResolution)) - cast(*void)(*instance)) == 0, "VrDeviceInfo.hResolution has unexpected offset % instead of 0", ((cast(*void)(*instance.hResolution)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.hResolution)) == 4, "VrDeviceInfo.hResolution has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.hResolution))); - assert(((cast(*void)(*instance.vResolution)) - cast(*void)(*instance)) == 4, "VrDeviceInfo.vResolution has unexpected offset % instead of 4", ((cast(*void)(*instance.vResolution)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.vResolution)) == 4, "VrDeviceInfo.vResolution has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.vResolution))); - assert(((cast(*void)(*instance.hScreenSize)) - cast(*void)(*instance)) == 8, "VrDeviceInfo.hScreenSize has unexpected offset % instead of 8", ((cast(*void)(*instance.hScreenSize)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.hScreenSize)) == 4, "VrDeviceInfo.hScreenSize has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.hScreenSize))); - assert(((cast(*void)(*instance.vScreenSize)) - cast(*void)(*instance)) == 12, "VrDeviceInfo.vScreenSize has unexpected offset % instead of 12", ((cast(*void)(*instance.vScreenSize)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.vScreenSize)) == 4, "VrDeviceInfo.vScreenSize has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.vScreenSize))); - assert(((cast(*void)(*instance.eyeToScreenDistance)) - cast(*void)(*instance)) == 16, "VrDeviceInfo.eyeToScreenDistance has unexpected offset % instead of 16", ((cast(*void)(*instance.eyeToScreenDistance)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.eyeToScreenDistance)) == 4, "VrDeviceInfo.eyeToScreenDistance has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.eyeToScreenDistance))); - assert(((cast(*void)(*instance.lensSeparationDistance)) - cast(*void)(*instance)) == 20, "VrDeviceInfo.lensSeparationDistance has unexpected offset % instead of 20", ((cast(*void)(*instance.lensSeparationDistance)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.lensSeparationDistance)) == 4, "VrDeviceInfo.lensSeparationDistance has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.lensSeparationDistance))); - assert(((cast(*void)(*instance.interpupillaryDistance)) - cast(*void)(*instance)) == 24, "VrDeviceInfo.interpupillaryDistance has unexpected offset % instead of 24", ((cast(*void)(*instance.interpupillaryDistance)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.interpupillaryDistance)) == 4, "VrDeviceInfo.interpupillaryDistance has unexpected size % instead of 4", size_of(type_of(VrDeviceInfo.interpupillaryDistance))); - assert(((cast(*void)(*instance.lensDistortionValues)) - cast(*void)(*instance)) == 28, "VrDeviceInfo.lensDistortionValues has unexpected offset % instead of 28", ((cast(*void)(*instance.lensDistortionValues)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.lensDistortionValues)) == 16, "VrDeviceInfo.lensDistortionValues has unexpected size % instead of 16", size_of(type_of(VrDeviceInfo.lensDistortionValues))); - assert(((cast(*void)(*instance.chromaAbCorrection)) - cast(*void)(*instance)) == 44, "VrDeviceInfo.chromaAbCorrection has unexpected offset % instead of 44", ((cast(*void)(*instance.chromaAbCorrection)) - cast(*void)(*instance))); - assert(size_of(type_of(VrDeviceInfo.chromaAbCorrection)) == 16, "VrDeviceInfo.chromaAbCorrection has unexpected size % instead of 16", size_of(type_of(VrDeviceInfo.chromaAbCorrection))); + info := type_info(VrDeviceInfo); + for info.members { + if it.name == { + case "hResolution"; + assert(it.offset_in_bytes == 0, "VrDeviceInfo.hResolution has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.hResolution has unexpected size % instead of 4", it.type.runtime_size); + case "vResolution"; + assert(it.offset_in_bytes == 4, "VrDeviceInfo.vResolution has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.vResolution has unexpected size % instead of 4", it.type.runtime_size); + case "hScreenSize"; + assert(it.offset_in_bytes == 8, "VrDeviceInfo.hScreenSize has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.hScreenSize has unexpected size % instead of 4", it.type.runtime_size); + case "vScreenSize"; + assert(it.offset_in_bytes == 12, "VrDeviceInfo.vScreenSize has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.vScreenSize has unexpected size % instead of 4", it.type.runtime_size); + case "eyeToScreenDistance"; + assert(it.offset_in_bytes == 16, "VrDeviceInfo.eyeToScreenDistance has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.eyeToScreenDistance has unexpected size % instead of 4", it.type.runtime_size); + case "lensSeparationDistance"; + assert(it.offset_in_bytes == 20, "VrDeviceInfo.lensSeparationDistance has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.lensSeparationDistance has unexpected size % instead of 4", it.type.runtime_size); + case "interpupillaryDistance"; + assert(it.offset_in_bytes == 24, "VrDeviceInfo.interpupillaryDistance has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VrDeviceInfo.interpupillaryDistance has unexpected size % instead of 4", it.type.runtime_size); + case "lensDistortionValues"; + assert(it.offset_in_bytes == 28, "VrDeviceInfo.lensDistortionValues has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "VrDeviceInfo.lensDistortionValues has unexpected size % instead of 16", it.type.runtime_size); + case "chromaAbCorrection"; + assert(it.offset_in_bytes == 44, "VrDeviceInfo.chromaAbCorrection has unexpected offset % instead of 44", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "VrDeviceInfo.chromaAbCorrection has unexpected size % instead of 16", it.type.runtime_size); + } + } assert(size_of(VrDeviceInfo) == 60, "VrDeviceInfo has size % instead of 60", size_of(VrDeviceInfo)); } { - instance: VrStereoConfig; - assert(((cast(*void)(*instance.projection)) - cast(*void)(*instance)) == 0, "VrStereoConfig.projection has unexpected offset % instead of 0", ((cast(*void)(*instance.projection)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.projection)) == 128, "VrStereoConfig.projection has unexpected size % instead of 128", size_of(type_of(VrStereoConfig.projection))); - assert(((cast(*void)(*instance.viewOffset)) - cast(*void)(*instance)) == 128, "VrStereoConfig.viewOffset has unexpected offset % instead of 128", ((cast(*void)(*instance.viewOffset)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.viewOffset)) == 128, "VrStereoConfig.viewOffset has unexpected size % instead of 128", size_of(type_of(VrStereoConfig.viewOffset))); - assert(((cast(*void)(*instance.leftLensCenter)) - cast(*void)(*instance)) == 256, "VrStereoConfig.leftLensCenter has unexpected offset % instead of 256", ((cast(*void)(*instance.leftLensCenter)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.leftLensCenter)) == 8, "VrStereoConfig.leftLensCenter has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.leftLensCenter))); - assert(((cast(*void)(*instance.rightLensCenter)) - cast(*void)(*instance)) == 264, "VrStereoConfig.rightLensCenter has unexpected offset % instead of 264", ((cast(*void)(*instance.rightLensCenter)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.rightLensCenter)) == 8, "VrStereoConfig.rightLensCenter has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.rightLensCenter))); - assert(((cast(*void)(*instance.leftScreenCenter)) - cast(*void)(*instance)) == 272, "VrStereoConfig.leftScreenCenter has unexpected offset % instead of 272", ((cast(*void)(*instance.leftScreenCenter)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.leftScreenCenter)) == 8, "VrStereoConfig.leftScreenCenter has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.leftScreenCenter))); - assert(((cast(*void)(*instance.rightScreenCenter)) - cast(*void)(*instance)) == 280, "VrStereoConfig.rightScreenCenter has unexpected offset % instead of 280", ((cast(*void)(*instance.rightScreenCenter)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.rightScreenCenter)) == 8, "VrStereoConfig.rightScreenCenter has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.rightScreenCenter))); - assert(((cast(*void)(*instance.scale)) - cast(*void)(*instance)) == 288, "VrStereoConfig.scale has unexpected offset % instead of 288", ((cast(*void)(*instance.scale)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.scale)) == 8, "VrStereoConfig.scale has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.scale))); - assert(((cast(*void)(*instance.scaleIn)) - cast(*void)(*instance)) == 296, "VrStereoConfig.scaleIn has unexpected offset % instead of 296", ((cast(*void)(*instance.scaleIn)) - cast(*void)(*instance))); - assert(size_of(type_of(VrStereoConfig.scaleIn)) == 8, "VrStereoConfig.scaleIn has unexpected size % instead of 8", size_of(type_of(VrStereoConfig.scaleIn))); + info := type_info(VrStereoConfig); + for info.members { + if it.name == { + case "projection"; + assert(it.offset_in_bytes == 0, "VrStereoConfig.projection has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 128, "VrStereoConfig.projection has unexpected size % instead of 128", it.type.runtime_size); + case "viewOffset"; + assert(it.offset_in_bytes == 128, "VrStereoConfig.viewOffset has unexpected offset % instead of 128", it.offset_in_bytes); + assert(it.type.runtime_size == 128, "VrStereoConfig.viewOffset has unexpected size % instead of 128", it.type.runtime_size); + case "leftLensCenter"; + assert(it.offset_in_bytes == 256, "VrStereoConfig.leftLensCenter has unexpected offset % instead of 256", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.leftLensCenter has unexpected size % instead of 8", it.type.runtime_size); + case "rightLensCenter"; + assert(it.offset_in_bytes == 264, "VrStereoConfig.rightLensCenter has unexpected offset % instead of 264", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.rightLensCenter has unexpected size % instead of 8", it.type.runtime_size); + case "leftScreenCenter"; + assert(it.offset_in_bytes == 272, "VrStereoConfig.leftScreenCenter has unexpected offset % instead of 272", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.leftScreenCenter has unexpected size % instead of 8", it.type.runtime_size); + case "rightScreenCenter"; + assert(it.offset_in_bytes == 280, "VrStereoConfig.rightScreenCenter has unexpected offset % instead of 280", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.rightScreenCenter has unexpected size % instead of 8", it.type.runtime_size); + case "scale"; + assert(it.offset_in_bytes == 288, "VrStereoConfig.scale has unexpected offset % instead of 288", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.scale has unexpected size % instead of 8", it.type.runtime_size); + case "scaleIn"; + assert(it.offset_in_bytes == 296, "VrStereoConfig.scaleIn has unexpected offset % instead of 296", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VrStereoConfig.scaleIn has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(VrStereoConfig) == 304, "VrStereoConfig has size % instead of 304", size_of(VrStereoConfig)); } { - instance: FilePathList; - assert(((cast(*void)(*instance.capacity)) - cast(*void)(*instance)) == 0, "FilePathList.capacity has unexpected offset % instead of 0", ((cast(*void)(*instance.capacity)) - cast(*void)(*instance))); - assert(size_of(type_of(FilePathList.capacity)) == 4, "FilePathList.capacity has unexpected size % instead of 4", size_of(type_of(FilePathList.capacity))); - assert(((cast(*void)(*instance.count)) - cast(*void)(*instance)) == 4, "FilePathList.count has unexpected offset % instead of 4", ((cast(*void)(*instance.count)) - cast(*void)(*instance))); - assert(size_of(type_of(FilePathList.count)) == 4, "FilePathList.count has unexpected size % instead of 4", size_of(type_of(FilePathList.count))); - assert(((cast(*void)(*instance.paths)) - cast(*void)(*instance)) == 8, "FilePathList.paths has unexpected offset % instead of 8", ((cast(*void)(*instance.paths)) - cast(*void)(*instance))); - assert(size_of(type_of(FilePathList.paths)) == 8, "FilePathList.paths has unexpected size % instead of 8", size_of(type_of(FilePathList.paths))); + info := type_info(FilePathList); + for info.members { + if it.name == { + case "capacity"; + assert(it.offset_in_bytes == 0, "FilePathList.capacity has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "FilePathList.capacity has unexpected size % instead of 4", it.type.runtime_size); + case "count"; + assert(it.offset_in_bytes == 4, "FilePathList.count has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "FilePathList.count has unexpected size % instead of 4", it.type.runtime_size); + case "paths"; + assert(it.offset_in_bytes == 8, "FilePathList.paths has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "FilePathList.paths has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(FilePathList) == 16, "FilePathList has size % instead of 16", size_of(FilePathList)); } { - instance: AutomationEvent; - assert(((cast(*void)(*instance.frame)) - cast(*void)(*instance)) == 0, "AutomationEvent.frame has unexpected offset % instead of 0", ((cast(*void)(*instance.frame)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEvent.frame)) == 4, "AutomationEvent.frame has unexpected size % instead of 4", size_of(type_of(AutomationEvent.frame))); - assert(((cast(*void)(*instance.type)) - cast(*void)(*instance)) == 4, "AutomationEvent.type has unexpected offset % instead of 4", ((cast(*void)(*instance.type)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEvent.type)) == 4, "AutomationEvent.type has unexpected size % instead of 4", size_of(type_of(AutomationEvent.type))); - assert(((cast(*void)(*instance.params)) - cast(*void)(*instance)) == 8, "AutomationEvent.params has unexpected offset % instead of 8", ((cast(*void)(*instance.params)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEvent.params)) == 16, "AutomationEvent.params has unexpected size % instead of 16", size_of(type_of(AutomationEvent.params))); + info := type_info(AutomationEvent); + for info.members { + if it.name == { + case "frame"; + assert(it.offset_in_bytes == 0, "AutomationEvent.frame has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AutomationEvent.frame has unexpected size % instead of 4", it.type.runtime_size); + case "type"; + assert(it.offset_in_bytes == 4, "AutomationEvent.type has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AutomationEvent.type has unexpected size % instead of 4", it.type.runtime_size); + case "params"; + assert(it.offset_in_bytes == 8, "AutomationEvent.params has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 16, "AutomationEvent.params has unexpected size % instead of 16", it.type.runtime_size); + } + } assert(size_of(AutomationEvent) == 24, "AutomationEvent has size % instead of 24", size_of(AutomationEvent)); } { - instance: AutomationEventList; - assert(((cast(*void)(*instance.capacity)) - cast(*void)(*instance)) == 0, "AutomationEventList.capacity has unexpected offset % instead of 0", ((cast(*void)(*instance.capacity)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEventList.capacity)) == 4, "AutomationEventList.capacity has unexpected size % instead of 4", size_of(type_of(AutomationEventList.capacity))); - assert(((cast(*void)(*instance.count)) - cast(*void)(*instance)) == 4, "AutomationEventList.count has unexpected offset % instead of 4", ((cast(*void)(*instance.count)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEventList.count)) == 4, "AutomationEventList.count has unexpected size % instead of 4", size_of(type_of(AutomationEventList.count))); - assert(((cast(*void)(*instance.events)) - cast(*void)(*instance)) == 8, "AutomationEventList.events has unexpected offset % instead of 8", ((cast(*void)(*instance.events)) - cast(*void)(*instance))); - assert(size_of(type_of(AutomationEventList.events)) == 8, "AutomationEventList.events has unexpected size % instead of 8", size_of(type_of(AutomationEventList.events))); + info := type_info(AutomationEventList); + for info.members { + if it.name == { + case "capacity"; + assert(it.offset_in_bytes == 0, "AutomationEventList.capacity has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AutomationEventList.capacity has unexpected size % instead of 4", it.type.runtime_size); + case "count"; + assert(it.offset_in_bytes == 4, "AutomationEventList.count has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "AutomationEventList.count has unexpected size % instead of 4", it.type.runtime_size); + case "events"; + assert(it.offset_in_bytes == 8, "AutomationEventList.events has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "AutomationEventList.events has unexpected size % instead of 8", it.type.runtime_size); + } + } assert(size_of(AutomationEventList) == 16, "AutomationEventList has size % instead of 16", size_of(AutomationEventList)); } { - instance: float3; - assert(((cast(*void)(*instance.v)) - cast(*void)(*instance)) == 0, "float3.v has unexpected offset % instead of 0", ((cast(*void)(*instance.v)) - cast(*void)(*instance))); - assert(size_of(type_of(float3.v)) == 12, "float3.v has unexpected size % instead of 12", size_of(type_of(float3.v))); + info := type_info(float3); + for info.members { + if it.name == { + case "v"; + assert(it.offset_in_bytes == 0, "float3.v has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 12, "float3.v has unexpected size % instead of 12", it.type.runtime_size); + } + } assert(size_of(float3) == 12, "float3 has size % instead of 12", size_of(float3)); } { - instance: float16; - assert(((cast(*void)(*instance.v)) - cast(*void)(*instance)) == 0, "float16.v has unexpected offset % instead of 0", ((cast(*void)(*instance.v)) - cast(*void)(*instance))); - assert(size_of(type_of(float16.v)) == 64, "float16.v has unexpected size % instead of 64", size_of(type_of(float16.v))); + info := type_info(float16); + for info.members { + if it.name == { + case "v"; + assert(it.offset_in_bytes == 0, "float16.v has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 64, "float16.v has unexpected size % instead of 64", it.type.runtime_size); + } + } assert(size_of(float16) == 64, "float16 has size % instead of 64", size_of(float16)); } } diff --git a/raylib/readme.md b/raylib/readme.md deleted file mode 100644 index 7e120b5..0000000 --- a/raylib/readme.md +++ /dev/null @@ -1,19 +0,0 @@ -# Raylib - -[Raylib](https://www.raylib.com) 5.0 bindings for Jai. - -## Usage - -See: `examples/` - -## Notes - -- These are generated using Jai's `Bindings_Generator` library (`jai generate.jai`) -- `extras.jai` contains auto-generated macros for Begin/End procs -- `interop.jai` contains overloads to make calling into Raylib easier - -To generate bindings for a different version: - -- Place headers in `lib/` and dynamic libraries in `win/`, `mac/`, or `linux/` -- Change `LIBRARY_NAME` in `generate.jai` to match the dynamic library's name (no extension) -- Run `jai generate.jai` diff --git a/raylib/rlgl/rlgl.jai b/raylib/rlgl/rlgl.jai index 8ac88af..c93adcd 100644 --- a/raylib/rlgl/rlgl.jai +++ b/raylib/rlgl/rlgl.jai @@ -1,7 +1,5 @@ // -// This file was auto-generated using the following command: -// -// jai /Users/judah/Main/cod/jai/jc.jai/raylib/generate.jai +// This file was autogenerated. // @@ -463,204 +461,204 @@ CullMode :: enum u32 { RL_CULL_FACE_BACK :: BACK; } -MatrixMode :: (mode: s32) -> void #foreign raylib "rlMatrixMode"; -PushMatrix :: () -> void #foreign raylib "rlPushMatrix"; -PopMatrix :: () -> void #foreign raylib "rlPopMatrix"; -LoadIdentity :: () -> void #foreign raylib "rlLoadIdentity"; -Translatef :: (x: float, y: float, z: float) -> void #foreign raylib "rlTranslatef"; -Rotatef :: (angle: float, x: float, y: float, z: float) -> void #foreign raylib "rlRotatef"; -Scalef :: (x: float, y: float, z: float) -> void #foreign raylib "rlScalef"; -MultMatrixf :: (matf: *float) -> void #foreign raylib "rlMultMatrixf"; -Frustum :: (left: float64, right: float64, bottom: float64, top: float64, znear: float64, zfar: float64) -> void #foreign raylib "rlFrustum"; -Ortho :: (left: float64, right: float64, bottom: float64, top: float64, znear: float64, zfar: float64) -> void #foreign raylib "rlOrtho"; -Viewport :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign raylib "rlViewport"; -SetClipPlanes :: (nearPlane: float64, farPlane: float64) -> void #foreign raylib "rlSetClipPlanes"; -GetCullDistanceNear :: () -> float64 #foreign raylib "rlGetCullDistanceNear"; -GetCullDistanceFar :: () -> float64 #foreign raylib "rlGetCullDistanceFar"; +MatrixMode :: (mode: s32) -> void #foreign libraylib "rlMatrixMode"; +PushMatrix :: () -> void #foreign libraylib "rlPushMatrix"; +PopMatrix :: () -> void #foreign libraylib "rlPopMatrix"; +LoadIdentity :: () -> void #foreign libraylib "rlLoadIdentity"; +Translatef :: (x: float, y: float, z: float) -> void #foreign libraylib "rlTranslatef"; +Rotatef :: (angle: float, x: float, y: float, z: float) -> void #foreign libraylib "rlRotatef"; +Scalef :: (x: float, y: float, z: float) -> void #foreign libraylib "rlScalef"; +MultMatrixf :: (matf: *float) -> void #foreign libraylib "rlMultMatrixf"; +Frustum :: (left: float64, right: float64, bottom: float64, top: float64, znear: float64, zfar: float64) -> void #foreign libraylib "rlFrustum"; +Ortho :: (left: float64, right: float64, bottom: float64, top: float64, znear: float64, zfar: float64) -> void #foreign libraylib "rlOrtho"; +Viewport :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign libraylib "rlViewport"; +SetClipPlanes :: (nearPlane: float64, farPlane: float64) -> void #foreign libraylib "rlSetClipPlanes"; +GetCullDistanceNear :: () -> float64 #foreign libraylib "rlGetCullDistanceNear"; +GetCullDistanceFar :: () -> float64 #foreign libraylib "rlGetCullDistanceFar"; //------------------------------------------------------------------------------------ // Functions Declaration - Vertex level operations //------------------------------------------------------------------------------------ -Begin :: (mode: s32) -> void #foreign raylib "rlBegin"; -End :: () -> void #foreign raylib "rlEnd"; -Vertex2i :: (x: s32, y: s32) -> void #foreign raylib "rlVertex2i"; -Vertex2f :: (x: float, y: float) -> void #foreign raylib "rlVertex2f"; -Vertex3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlVertex3f"; -TexCoord2f :: (x: float, y: float) -> void #foreign raylib "rlTexCoord2f"; -Normal3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlNormal3f"; -Color4ub :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign raylib "rlColor4ub"; -Color3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlColor3f"; -Color4f :: (x: float, y: float, z: float, w: float) -> void #foreign raylib "rlColor4f"; +Begin :: (mode: s32) -> void #foreign libraylib "rlBegin"; +End :: () -> void #foreign libraylib "rlEnd"; +Vertex2i :: (x: s32, y: s32) -> void #foreign libraylib "rlVertex2i"; +Vertex2f :: (x: float, y: float) -> void #foreign libraylib "rlVertex2f"; +Vertex3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlVertex3f"; +TexCoord2f :: (x: float, y: float) -> void #foreign libraylib "rlTexCoord2f"; +Normal3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlNormal3f"; +Color4ub :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign libraylib "rlColor4ub"; +Color3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlColor3f"; +Color4f :: (x: float, y: float, z: float, w: float) -> void #foreign libraylib "rlColor4f"; // Vertex buffers state -EnableVertexArray :: (vaoId: u32) -> bool #foreign raylib "rlEnableVertexArray"; -DisableVertexArray :: () -> void #foreign raylib "rlDisableVertexArray"; -EnableVertexBuffer :: (id: u32) -> void #foreign raylib "rlEnableVertexBuffer"; -DisableVertexBuffer :: () -> void #foreign raylib "rlDisableVertexBuffer"; -EnableVertexBufferElement :: (id: u32) -> void #foreign raylib "rlEnableVertexBufferElement"; -DisableVertexBufferElement :: () -> void #foreign raylib "rlDisableVertexBufferElement"; -EnableVertexAttribute :: (index: u32) -> void #foreign raylib "rlEnableVertexAttribute"; -DisableVertexAttribute :: (index: u32) -> void #foreign raylib "rlDisableVertexAttribute"; +EnableVertexArray :: (vaoId: u32) -> bool #foreign libraylib "rlEnableVertexArray"; +DisableVertexArray :: () -> void #foreign libraylib "rlDisableVertexArray"; +EnableVertexBuffer :: (id: u32) -> void #foreign libraylib "rlEnableVertexBuffer"; +DisableVertexBuffer :: () -> void #foreign libraylib "rlDisableVertexBuffer"; +EnableVertexBufferElement :: (id: u32) -> void #foreign libraylib "rlEnableVertexBufferElement"; +DisableVertexBufferElement :: () -> void #foreign libraylib "rlDisableVertexBufferElement"; +EnableVertexAttribute :: (index: u32) -> void #foreign libraylib "rlEnableVertexAttribute"; +DisableVertexAttribute :: (index: u32) -> void #foreign libraylib "rlDisableVertexAttribute"; // Textures state -ActiveTextureSlot :: (slot: s32) -> void #foreign raylib "rlActiveTextureSlot"; -EnableTexture :: (id: u32) -> void #foreign raylib "rlEnableTexture"; -DisableTexture :: () -> void #foreign raylib "rlDisableTexture"; -EnableTextureCubemap :: (id: u32) -> void #foreign raylib "rlEnableTextureCubemap"; -DisableTextureCubemap :: () -> void #foreign raylib "rlDisableTextureCubemap"; -TextureParameters :: (id: u32, param: s32, value: s32) -> void #foreign raylib "rlTextureParameters"; -CubemapParameters :: (id: u32, param: s32, value: s32) -> void #foreign raylib "rlCubemapParameters"; +ActiveTextureSlot :: (slot: s32) -> void #foreign libraylib "rlActiveTextureSlot"; +EnableTexture :: (id: u32) -> void #foreign libraylib "rlEnableTexture"; +DisableTexture :: () -> void #foreign libraylib "rlDisableTexture"; +EnableTextureCubemap :: (id: u32) -> void #foreign libraylib "rlEnableTextureCubemap"; +DisableTextureCubemap :: () -> void #foreign libraylib "rlDisableTextureCubemap"; +TextureParameters :: (id: u32, param: s32, value: s32) -> void #foreign libraylib "rlTextureParameters"; +CubemapParameters :: (id: u32, param: s32, value: s32) -> void #foreign libraylib "rlCubemapParameters"; // Shader state -EnableShader :: (id: u32) -> void #foreign raylib "rlEnableShader"; -DisableShader :: () -> void #foreign raylib "rlDisableShader"; +EnableShader :: (id: u32) -> void #foreign libraylib "rlEnableShader"; +DisableShader :: () -> void #foreign libraylib "rlDisableShader"; // Framebuffer state -EnableFramebuffer :: (id: u32) -> void #foreign raylib "rlEnableFramebuffer"; -DisableFramebuffer :: () -> void #foreign raylib "rlDisableFramebuffer"; -GetActiveFramebuffer :: () -> u32 #foreign raylib "rlGetActiveFramebuffer"; -ActiveDrawBuffers :: (count: s32) -> void #foreign raylib "rlActiveDrawBuffers"; -BlitFramebuffer :: (srcX: s32, srcY: s32, srcWidth: s32, srcHeight: s32, dstX: s32, dstY: s32, dstWidth: s32, dstHeight: s32, bufferMask: s32) -> void #foreign raylib "rlBlitFramebuffer"; -BindFramebuffer :: (target: u32, framebuffer: u32) -> void #foreign raylib "rlBindFramebuffer"; +EnableFramebuffer :: (id: u32) -> void #foreign libraylib "rlEnableFramebuffer"; +DisableFramebuffer :: () -> void #foreign libraylib "rlDisableFramebuffer"; +GetActiveFramebuffer :: () -> u32 #foreign libraylib "rlGetActiveFramebuffer"; +ActiveDrawBuffers :: (count: s32) -> void #foreign libraylib "rlActiveDrawBuffers"; +BlitFramebuffer :: (srcX: s32, srcY: s32, srcWidth: s32, srcHeight: s32, dstX: s32, dstY: s32, dstWidth: s32, dstHeight: s32, bufferMask: s32) -> void #foreign libraylib "rlBlitFramebuffer"; +BindFramebuffer :: (target: u32, framebuffer: u32) -> void #foreign libraylib "rlBindFramebuffer"; // General render state -EnableColorBlend :: () -> void #foreign raylib "rlEnableColorBlend"; -DisableColorBlend :: () -> void #foreign raylib "rlDisableColorBlend"; -EnableDepthTest :: () -> void #foreign raylib "rlEnableDepthTest"; -DisableDepthTest :: () -> void #foreign raylib "rlDisableDepthTest"; -EnableDepthMask :: () -> void #foreign raylib "rlEnableDepthMask"; -DisableDepthMask :: () -> void #foreign raylib "rlDisableDepthMask"; -EnableBackfaceCulling :: () -> void #foreign raylib "rlEnableBackfaceCulling"; -DisableBackfaceCulling :: () -> void #foreign raylib "rlDisableBackfaceCulling"; -ColorMask :: (r: bool, g: bool, b: bool, a: bool) -> void #foreign raylib "rlColorMask"; -SetCullFace :: (mode: s32) -> void #foreign raylib "rlSetCullFace"; -EnableScissorTest :: () -> void #foreign raylib "rlEnableScissorTest"; -DisableScissorTest :: () -> void #foreign raylib "rlDisableScissorTest"; -Scissor :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign raylib "rlScissor"; -EnableWireMode :: () -> void #foreign raylib "rlEnableWireMode"; -EnablePointMode :: () -> void #foreign raylib "rlEnablePointMode"; -DisableWireMode :: () -> void #foreign raylib "rlDisableWireMode"; -SetLineWidth :: (width: float) -> void #foreign raylib "rlSetLineWidth"; -GetLineWidth :: () -> float #foreign raylib "rlGetLineWidth"; -EnableSmoothLines :: () -> void #foreign raylib "rlEnableSmoothLines"; -DisableSmoothLines :: () -> void #foreign raylib "rlDisableSmoothLines"; -EnableStereoRender :: () -> void #foreign raylib "rlEnableStereoRender"; -DisableStereoRender :: () -> void #foreign raylib "rlDisableStereoRender"; -IsStereoRenderEnabled :: () -> bool #foreign raylib "rlIsStereoRenderEnabled"; +EnableColorBlend :: () -> void #foreign libraylib "rlEnableColorBlend"; +DisableColorBlend :: () -> void #foreign libraylib "rlDisableColorBlend"; +EnableDepthTest :: () -> void #foreign libraylib "rlEnableDepthTest"; +DisableDepthTest :: () -> void #foreign libraylib "rlDisableDepthTest"; +EnableDepthMask :: () -> void #foreign libraylib "rlEnableDepthMask"; +DisableDepthMask :: () -> void #foreign libraylib "rlDisableDepthMask"; +EnableBackfaceCulling :: () -> void #foreign libraylib "rlEnableBackfaceCulling"; +DisableBackfaceCulling :: () -> void #foreign libraylib "rlDisableBackfaceCulling"; +ColorMask :: (r: bool, g: bool, b: bool, a: bool) -> void #foreign libraylib "rlColorMask"; +SetCullFace :: (mode: s32) -> void #foreign libraylib "rlSetCullFace"; +EnableScissorTest :: () -> void #foreign libraylib "rlEnableScissorTest"; +DisableScissorTest :: () -> void #foreign libraylib "rlDisableScissorTest"; +Scissor :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign libraylib "rlScissor"; +EnableWireMode :: () -> void #foreign libraylib "rlEnableWireMode"; +EnablePointMode :: () -> void #foreign libraylib "rlEnablePointMode"; +DisableWireMode :: () -> void #foreign libraylib "rlDisableWireMode"; +SetLineWidth :: (width: float) -> void #foreign libraylib "rlSetLineWidth"; +GetLineWidth :: () -> float #foreign libraylib "rlGetLineWidth"; +EnableSmoothLines :: () -> void #foreign libraylib "rlEnableSmoothLines"; +DisableSmoothLines :: () -> void #foreign libraylib "rlDisableSmoothLines"; +EnableStereoRender :: () -> void #foreign libraylib "rlEnableStereoRender"; +DisableStereoRender :: () -> void #foreign libraylib "rlDisableStereoRender"; +IsStereoRenderEnabled :: () -> bool #foreign libraylib "rlIsStereoRenderEnabled"; -ClearColor :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign raylib "rlClearColor"; -ClearScreenBuffers :: () -> void #foreign raylib "rlClearScreenBuffers"; -CheckErrors :: () -> void #foreign raylib "rlCheckErrors"; -SetBlendMode :: (mode: s32) -> void #foreign raylib "rlSetBlendMode"; -SetBlendFactors :: (glSrcFactor: s32, glDstFactor: s32, glEquation: s32) -> void #foreign raylib "rlSetBlendFactors"; -SetBlendFactorsSeparate :: (glSrcRGB: s32, glDstRGB: s32, glSrcAlpha: s32, glDstAlpha: s32, glEqRGB: s32, glEqAlpha: s32) -> void #foreign raylib "rlSetBlendFactorsSeparate"; +ClearColor :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign libraylib "rlClearColor"; +ClearScreenBuffers :: () -> void #foreign libraylib "rlClearScreenBuffers"; +CheckErrors :: () -> void #foreign libraylib "rlCheckErrors"; +SetBlendMode :: (mode: s32) -> void #foreign libraylib "rlSetBlendMode"; +SetBlendFactors :: (glSrcFactor: s32, glDstFactor: s32, glEquation: s32) -> void #foreign libraylib "rlSetBlendFactors"; +SetBlendFactorsSeparate :: (glSrcRGB: s32, glDstRGB: s32, glSrcAlpha: s32, glDstAlpha: s32, glEqRGB: s32, glEqAlpha: s32) -> void #foreign libraylib "rlSetBlendFactorsSeparate"; //------------------------------------------------------------------------------------ // Functions Declaration - rlgl functionality //------------------------------------------------------------------------------------ // rlgl initialization functions -glInit :: (width: s32, height: s32) -> void #foreign raylib "rlglInit"; -glClose :: () -> void #foreign raylib "rlglClose"; -LoadExtensions :: (loader: *void) -> void #foreign raylib "rlLoadExtensions"; -GetVersion :: () -> s32 #foreign raylib "rlGetVersion"; -SetFramebufferWidth :: (width: s32) -> void #foreign raylib "rlSetFramebufferWidth"; -GetFramebufferWidth :: () -> s32 #foreign raylib "rlGetFramebufferWidth"; -SetFramebufferHeight :: (height: s32) -> void #foreign raylib "rlSetFramebufferHeight"; -GetFramebufferHeight :: () -> s32 #foreign raylib "rlGetFramebufferHeight"; +glInit :: (width: s32, height: s32) -> void #foreign libraylib "rlglInit"; +glClose :: () -> void #foreign libraylib "rlglClose"; +LoadExtensions :: (loader: *void) -> void #foreign libraylib "rlLoadExtensions"; +GetVersion :: () -> s32 #foreign libraylib "rlGetVersion"; +SetFramebufferWidth :: (width: s32) -> void #foreign libraylib "rlSetFramebufferWidth"; +GetFramebufferWidth :: () -> s32 #foreign libraylib "rlGetFramebufferWidth"; +SetFramebufferHeight :: (height: s32) -> void #foreign libraylib "rlSetFramebufferHeight"; +GetFramebufferHeight :: () -> s32 #foreign libraylib "rlGetFramebufferHeight"; -GetTextureIdDefault :: () -> u32 #foreign raylib "rlGetTextureIdDefault"; -GetShaderIdDefault :: () -> u32 #foreign raylib "rlGetShaderIdDefault"; -GetShaderLocsDefault :: () -> *s32 #foreign raylib "rlGetShaderLocsDefault"; +GetTextureIdDefault :: () -> u32 #foreign libraylib "rlGetTextureIdDefault"; +GetShaderIdDefault :: () -> u32 #foreign libraylib "rlGetShaderIdDefault"; +GetShaderLocsDefault :: () -> *s32 #foreign libraylib "rlGetShaderLocsDefault"; // Render batch management // NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode // but this render batch API is exposed in case of custom batches are required -LoadRenderBatch :: (numBuffers: s32, bufferElements: s32) -> RenderBatch #foreign raylib "rlLoadRenderBatch"; -UnloadRenderBatch :: (batch: RenderBatch) -> void #foreign raylib "rlUnloadRenderBatch"; -DrawRenderBatch :: (batch: *RenderBatch) -> void #foreign raylib "rlDrawRenderBatch"; -SetRenderBatchActive :: (batch: *RenderBatch) -> void #foreign raylib "rlSetRenderBatchActive"; -DrawRenderBatchActive :: () -> void #foreign raylib "rlDrawRenderBatchActive"; -CheckRenderBatchLimit :: (vCount: s32) -> bool #foreign raylib "rlCheckRenderBatchLimit"; +LoadRenderBatch :: (numBuffers: s32, bufferElements: s32) -> RenderBatch #foreign libraylib "rlLoadRenderBatch"; +UnloadRenderBatch :: (batch: RenderBatch) -> void #foreign libraylib "rlUnloadRenderBatch"; +DrawRenderBatch :: (batch: *RenderBatch) -> void #foreign libraylib "rlDrawRenderBatch"; +SetRenderBatchActive :: (batch: *RenderBatch) -> void #foreign libraylib "rlSetRenderBatchActive"; +DrawRenderBatchActive :: () -> void #foreign libraylib "rlDrawRenderBatchActive"; +CheckRenderBatchLimit :: (vCount: s32) -> bool #foreign libraylib "rlCheckRenderBatchLimit"; -SetTexture :: (id: u32) -> void #foreign raylib "rlSetTexture"; +SetTexture :: (id: u32) -> void #foreign libraylib "rlSetTexture"; // Vertex buffers management -LoadVertexArray :: () -> u32 #foreign raylib "rlLoadVertexArray"; -LoadVertexBuffer :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign raylib "rlLoadVertexBuffer"; -LoadVertexBufferElement :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign raylib "rlLoadVertexBufferElement"; -UpdateVertexBuffer :: (bufferId: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign raylib "rlUpdateVertexBuffer"; -UpdateVertexBufferElements :: (id: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign raylib "rlUpdateVertexBufferElements"; -UnloadVertexArray :: (vaoId: u32) -> void #foreign raylib "rlUnloadVertexArray"; -UnloadVertexBuffer :: (vboId: u32) -> void #foreign raylib "rlUnloadVertexBuffer"; -SetVertexAttribute :: (index: u32, compSize: s32, type: s32, normalized: bool, stride: s32, offset: s32) -> void #foreign raylib "rlSetVertexAttribute"; -SetVertexAttributeDivisor :: (index: u32, divisor: s32) -> void #foreign raylib "rlSetVertexAttributeDivisor"; -SetVertexAttributeDefault :: (locIndex: s32, value: *void, attribType: s32, count: s32) -> void #foreign raylib "rlSetVertexAttributeDefault"; -DrawVertexArray :: (offset: s32, count: s32) -> void #foreign raylib "rlDrawVertexArray"; -DrawVertexArrayElements :: (offset: s32, count: s32, buffer: *void) -> void #foreign raylib "rlDrawVertexArrayElements"; -DrawVertexArrayInstanced :: (offset: s32, count: s32, instances: s32) -> void #foreign raylib "rlDrawVertexArrayInstanced"; -DrawVertexArrayElementsInstanced :: (offset: s32, count: s32, buffer: *void, instances: s32) -> void #foreign raylib "rlDrawVertexArrayElementsInstanced"; +LoadVertexArray :: () -> u32 #foreign libraylib "rlLoadVertexArray"; +LoadVertexBuffer :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign libraylib "rlLoadVertexBuffer"; +LoadVertexBufferElement :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign libraylib "rlLoadVertexBufferElement"; +UpdateVertexBuffer :: (bufferId: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign libraylib "rlUpdateVertexBuffer"; +UpdateVertexBufferElements :: (id: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign libraylib "rlUpdateVertexBufferElements"; +UnloadVertexArray :: (vaoId: u32) -> void #foreign libraylib "rlUnloadVertexArray"; +UnloadVertexBuffer :: (vboId: u32) -> void #foreign libraylib "rlUnloadVertexBuffer"; +SetVertexAttribute :: (index: u32, compSize: s32, type: s32, normalized: bool, stride: s32, offset: s32) -> void #foreign libraylib "rlSetVertexAttribute"; +SetVertexAttributeDivisor :: (index: u32, divisor: s32) -> void #foreign libraylib "rlSetVertexAttributeDivisor"; +SetVertexAttributeDefault :: (locIndex: s32, value: *void, attribType: s32, count: s32) -> void #foreign libraylib "rlSetVertexAttributeDefault"; +DrawVertexArray :: (offset: s32, count: s32) -> void #foreign libraylib "rlDrawVertexArray"; +DrawVertexArrayElements :: (offset: s32, count: s32, buffer: *void) -> void #foreign libraylib "rlDrawVertexArrayElements"; +DrawVertexArrayInstanced :: (offset: s32, count: s32, instances: s32) -> void #foreign libraylib "rlDrawVertexArrayInstanced"; +DrawVertexArrayElementsInstanced :: (offset: s32, count: s32, buffer: *void, instances: s32) -> void #foreign libraylib "rlDrawVertexArrayElementsInstanced"; // Textures management -LoadTexture :: (data: *void, width: s32, height: s32, format: s32, mipmapCount: s32) -> u32 #foreign raylib "rlLoadTexture"; -LoadTextureDepth :: (width: s32, height: s32, useRenderBuffer: bool) -> u32 #foreign raylib "rlLoadTextureDepth"; -LoadTextureCubemap :: (data: *void, size: s32, format: s32, mipmapCount: s32) -> u32 #foreign raylib "rlLoadTextureCubemap"; -UpdateTexture :: (id: u32, offsetX: s32, offsetY: s32, width: s32, height: s32, format: s32, data: *void) -> void #foreign raylib "rlUpdateTexture"; -GetGlTextureFormats :: (format: s32, glInternalFormat: *u32, glFormat: *u32, glType: *u32) -> void #foreign raylib "rlGetGlTextureFormats"; -GetPixelFormatName :: (format: u32) -> *u8 #foreign raylib "rlGetPixelFormatName"; -UnloadTexture :: (id: u32) -> void #foreign raylib "rlUnloadTexture"; -GenTextureMipmaps :: (id: u32, width: s32, height: s32, format: s32, mipmaps: *s32) -> void #foreign raylib "rlGenTextureMipmaps"; -ReadTexturePixels :: (id: u32, width: s32, height: s32, format: s32) -> *void #foreign raylib "rlReadTexturePixels"; -ReadScreenPixels :: (width: s32, height: s32) -> *u8 #foreign raylib "rlReadScreenPixels"; +LoadTexture :: (data: *void, width: s32, height: s32, format: s32, mipmapCount: s32) -> u32 #foreign libraylib "rlLoadTexture"; +LoadTextureDepth :: (width: s32, height: s32, useRenderBuffer: bool) -> u32 #foreign libraylib "rlLoadTextureDepth"; +LoadTextureCubemap :: (data: *void, size: s32, format: s32, mipmapCount: s32) -> u32 #foreign libraylib "rlLoadTextureCubemap"; +UpdateTexture :: (id: u32, offsetX: s32, offsetY: s32, width: s32, height: s32, format: s32, data: *void) -> void #foreign libraylib "rlUpdateTexture"; +GetGlTextureFormats :: (format: s32, glInternalFormat: *u32, glFormat: *u32, glType: *u32) -> void #foreign libraylib "rlGetGlTextureFormats"; +GetPixelFormatName :: (format: u32) -> *u8 #foreign libraylib "rlGetPixelFormatName"; +UnloadTexture :: (id: u32) -> void #foreign libraylib "rlUnloadTexture"; +GenTextureMipmaps :: (id: u32, width: s32, height: s32, format: s32, mipmaps: *s32) -> void #foreign libraylib "rlGenTextureMipmaps"; +ReadTexturePixels :: (id: u32, width: s32, height: s32, format: s32) -> *void #foreign libraylib "rlReadTexturePixels"; +ReadScreenPixels :: (width: s32, height: s32) -> *u8 #foreign libraylib "rlReadScreenPixels"; // Framebuffer management (fbo) -LoadFramebuffer :: () -> u32 #foreign raylib "rlLoadFramebuffer"; -FramebufferAttach :: (fboId: u32, texId: u32, attachType: s32, texType: s32, mipLevel: s32) -> void #foreign raylib "rlFramebufferAttach"; -FramebufferComplete :: (id: u32) -> bool #foreign raylib "rlFramebufferComplete"; -UnloadFramebuffer :: (id: u32) -> void #foreign raylib "rlUnloadFramebuffer"; +LoadFramebuffer :: () -> u32 #foreign libraylib "rlLoadFramebuffer"; +FramebufferAttach :: (fboId: u32, texId: u32, attachType: s32, texType: s32, mipLevel: s32) -> void #foreign libraylib "rlFramebufferAttach"; +FramebufferComplete :: (id: u32) -> bool #foreign libraylib "rlFramebufferComplete"; +UnloadFramebuffer :: (id: u32) -> void #foreign libraylib "rlUnloadFramebuffer"; // Shaders management -LoadShaderCode :: (vsCode: *u8, fsCode: *u8) -> u32 #foreign raylib "rlLoadShaderCode"; -CompileShader :: (shaderCode: *u8, type: s32) -> u32 #foreign raylib "rlCompileShader"; -LoadShaderProgram :: (vShaderId: u32, fShaderId: u32) -> u32 #foreign raylib "rlLoadShaderProgram"; -UnloadShaderProgram :: (id: u32) -> void #foreign raylib "rlUnloadShaderProgram"; -GetLocationUniform :: (shaderId: u32, uniformName: *u8) -> s32 #foreign raylib "rlGetLocationUniform"; -GetLocationAttrib :: (shaderId: u32, attribName: *u8) -> s32 #foreign raylib "rlGetLocationAttrib"; -SetUniform :: (locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign raylib "rlSetUniform"; -SetUniformMatrix :: (locIndex: s32, mat: Matrix) -> void #foreign raylib "rlSetUniformMatrix"; -SetUniformMatrices :: (locIndex: s32, mat: *Matrix, count: s32) -> void #foreign raylib "rlSetUniformMatrices"; -SetUniformSampler :: (locIndex: s32, textureId: u32) -> void #foreign raylib "rlSetUniformSampler"; -SetShader :: (id: u32, locs: *s32) -> void #foreign raylib "rlSetShader"; +LoadShaderCode :: (vsCode: *u8, fsCode: *u8) -> u32 #foreign libraylib "rlLoadShaderCode"; +CompileShader :: (shaderCode: *u8, type: s32) -> u32 #foreign libraylib "rlCompileShader"; +LoadShaderProgram :: (vShaderId: u32, fShaderId: u32) -> u32 #foreign libraylib "rlLoadShaderProgram"; +UnloadShaderProgram :: (id: u32) -> void #foreign libraylib "rlUnloadShaderProgram"; +GetLocationUniform :: (shaderId: u32, uniformName: *u8) -> s32 #foreign libraylib "rlGetLocationUniform"; +GetLocationAttrib :: (shaderId: u32, attribName: *u8) -> s32 #foreign libraylib "rlGetLocationAttrib"; +SetUniform :: (locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign libraylib "rlSetUniform"; +SetUniformMatrix :: (locIndex: s32, mat: Matrix) -> void #foreign libraylib "rlSetUniformMatrix"; +SetUniformMatrices :: (locIndex: s32, mat: *Matrix, count: s32) -> void #foreign libraylib "rlSetUniformMatrices"; +SetUniformSampler :: (locIndex: s32, textureId: u32) -> void #foreign libraylib "rlSetUniformSampler"; +SetShader :: (id: u32, locs: *s32) -> void #foreign libraylib "rlSetShader"; // Compute shader management -LoadComputeShaderProgram :: (shaderId: u32) -> u32 #foreign raylib "rlLoadComputeShaderProgram"; -ComputeShaderDispatch :: (groupX: u32, groupY: u32, groupZ: u32) -> void #foreign raylib "rlComputeShaderDispatch"; +LoadComputeShaderProgram :: (shaderId: u32) -> u32 #foreign libraylib "rlLoadComputeShaderProgram"; +ComputeShaderDispatch :: (groupX: u32, groupY: u32, groupZ: u32) -> void #foreign libraylib "rlComputeShaderDispatch"; // Shader buffer storage object management (ssbo) -LoadShaderBuffer :: (size: u32, data: *void, usageHint: s32) -> u32 #foreign raylib "rlLoadShaderBuffer"; -UnloadShaderBuffer :: (ssboId: u32) -> void #foreign raylib "rlUnloadShaderBuffer"; -UpdateShaderBuffer :: (id: u32, data: *void, dataSize: u32, offset: u32) -> void #foreign raylib "rlUpdateShaderBuffer"; -BindShaderBuffer :: (id: u32, index: u32) -> void #foreign raylib "rlBindShaderBuffer"; -ReadShaderBuffer :: (id: u32, dest: *void, count: u32, offset: u32) -> void #foreign raylib "rlReadShaderBuffer"; -CopyShaderBuffer :: (destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32) -> void #foreign raylib "rlCopyShaderBuffer"; -GetShaderBufferSize :: (id: u32) -> u32 #foreign raylib "rlGetShaderBufferSize"; +LoadShaderBuffer :: (size: u32, data: *void, usageHint: s32) -> u32 #foreign libraylib "rlLoadShaderBuffer"; +UnloadShaderBuffer :: (ssboId: u32) -> void #foreign libraylib "rlUnloadShaderBuffer"; +UpdateShaderBuffer :: (id: u32, data: *void, dataSize: u32, offset: u32) -> void #foreign libraylib "rlUpdateShaderBuffer"; +BindShaderBuffer :: (id: u32, index: u32) -> void #foreign libraylib "rlBindShaderBuffer"; +ReadShaderBuffer :: (id: u32, dest: *void, count: u32, offset: u32) -> void #foreign libraylib "rlReadShaderBuffer"; +CopyShaderBuffer :: (destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32) -> void #foreign libraylib "rlCopyShaderBuffer"; +GetShaderBufferSize :: (id: u32) -> u32 #foreign libraylib "rlGetShaderBufferSize"; // Buffer management -BindImageTexture :: (id: u32, index: u32, format: s32, readonly: bool) -> void #foreign raylib "rlBindImageTexture"; +BindImageTexture :: (id: u32, index: u32, format: s32, readonly: bool) -> void #foreign libraylib "rlBindImageTexture"; // Matrix state management -GetMatrixModelview :: () -> Matrix #foreign raylib "rlGetMatrixModelview"; -GetMatrixProjection :: () -> Matrix #foreign raylib "rlGetMatrixProjection"; -GetMatrixTransform :: () -> Matrix #foreign raylib "rlGetMatrixTransform"; -GetMatrixProjectionStereo :: (eye: s32) -> Matrix #foreign raylib "rlGetMatrixProjectionStereo"; -GetMatrixViewOffsetStereo :: (eye: s32) -> Matrix #foreign raylib "rlGetMatrixViewOffsetStereo"; -SetMatrixProjection :: (proj: Matrix) -> void #foreign raylib "rlSetMatrixProjection"; -SetMatrixModelview :: (view: Matrix) -> void #foreign raylib "rlSetMatrixModelview"; -SetMatrixProjectionStereo :: (right: Matrix, left: Matrix) -> void #foreign raylib "rlSetMatrixProjectionStereo"; -SetMatrixViewOffsetStereo :: (right: Matrix, left: Matrix) -> void #foreign raylib "rlSetMatrixViewOffsetStereo"; +GetMatrixModelview :: () -> Matrix #foreign libraylib "rlGetMatrixModelview"; +GetMatrixProjection :: () -> Matrix #foreign libraylib "rlGetMatrixProjection"; +GetMatrixTransform :: () -> Matrix #foreign libraylib "rlGetMatrixTransform"; +GetMatrixProjectionStereo :: (eye: s32) -> Matrix #foreign libraylib "rlGetMatrixProjectionStereo"; +GetMatrixViewOffsetStereo :: (eye: s32) -> Matrix #foreign libraylib "rlGetMatrixViewOffsetStereo"; +SetMatrixProjection :: (proj: Matrix) -> void #foreign libraylib "rlSetMatrixProjection"; +SetMatrixModelview :: (view: Matrix) -> void #foreign libraylib "rlSetMatrixModelview"; +SetMatrixProjectionStereo :: (right: Matrix, left: Matrix) -> void #foreign libraylib "rlSetMatrixProjectionStereo"; +SetMatrixViewOffsetStereo :: (right: Matrix, left: Matrix) -> void #foreign libraylib "rlSetMatrixViewOffsetStereo"; // Quick and dirty cube/quad buffers load->draw->unload -LoadDrawCube :: () -> void #foreign raylib "rlLoadDrawCube"; -LoadDrawQuad :: () -> void #foreign raylib "rlLoadDrawQuad"; +LoadDrawCube :: () -> void #foreign libraylib "rlLoadDrawCube"; +LoadDrawQuad :: () -> void #foreign libraylib "rlLoadDrawQuad"; #scope_file @@ -669,90 +667,140 @@ LoadDrawQuad :: () -> void #foreign raylib "rlLoadDrawQuad"; #run { { - instance: Matrix; - assert(((cast(*void)(*instance.m0)) - cast(*void)(*instance)) == 0, "Matrix.m0 has unexpected offset % instead of 0", ((cast(*void)(*instance.m0)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m0)) == 4, "Matrix.m0 has unexpected size % instead of 4", size_of(type_of(Matrix.m0))); - assert(((cast(*void)(*instance.m4)) - cast(*void)(*instance)) == 4, "Matrix.m4 has unexpected offset % instead of 4", ((cast(*void)(*instance.m4)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m4)) == 4, "Matrix.m4 has unexpected size % instead of 4", size_of(type_of(Matrix.m4))); - assert(((cast(*void)(*instance.m8)) - cast(*void)(*instance)) == 8, "Matrix.m8 has unexpected offset % instead of 8", ((cast(*void)(*instance.m8)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m8)) == 4, "Matrix.m8 has unexpected size % instead of 4", size_of(type_of(Matrix.m8))); - assert(((cast(*void)(*instance.m12)) - cast(*void)(*instance)) == 12, "Matrix.m12 has unexpected offset % instead of 12", ((cast(*void)(*instance.m12)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m12)) == 4, "Matrix.m12 has unexpected size % instead of 4", size_of(type_of(Matrix.m12))); - assert(((cast(*void)(*instance.m1)) - cast(*void)(*instance)) == 16, "Matrix.m1 has unexpected offset % instead of 16", ((cast(*void)(*instance.m1)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m1)) == 4, "Matrix.m1 has unexpected size % instead of 4", size_of(type_of(Matrix.m1))); - assert(((cast(*void)(*instance.m5)) - cast(*void)(*instance)) == 20, "Matrix.m5 has unexpected offset % instead of 20", ((cast(*void)(*instance.m5)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m5)) == 4, "Matrix.m5 has unexpected size % instead of 4", size_of(type_of(Matrix.m5))); - assert(((cast(*void)(*instance.m9)) - cast(*void)(*instance)) == 24, "Matrix.m9 has unexpected offset % instead of 24", ((cast(*void)(*instance.m9)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m9)) == 4, "Matrix.m9 has unexpected size % instead of 4", size_of(type_of(Matrix.m9))); - assert(((cast(*void)(*instance.m13)) - cast(*void)(*instance)) == 28, "Matrix.m13 has unexpected offset % instead of 28", ((cast(*void)(*instance.m13)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m13)) == 4, "Matrix.m13 has unexpected size % instead of 4", size_of(type_of(Matrix.m13))); - assert(((cast(*void)(*instance.m2)) - cast(*void)(*instance)) == 32, "Matrix.m2 has unexpected offset % instead of 32", ((cast(*void)(*instance.m2)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m2)) == 4, "Matrix.m2 has unexpected size % instead of 4", size_of(type_of(Matrix.m2))); - assert(((cast(*void)(*instance.m6)) - cast(*void)(*instance)) == 36, "Matrix.m6 has unexpected offset % instead of 36", ((cast(*void)(*instance.m6)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m6)) == 4, "Matrix.m6 has unexpected size % instead of 4", size_of(type_of(Matrix.m6))); - assert(((cast(*void)(*instance.m10)) - cast(*void)(*instance)) == 40, "Matrix.m10 has unexpected offset % instead of 40", ((cast(*void)(*instance.m10)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m10)) == 4, "Matrix.m10 has unexpected size % instead of 4", size_of(type_of(Matrix.m10))); - assert(((cast(*void)(*instance.m14)) - cast(*void)(*instance)) == 44, "Matrix.m14 has unexpected offset % instead of 44", ((cast(*void)(*instance.m14)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m14)) == 4, "Matrix.m14 has unexpected size % instead of 4", size_of(type_of(Matrix.m14))); - assert(((cast(*void)(*instance.m3)) - cast(*void)(*instance)) == 48, "Matrix.m3 has unexpected offset % instead of 48", ((cast(*void)(*instance.m3)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m3)) == 4, "Matrix.m3 has unexpected size % instead of 4", size_of(type_of(Matrix.m3))); - assert(((cast(*void)(*instance.m7)) - cast(*void)(*instance)) == 52, "Matrix.m7 has unexpected offset % instead of 52", ((cast(*void)(*instance.m7)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m7)) == 4, "Matrix.m7 has unexpected size % instead of 4", size_of(type_of(Matrix.m7))); - assert(((cast(*void)(*instance.m11)) - cast(*void)(*instance)) == 56, "Matrix.m11 has unexpected offset % instead of 56", ((cast(*void)(*instance.m11)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m11)) == 4, "Matrix.m11 has unexpected size % instead of 4", size_of(type_of(Matrix.m11))); - assert(((cast(*void)(*instance.m15)) - cast(*void)(*instance)) == 60, "Matrix.m15 has unexpected offset % instead of 60", ((cast(*void)(*instance.m15)) - cast(*void)(*instance))); - assert(size_of(type_of(Matrix.m15)) == 4, "Matrix.m15 has unexpected size % instead of 4", size_of(type_of(Matrix.m15))); + info := type_info(Matrix); + for info.members { + if it.name == { + case "m0"; + assert(it.offset_in_bytes == 0, "Matrix.m0 has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m0 has unexpected size % instead of 4", it.type.runtime_size); + case "m4"; + assert(it.offset_in_bytes == 4, "Matrix.m4 has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m4 has unexpected size % instead of 4", it.type.runtime_size); + case "m8"; + assert(it.offset_in_bytes == 8, "Matrix.m8 has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m8 has unexpected size % instead of 4", it.type.runtime_size); + case "m12"; + assert(it.offset_in_bytes == 12, "Matrix.m12 has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m12 has unexpected size % instead of 4", it.type.runtime_size); + case "m1"; + assert(it.offset_in_bytes == 16, "Matrix.m1 has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m1 has unexpected size % instead of 4", it.type.runtime_size); + case "m5"; + assert(it.offset_in_bytes == 20, "Matrix.m5 has unexpected offset % instead of 20", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m5 has unexpected size % instead of 4", it.type.runtime_size); + case "m9"; + assert(it.offset_in_bytes == 24, "Matrix.m9 has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m9 has unexpected size % instead of 4", it.type.runtime_size); + case "m13"; + assert(it.offset_in_bytes == 28, "Matrix.m13 has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m13 has unexpected size % instead of 4", it.type.runtime_size); + case "m2"; + assert(it.offset_in_bytes == 32, "Matrix.m2 has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m2 has unexpected size % instead of 4", it.type.runtime_size); + case "m6"; + assert(it.offset_in_bytes == 36, "Matrix.m6 has unexpected offset % instead of 36", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m6 has unexpected size % instead of 4", it.type.runtime_size); + case "m10"; + assert(it.offset_in_bytes == 40, "Matrix.m10 has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m10 has unexpected size % instead of 4", it.type.runtime_size); + case "m14"; + assert(it.offset_in_bytes == 44, "Matrix.m14 has unexpected offset % instead of 44", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m14 has unexpected size % instead of 4", it.type.runtime_size); + case "m3"; + assert(it.offset_in_bytes == 48, "Matrix.m3 has unexpected offset % instead of 48", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m3 has unexpected size % instead of 4", it.type.runtime_size); + case "m7"; + assert(it.offset_in_bytes == 52, "Matrix.m7 has unexpected offset % instead of 52", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m7 has unexpected size % instead of 4", it.type.runtime_size); + case "m11"; + assert(it.offset_in_bytes == 56, "Matrix.m11 has unexpected offset % instead of 56", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m11 has unexpected size % instead of 4", it.type.runtime_size); + case "m15"; + assert(it.offset_in_bytes == 60, "Matrix.m15 has unexpected offset % instead of 60", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "Matrix.m15 has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(Matrix) == 64, "Matrix has size % instead of 64", size_of(Matrix)); } { - instance: VertexBuffer; - assert(((cast(*void)(*instance.elementCount)) - cast(*void)(*instance)) == 0, "VertexBuffer.elementCount has unexpected offset % instead of 0", ((cast(*void)(*instance.elementCount)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.elementCount)) == 4, "VertexBuffer.elementCount has unexpected size % instead of 4", size_of(type_of(VertexBuffer.elementCount))); - assert(((cast(*void)(*instance.vertices)) - cast(*void)(*instance)) == 8, "VertexBuffer.vertices has unexpected offset % instead of 8", ((cast(*void)(*instance.vertices)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.vertices)) == 8, "VertexBuffer.vertices has unexpected size % instead of 8", size_of(type_of(VertexBuffer.vertices))); - assert(((cast(*void)(*instance.texcoords)) - cast(*void)(*instance)) == 16, "VertexBuffer.texcoords has unexpected offset % instead of 16", ((cast(*void)(*instance.texcoords)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.texcoords)) == 8, "VertexBuffer.texcoords has unexpected size % instead of 8", size_of(type_of(VertexBuffer.texcoords))); - assert(((cast(*void)(*instance.normals)) - cast(*void)(*instance)) == 24, "VertexBuffer.normals has unexpected offset % instead of 24", ((cast(*void)(*instance.normals)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.normals)) == 8, "VertexBuffer.normals has unexpected size % instead of 8", size_of(type_of(VertexBuffer.normals))); - assert(((cast(*void)(*instance.colors)) - cast(*void)(*instance)) == 32, "VertexBuffer.colors has unexpected offset % instead of 32", ((cast(*void)(*instance.colors)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.colors)) == 8, "VertexBuffer.colors has unexpected size % instead of 8", size_of(type_of(VertexBuffer.colors))); - assert(((cast(*void)(*instance.indices)) - cast(*void)(*instance)) == 40, "VertexBuffer.indices has unexpected offset % instead of 40", ((cast(*void)(*instance.indices)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.indices)) == 8, "VertexBuffer.indices has unexpected size % instead of 8", size_of(type_of(VertexBuffer.indices))); - assert(((cast(*void)(*instance.vaoId)) - cast(*void)(*instance)) == 48, "VertexBuffer.vaoId has unexpected offset % instead of 48", ((cast(*void)(*instance.vaoId)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.vaoId)) == 4, "VertexBuffer.vaoId has unexpected size % instead of 4", size_of(type_of(VertexBuffer.vaoId))); - assert(((cast(*void)(*instance.vboId)) - cast(*void)(*instance)) == 52, "VertexBuffer.vboId has unexpected offset % instead of 52", ((cast(*void)(*instance.vboId)) - cast(*void)(*instance))); - assert(size_of(type_of(VertexBuffer.vboId)) == 20, "VertexBuffer.vboId has unexpected size % instead of 20", size_of(type_of(VertexBuffer.vboId))); + info := type_info(VertexBuffer); + for info.members { + if it.name == { + case "elementCount"; + assert(it.offset_in_bytes == 0, "VertexBuffer.elementCount has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VertexBuffer.elementCount has unexpected size % instead of 4", it.type.runtime_size); + case "vertices"; + assert(it.offset_in_bytes == 8, "VertexBuffer.vertices has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VertexBuffer.vertices has unexpected size % instead of 8", it.type.runtime_size); + case "texcoords"; + assert(it.offset_in_bytes == 16, "VertexBuffer.texcoords has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VertexBuffer.texcoords has unexpected size % instead of 8", it.type.runtime_size); + case "normals"; + assert(it.offset_in_bytes == 24, "VertexBuffer.normals has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VertexBuffer.normals has unexpected size % instead of 8", it.type.runtime_size); + case "colors"; + assert(it.offset_in_bytes == 32, "VertexBuffer.colors has unexpected offset % instead of 32", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VertexBuffer.colors has unexpected size % instead of 8", it.type.runtime_size); + case "indices"; + assert(it.offset_in_bytes == 40, "VertexBuffer.indices has unexpected offset % instead of 40", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "VertexBuffer.indices has unexpected size % instead of 8", it.type.runtime_size); + case "vaoId"; + assert(it.offset_in_bytes == 48, "VertexBuffer.vaoId has unexpected offset % instead of 48", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "VertexBuffer.vaoId has unexpected size % instead of 4", it.type.runtime_size); + case "vboId"; + assert(it.offset_in_bytes == 52, "VertexBuffer.vboId has unexpected offset % instead of 52", it.offset_in_bytes); + assert(it.type.runtime_size == 20, "VertexBuffer.vboId has unexpected size % instead of 20", it.type.runtime_size); + } + } assert(size_of(VertexBuffer) == 72, "VertexBuffer has size % instead of 72", size_of(VertexBuffer)); } { - instance: DrawCall; - assert(((cast(*void)(*instance.mode)) - cast(*void)(*instance)) == 0, "DrawCall.mode has unexpected offset % instead of 0", ((cast(*void)(*instance.mode)) - cast(*void)(*instance))); - assert(size_of(type_of(DrawCall.mode)) == 4, "DrawCall.mode has unexpected size % instead of 4", size_of(type_of(DrawCall.mode))); - assert(((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance)) == 4, "DrawCall.vertexCount has unexpected offset % instead of 4", ((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance))); - assert(size_of(type_of(DrawCall.vertexCount)) == 4, "DrawCall.vertexCount has unexpected size % instead of 4", size_of(type_of(DrawCall.vertexCount))); - assert(((cast(*void)(*instance.vertexAlignment)) - cast(*void)(*instance)) == 8, "DrawCall.vertexAlignment has unexpected offset % instead of 8", ((cast(*void)(*instance.vertexAlignment)) - cast(*void)(*instance))); - assert(size_of(type_of(DrawCall.vertexAlignment)) == 4, "DrawCall.vertexAlignment has unexpected size % instead of 4", size_of(type_of(DrawCall.vertexAlignment))); - assert(((cast(*void)(*instance.textureId)) - cast(*void)(*instance)) == 12, "DrawCall.textureId has unexpected offset % instead of 12", ((cast(*void)(*instance.textureId)) - cast(*void)(*instance))); - assert(size_of(type_of(DrawCall.textureId)) == 4, "DrawCall.textureId has unexpected size % instead of 4", size_of(type_of(DrawCall.textureId))); + info := type_info(DrawCall); + for info.members { + if it.name == { + case "mode"; + assert(it.offset_in_bytes == 0, "DrawCall.mode has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "DrawCall.mode has unexpected size % instead of 4", it.type.runtime_size); + case "vertexCount"; + assert(it.offset_in_bytes == 4, "DrawCall.vertexCount has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "DrawCall.vertexCount has unexpected size % instead of 4", it.type.runtime_size); + case "vertexAlignment"; + assert(it.offset_in_bytes == 8, "DrawCall.vertexAlignment has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "DrawCall.vertexAlignment has unexpected size % instead of 4", it.type.runtime_size); + case "textureId"; + assert(it.offset_in_bytes == 12, "DrawCall.textureId has unexpected offset % instead of 12", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "DrawCall.textureId has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(DrawCall) == 16, "DrawCall has size % instead of 16", size_of(DrawCall)); } { - instance: RenderBatch; - assert(((cast(*void)(*instance.bufferCount)) - cast(*void)(*instance)) == 0, "RenderBatch.bufferCount has unexpected offset % instead of 0", ((cast(*void)(*instance.bufferCount)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.bufferCount)) == 4, "RenderBatch.bufferCount has unexpected size % instead of 4", size_of(type_of(RenderBatch.bufferCount))); - assert(((cast(*void)(*instance.currentBuffer)) - cast(*void)(*instance)) == 4, "RenderBatch.currentBuffer has unexpected offset % instead of 4", ((cast(*void)(*instance.currentBuffer)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.currentBuffer)) == 4, "RenderBatch.currentBuffer has unexpected size % instead of 4", size_of(type_of(RenderBatch.currentBuffer))); - assert(((cast(*void)(*instance.vertexBuffer)) - cast(*void)(*instance)) == 8, "RenderBatch.vertexBuffer has unexpected offset % instead of 8", ((cast(*void)(*instance.vertexBuffer)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.vertexBuffer)) == 8, "RenderBatch.vertexBuffer has unexpected size % instead of 8", size_of(type_of(RenderBatch.vertexBuffer))); - assert(((cast(*void)(*instance.draws)) - cast(*void)(*instance)) == 16, "RenderBatch.draws has unexpected offset % instead of 16", ((cast(*void)(*instance.draws)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.draws)) == 8, "RenderBatch.draws has unexpected size % instead of 8", size_of(type_of(RenderBatch.draws))); - assert(((cast(*void)(*instance.drawCounter)) - cast(*void)(*instance)) == 24, "RenderBatch.drawCounter has unexpected offset % instead of 24", ((cast(*void)(*instance.drawCounter)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.drawCounter)) == 4, "RenderBatch.drawCounter has unexpected size % instead of 4", size_of(type_of(RenderBatch.drawCounter))); - assert(((cast(*void)(*instance.currentDepth)) - cast(*void)(*instance)) == 28, "RenderBatch.currentDepth has unexpected offset % instead of 28", ((cast(*void)(*instance.currentDepth)) - cast(*void)(*instance))); - assert(size_of(type_of(RenderBatch.currentDepth)) == 4, "RenderBatch.currentDepth has unexpected size % instead of 4", size_of(type_of(RenderBatch.currentDepth))); + info := type_info(RenderBatch); + for info.members { + if it.name == { + case "bufferCount"; + assert(it.offset_in_bytes == 0, "RenderBatch.bufferCount has unexpected offset % instead of 0", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RenderBatch.bufferCount has unexpected size % instead of 4", it.type.runtime_size); + case "currentBuffer"; + assert(it.offset_in_bytes == 4, "RenderBatch.currentBuffer has unexpected offset % instead of 4", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RenderBatch.currentBuffer has unexpected size % instead of 4", it.type.runtime_size); + case "vertexBuffer"; + assert(it.offset_in_bytes == 8, "RenderBatch.vertexBuffer has unexpected offset % instead of 8", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "RenderBatch.vertexBuffer has unexpected size % instead of 8", it.type.runtime_size); + case "draws"; + assert(it.offset_in_bytes == 16, "RenderBatch.draws has unexpected offset % instead of 16", it.offset_in_bytes); + assert(it.type.runtime_size == 8, "RenderBatch.draws has unexpected size % instead of 8", it.type.runtime_size); + case "drawCounter"; + assert(it.offset_in_bytes == 24, "RenderBatch.drawCounter has unexpected offset % instead of 24", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RenderBatch.drawCounter has unexpected size % instead of 4", it.type.runtime_size); + case "currentDepth"; + assert(it.offset_in_bytes == 28, "RenderBatch.currentDepth has unexpected offset % instead of 28", it.offset_in_bytes); + assert(it.type.runtime_size == 4, "RenderBatch.currentDepth has unexpected size % instead of 4", it.type.runtime_size); + } + } assert(size_of(RenderBatch) == 32, "RenderBatch has size % instead of 32", size_of(RenderBatch)); } } diff --git a/raylib/wasm/libraygui.a b/raylib/wasm/libraygui.a new file mode 100644 index 0000000..cfde78a Binary files /dev/null and b/raylib/wasm/libraygui.a differ diff --git a/raylib/wasm/libraylib.a b/raylib/wasm/libraylib.a new file mode 100644 index 0000000..4cdbfa6 Binary files /dev/null and b/raylib/wasm/libraylib.a differ diff --git a/raylib/win/libraygui.dll b/raylib/win/libraygui.dll new file mode 100644 index 0000000..ca99ee7 Binary files /dev/null and b/raylib/win/libraygui.dll differ diff --git a/raylib/win/libraygui.lib b/raylib/win/libraygui.lib new file mode 100644 index 0000000..ea10fad Binary files /dev/null and b/raylib/win/libraygui.lib differ diff --git a/raylib/win/librayguidll.lib b/raylib/win/librayguidll.lib new file mode 100644 index 0000000..d846635 Binary files /dev/null and b/raylib/win/librayguidll.lib differ diff --git a/raylib/win/raylib.dll b/raylib/win/libraylib.dll similarity index 100% rename from raylib/win/raylib.dll rename to raylib/win/libraylib.dll diff --git a/raylib/win/raylib.lib b/raylib/win/libraylib.lib similarity index 100% rename from raylib/win/raylib.lib rename to raylib/win/libraylib.lib diff --git a/raylib/win/libraylibdll.lib b/raylib/win/libraylibdll.lib new file mode 100644 index 0000000..c21e044 Binary files /dev/null and b/raylib/win/libraylibdll.lib differ