fix raylib

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.

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 := create_opts(rl_enum_visitor);
-   opts.visitor = rl_enum_visitor;
-   opts.generate_library_declarations = false;
-
-   LIBRARY_NAME :: "raylib";
 
    #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.libnames, "libraylib");
-   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.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 = create_opts();
-   opts.generate_library_declarations = false;
    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;

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";
    }
 }
 

raylib/readme.md

@@ -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`

raylib/rlgl/rlgl.jai

@@ -1,7 +1,5 @@
 //
-// This file was auto-generated using the following command:
+// This file was autogenerated.
-//
-// jai /Users/judah/Main/cod/jai/jc.jai/raylib/generate.jai
 //
 
 
@@ -463,204 +461,204 @@ CullMode :: enum u32 {
     RL_CULL_FACE_BACK  :: BACK;
 }
 
-MatrixMode :: (mode: s32) -> void #foreign raylib "rlMatrixMode";
+MatrixMode :: (mode: s32) -> void #foreign libraylib "rlMatrixMode";
-PushMatrix :: () -> void #foreign raylib "rlPushMatrix";
+PushMatrix :: () -> void #foreign libraylib "rlPushMatrix";
-PopMatrix :: () -> void #foreign raylib "rlPopMatrix";
+PopMatrix :: () -> void #foreign libraylib "rlPopMatrix";
-LoadIdentity :: () -> void #foreign raylib "rlLoadIdentity";
+LoadIdentity :: () -> void #foreign libraylib "rlLoadIdentity";
-Translatef :: (x: float, y: float, z: float) -> void #foreign raylib "rlTranslatef";
+Translatef :: (x: float, y: float, z: float) -> void #foreign libraylib "rlTranslatef";
-Rotatef :: (angle: float, x: float, y: float, z: float) -> void #foreign raylib "rlRotatef";
+Rotatef :: (angle: float, x: float, y: float, z: float) -> void #foreign libraylib "rlRotatef";
-Scalef :: (x: float, y: float, z: float) -> void #foreign raylib "rlScalef";
+Scalef :: (x: float, y: float, z: float) -> void #foreign libraylib "rlScalef";
-MultMatrixf :: (matf: *float) -> void #foreign raylib "rlMultMatrixf";
+MultMatrixf :: (matf: *float) -> void #foreign libraylib "rlMultMatrixf";
-Frustum :: (left: float64, right: float64, bottom: float64, top: float64, znear: float64, zfar: float64) -> void #foreign raylib "rlFrustum";
+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 raylib "rlOrtho";
+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 raylib "rlViewport";
+Viewport :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign libraylib "rlViewport";
-SetClipPlanes :: (nearPlane: float64, farPlane: float64) -> void #foreign raylib "rlSetClipPlanes";
+SetClipPlanes :: (nearPlane: float64, farPlane: float64) -> void #foreign libraylib "rlSetClipPlanes";
-GetCullDistanceNear :: () -> float64 #foreign raylib "rlGetCullDistanceNear";
+GetCullDistanceNear :: () -> float64 #foreign libraylib "rlGetCullDistanceNear";
-GetCullDistanceFar :: () -> float64 #foreign raylib "rlGetCullDistanceFar";
+GetCullDistanceFar :: () -> float64 #foreign libraylib "rlGetCullDistanceFar";
 
 //------------------------------------------------------------------------------------
 // Functions Declaration - Vertex level operations
 //------------------------------------------------------------------------------------
-Begin :: (mode: s32) -> void #foreign raylib "rlBegin";
+Begin :: (mode: s32) -> void #foreign libraylib "rlBegin";
-End :: () -> void #foreign raylib "rlEnd";
+End :: () -> void #foreign libraylib "rlEnd";
-Vertex2i :: (x: s32, y: s32) -> void #foreign raylib "rlVertex2i";
+Vertex2i :: (x: s32, y: s32) -> void #foreign libraylib "rlVertex2i";
-Vertex2f :: (x: float, y: float) -> void #foreign raylib "rlVertex2f";
+Vertex2f :: (x: float, y: float) -> void #foreign libraylib "rlVertex2f";
-Vertex3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlVertex3f";
+Vertex3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlVertex3f";
-TexCoord2f :: (x: float, y: float) -> void #foreign raylib "rlTexCoord2f";
+TexCoord2f :: (x: float, y: float) -> void #foreign libraylib "rlTexCoord2f";
-Normal3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlNormal3f";
+Normal3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlNormal3f";
-Color4ub :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign raylib "rlColor4ub";
+Color4ub :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign libraylib "rlColor4ub";
-Color3f :: (x: float, y: float, z: float) -> void #foreign raylib "rlColor3f";
+Color3f :: (x: float, y: float, z: float) -> void #foreign libraylib "rlColor3f";
-Color4f :: (x: float, y: float, z: float, w: float) -> void #foreign raylib "rlColor4f";
+Color4f :: (x: float, y: float, z: float, w: float) -> void #foreign libraylib "rlColor4f";
 
 // Vertex buffers state
-EnableVertexArray :: (vaoId: u32) -> bool #foreign raylib "rlEnableVertexArray";
+EnableVertexArray :: (vaoId: u32) -> bool #foreign libraylib "rlEnableVertexArray";
-DisableVertexArray :: () -> void #foreign raylib "rlDisableVertexArray";
+DisableVertexArray :: () -> void #foreign libraylib "rlDisableVertexArray";
-EnableVertexBuffer :: (id: u32) -> void #foreign raylib "rlEnableVertexBuffer";
+EnableVertexBuffer :: (id: u32) -> void #foreign libraylib "rlEnableVertexBuffer";
-DisableVertexBuffer :: () -> void #foreign raylib "rlDisableVertexBuffer";
+DisableVertexBuffer :: () -> void #foreign libraylib "rlDisableVertexBuffer";
-EnableVertexBufferElement :: (id: u32) -> void #foreign raylib "rlEnableVertexBufferElement";
+EnableVertexBufferElement :: (id: u32) -> void #foreign libraylib "rlEnableVertexBufferElement";
-DisableVertexBufferElement :: () -> void #foreign raylib "rlDisableVertexBufferElement";
+DisableVertexBufferElement :: () -> void #foreign libraylib "rlDisableVertexBufferElement";
-EnableVertexAttribute :: (index: u32) -> void #foreign raylib "rlEnableVertexAttribute";
+EnableVertexAttribute :: (index: u32) -> void #foreign libraylib "rlEnableVertexAttribute";
-DisableVertexAttribute :: (index: u32) -> void #foreign raylib "rlDisableVertexAttribute";
+DisableVertexAttribute :: (index: u32) -> void #foreign libraylib "rlDisableVertexAttribute";
 
 // Textures state
-ActiveTextureSlot :: (slot: s32) -> void #foreign raylib "rlActiveTextureSlot";
+ActiveTextureSlot :: (slot: s32) -> void #foreign libraylib "rlActiveTextureSlot";
-EnableTexture :: (id: u32) -> void #foreign raylib "rlEnableTexture";
+EnableTexture :: (id: u32) -> void #foreign libraylib "rlEnableTexture";
-DisableTexture :: () -> void #foreign raylib "rlDisableTexture";
+DisableTexture :: () -> void #foreign libraylib "rlDisableTexture";
-EnableTextureCubemap :: (id: u32) -> void #foreign raylib "rlEnableTextureCubemap";
+EnableTextureCubemap :: (id: u32) -> void #foreign libraylib "rlEnableTextureCubemap";
-DisableTextureCubemap :: () -> void #foreign raylib "rlDisableTextureCubemap";
+DisableTextureCubemap :: () -> void #foreign libraylib "rlDisableTextureCubemap";
-TextureParameters :: (id: u32, param: s32, value: s32) -> void #foreign raylib "rlTextureParameters";
+TextureParameters :: (id: u32, param: s32, value: s32) -> void #foreign libraylib "rlTextureParameters";
-CubemapParameters :: (id: u32, param: s32, value: s32) -> void #foreign raylib "rlCubemapParameters";
+CubemapParameters :: (id: u32, param: s32, value: s32) -> void #foreign libraylib "rlCubemapParameters";
 
 // Shader state
-EnableShader :: (id: u32) -> void #foreign raylib "rlEnableShader";
+EnableShader :: (id: u32) -> void #foreign libraylib "rlEnableShader";
-DisableShader :: () -> void #foreign raylib "rlDisableShader";
+DisableShader :: () -> void #foreign libraylib "rlDisableShader";
 
 // Framebuffer state
-EnableFramebuffer :: (id: u32) -> void #foreign raylib "rlEnableFramebuffer";
+EnableFramebuffer :: (id: u32) -> void #foreign libraylib "rlEnableFramebuffer";
-DisableFramebuffer :: () -> void #foreign raylib "rlDisableFramebuffer";
+DisableFramebuffer :: () -> void #foreign libraylib "rlDisableFramebuffer";
-GetActiveFramebuffer :: () -> u32 #foreign raylib "rlGetActiveFramebuffer";
+GetActiveFramebuffer :: () -> u32 #foreign libraylib "rlGetActiveFramebuffer";
-ActiveDrawBuffers :: (count: s32) -> void #foreign raylib "rlActiveDrawBuffers";
+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 raylib "rlBlitFramebuffer";
+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 raylib "rlBindFramebuffer";
+BindFramebuffer :: (target: u32, framebuffer: u32) -> void #foreign libraylib "rlBindFramebuffer";
 
 // General render state
-EnableColorBlend :: () -> void #foreign raylib "rlEnableColorBlend";
+EnableColorBlend :: () -> void #foreign libraylib "rlEnableColorBlend";
-DisableColorBlend :: () -> void #foreign raylib "rlDisableColorBlend";
+DisableColorBlend :: () -> void #foreign libraylib "rlDisableColorBlend";
-EnableDepthTest :: () -> void #foreign raylib "rlEnableDepthTest";
+EnableDepthTest :: () -> void #foreign libraylib "rlEnableDepthTest";
-DisableDepthTest :: () -> void #foreign raylib "rlDisableDepthTest";
+DisableDepthTest :: () -> void #foreign libraylib "rlDisableDepthTest";
-EnableDepthMask :: () -> void #foreign raylib "rlEnableDepthMask";
+EnableDepthMask :: () -> void #foreign libraylib "rlEnableDepthMask";
-DisableDepthMask :: () -> void #foreign raylib "rlDisableDepthMask";
+DisableDepthMask :: () -> void #foreign libraylib "rlDisableDepthMask";
-EnableBackfaceCulling :: () -> void #foreign raylib "rlEnableBackfaceCulling";
+EnableBackfaceCulling :: () -> void #foreign libraylib "rlEnableBackfaceCulling";
-DisableBackfaceCulling :: () -> void #foreign raylib "rlDisableBackfaceCulling";
+DisableBackfaceCulling :: () -> void #foreign libraylib "rlDisableBackfaceCulling";
-ColorMask :: (r: bool, g: bool, b: bool, a: bool) -> void #foreign raylib "rlColorMask";
+ColorMask :: (r: bool, g: bool, b: bool, a: bool) -> void #foreign libraylib "rlColorMask";
-SetCullFace :: (mode: s32) -> void #foreign raylib "rlSetCullFace";
+SetCullFace :: (mode: s32) -> void #foreign libraylib "rlSetCullFace";
-EnableScissorTest :: () -> void #foreign raylib "rlEnableScissorTest";
+EnableScissorTest :: () -> void #foreign libraylib "rlEnableScissorTest";
-DisableScissorTest :: () -> void #foreign raylib "rlDisableScissorTest";
+DisableScissorTest :: () -> void #foreign libraylib "rlDisableScissorTest";
-Scissor :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign raylib "rlScissor";
+Scissor :: (x: s32, y: s32, width: s32, height: s32) -> void #foreign libraylib "rlScissor";
-EnableWireMode :: () -> void #foreign raylib "rlEnableWireMode";
+EnableWireMode :: () -> void #foreign libraylib "rlEnableWireMode";
-EnablePointMode :: () -> void #foreign raylib "rlEnablePointMode";
+EnablePointMode :: () -> void #foreign libraylib "rlEnablePointMode";
-DisableWireMode :: () -> void #foreign raylib "rlDisableWireMode";
+DisableWireMode :: () -> void #foreign libraylib "rlDisableWireMode";
-SetLineWidth :: (width: float) -> void #foreign raylib "rlSetLineWidth";
+SetLineWidth :: (width: float) -> void #foreign libraylib "rlSetLineWidth";
-GetLineWidth :: () -> float #foreign raylib "rlGetLineWidth";
+GetLineWidth :: () -> float #foreign libraylib "rlGetLineWidth";
-EnableSmoothLines :: () -> void #foreign raylib "rlEnableSmoothLines";
+EnableSmoothLines :: () -> void #foreign libraylib "rlEnableSmoothLines";
-DisableSmoothLines :: () -> void #foreign raylib "rlDisableSmoothLines";
+DisableSmoothLines :: () -> void #foreign libraylib "rlDisableSmoothLines";
-EnableStereoRender :: () -> void #foreign raylib "rlEnableStereoRender";
+EnableStereoRender :: () -> void #foreign libraylib "rlEnableStereoRender";
-DisableStereoRender :: () -> void #foreign raylib "rlDisableStereoRender";
+DisableStereoRender :: () -> void #foreign libraylib "rlDisableStereoRender";
-IsStereoRenderEnabled :: () -> bool #foreign raylib "rlIsStereoRenderEnabled";
+IsStereoRenderEnabled :: () -> bool #foreign libraylib "rlIsStereoRenderEnabled";
 
-ClearColor :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign raylib "rlClearColor";
+ClearColor :: (r: u8, g: u8, b: u8, a: u8) -> void #foreign libraylib "rlClearColor";
-ClearScreenBuffers :: () -> void #foreign raylib "rlClearScreenBuffers";
+ClearScreenBuffers :: () -> void #foreign libraylib "rlClearScreenBuffers";
-CheckErrors :: () -> void #foreign raylib "rlCheckErrors";
+CheckErrors :: () -> void #foreign libraylib "rlCheckErrors";
-SetBlendMode :: (mode: s32) -> void #foreign raylib "rlSetBlendMode";
+SetBlendMode :: (mode: s32) -> void #foreign libraylib "rlSetBlendMode";
-SetBlendFactors :: (glSrcFactor: s32, glDstFactor: s32, glEquation: s32) -> void #foreign raylib "rlSetBlendFactors";
+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 raylib "rlSetBlendFactorsSeparate";
+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";
+glInit :: (width: s32, height: s32) -> void #foreign libraylib "rlglInit";
-glClose :: () -> void #foreign raylib "rlglClose";
+glClose :: () -> void #foreign libraylib "rlglClose";
-LoadExtensions :: (loader: *void) -> void #foreign raylib "rlLoadExtensions";
+LoadExtensions :: (loader: *void) -> void #foreign libraylib "rlLoadExtensions";
-GetVersion :: () -> s32 #foreign raylib "rlGetVersion";
+GetVersion :: () -> s32 #foreign libraylib "rlGetVersion";
-SetFramebufferWidth :: (width: s32) -> void #foreign raylib "rlSetFramebufferWidth";
+SetFramebufferWidth :: (width: s32) -> void #foreign libraylib "rlSetFramebufferWidth";
-GetFramebufferWidth :: () -> s32 #foreign raylib "rlGetFramebufferWidth";
+GetFramebufferWidth :: () -> s32 #foreign libraylib "rlGetFramebufferWidth";
-SetFramebufferHeight :: (height: s32) -> void #foreign raylib "rlSetFramebufferHeight";
+SetFramebufferHeight :: (height: s32) -> void #foreign libraylib "rlSetFramebufferHeight";
-GetFramebufferHeight :: () -> s32 #foreign raylib "rlGetFramebufferHeight";
+GetFramebufferHeight :: () -> s32 #foreign libraylib "rlGetFramebufferHeight";
 
-GetTextureIdDefault :: () -> u32 #foreign raylib "rlGetTextureIdDefault";
+GetTextureIdDefault :: () -> u32 #foreign libraylib "rlGetTextureIdDefault";
-GetShaderIdDefault :: () -> u32 #foreign raylib "rlGetShaderIdDefault";
+GetShaderIdDefault :: () -> u32 #foreign libraylib "rlGetShaderIdDefault";
-GetShaderLocsDefault :: () -> *s32 #foreign raylib "rlGetShaderLocsDefault";
+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";
+LoadRenderBatch :: (numBuffers: s32, bufferElements: s32) -> RenderBatch #foreign libraylib "rlLoadRenderBatch";
-UnloadRenderBatch :: (batch: RenderBatch) -> void #foreign raylib "rlUnloadRenderBatch";
+UnloadRenderBatch :: (batch: RenderBatch) -> void #foreign libraylib "rlUnloadRenderBatch";
-DrawRenderBatch :: (batch: *RenderBatch) -> void #foreign raylib "rlDrawRenderBatch";
+DrawRenderBatch :: (batch: *RenderBatch) -> void #foreign libraylib "rlDrawRenderBatch";
-SetRenderBatchActive :: (batch: *RenderBatch) -> void #foreign raylib "rlSetRenderBatchActive";
+SetRenderBatchActive :: (batch: *RenderBatch) -> void #foreign libraylib "rlSetRenderBatchActive";
-DrawRenderBatchActive :: () -> void #foreign raylib "rlDrawRenderBatchActive";
+DrawRenderBatchActive :: () -> void #foreign libraylib "rlDrawRenderBatchActive";
-CheckRenderBatchLimit :: (vCount: s32) -> bool #foreign raylib "rlCheckRenderBatchLimit";
+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";
+LoadVertexArray :: () -> u32 #foreign libraylib "rlLoadVertexArray";
-LoadVertexBuffer :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign raylib "rlLoadVertexBuffer";
+LoadVertexBuffer :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign libraylib "rlLoadVertexBuffer";
-LoadVertexBufferElement :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign raylib "rlLoadVertexBufferElement";
+LoadVertexBufferElement :: (buffer: *void, size: s32, dynamic: bool) -> u32 #foreign libraylib "rlLoadVertexBufferElement";
-UpdateVertexBuffer :: (bufferId: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign raylib "rlUpdateVertexBuffer";
+UpdateVertexBuffer :: (bufferId: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign libraylib "rlUpdateVertexBuffer";
-UpdateVertexBufferElements :: (id: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign raylib "rlUpdateVertexBufferElements";
+UpdateVertexBufferElements :: (id: u32, data: *void, dataSize: s32, offset: s32) -> void #foreign libraylib "rlUpdateVertexBufferElements";
-UnloadVertexArray :: (vaoId: u32) -> void #foreign raylib "rlUnloadVertexArray";
+UnloadVertexArray :: (vaoId: u32) -> void #foreign libraylib "rlUnloadVertexArray";
-UnloadVertexBuffer :: (vboId: u32) -> void #foreign raylib "rlUnloadVertexBuffer";
+UnloadVertexBuffer :: (vboId: u32) -> void #foreign libraylib "rlUnloadVertexBuffer";
-SetVertexAttribute :: (index: u32, compSize: s32, type: s32, normalized: bool, stride: s32, offset: s32) -> void #foreign raylib "rlSetVertexAttribute";
+SetVertexAttribute :: (index: u32, compSize: s32, type: s32, normalized: bool, stride: s32, offset: s32) -> void #foreign libraylib "rlSetVertexAttribute";
-SetVertexAttributeDivisor :: (index: u32, divisor: s32) -> void #foreign raylib "rlSetVertexAttributeDivisor";
+SetVertexAttributeDivisor :: (index: u32, divisor: s32) -> void #foreign libraylib "rlSetVertexAttributeDivisor";
-SetVertexAttributeDefault :: (locIndex: s32, value: *void, attribType: s32, count: s32) -> void #foreign raylib "rlSetVertexAttributeDefault";
+SetVertexAttributeDefault :: (locIndex: s32, value: *void, attribType: s32, count: s32) -> void #foreign libraylib "rlSetVertexAttributeDefault";
-DrawVertexArray :: (offset: s32, count: s32) -> void #foreign raylib "rlDrawVertexArray";
+DrawVertexArray :: (offset: s32, count: s32) -> void #foreign libraylib "rlDrawVertexArray";
-DrawVertexArrayElements :: (offset: s32, count: s32, buffer: *void) -> void #foreign raylib "rlDrawVertexArrayElements";
+DrawVertexArrayElements :: (offset: s32, count: s32, buffer: *void) -> void #foreign libraylib "rlDrawVertexArrayElements";
-DrawVertexArrayInstanced :: (offset: s32, count: s32, instances: s32) -> void #foreign raylib "rlDrawVertexArrayInstanced";
+DrawVertexArrayInstanced :: (offset: s32, count: s32, instances: s32) -> void #foreign libraylib "rlDrawVertexArrayInstanced";
-DrawVertexArrayElementsInstanced :: (offset: s32, count: s32, buffer: *void, instances: s32) -> void #foreign raylib "rlDrawVertexArrayElementsInstanced";
+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";
+LoadTexture :: (data: *void, width: s32, height: s32, format: s32, mipmapCount: s32) -> u32 #foreign libraylib "rlLoadTexture";
-LoadTextureDepth :: (width: s32, height: s32, useRenderBuffer: bool) -> u32 #foreign raylib "rlLoadTextureDepth";
+LoadTextureDepth :: (width: s32, height: s32, useRenderBuffer: bool) -> u32 #foreign libraylib "rlLoadTextureDepth";
-LoadTextureCubemap :: (data: *void, size: s32, format: s32, mipmapCount: s32) -> u32 #foreign raylib "rlLoadTextureCubemap";
+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 raylib "rlUpdateTexture";
+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 raylib "rlGetGlTextureFormats";
+GetGlTextureFormats :: (format: s32, glInternalFormat: *u32, glFormat: *u32, glType: *u32) -> void #foreign libraylib "rlGetGlTextureFormats";
-GetPixelFormatName :: (format: u32) -> *u8 #foreign raylib "rlGetPixelFormatName";
+GetPixelFormatName :: (format: u32) -> *u8 #foreign libraylib "rlGetPixelFormatName";
-UnloadTexture :: (id: u32) -> void #foreign raylib "rlUnloadTexture";
+UnloadTexture :: (id: u32) -> void #foreign libraylib "rlUnloadTexture";
-GenTextureMipmaps :: (id: u32, width: s32, height: s32, format: s32, mipmaps: *s32) -> void #foreign raylib "rlGenTextureMipmaps";
+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 raylib "rlReadTexturePixels";
+ReadTexturePixels :: (id: u32, width: s32, height: s32, format: s32) -> *void #foreign libraylib "rlReadTexturePixels";
-ReadScreenPixels :: (width: s32, height: s32) -> *u8 #foreign raylib "rlReadScreenPixels";
+ReadScreenPixels :: (width: s32, height: s32) -> *u8 #foreign libraylib "rlReadScreenPixels";
 
 // Framebuffer management (fbo)
-LoadFramebuffer :: () -> u32 #foreign raylib "rlLoadFramebuffer";
+LoadFramebuffer :: () -> u32 #foreign libraylib "rlLoadFramebuffer";
-FramebufferAttach :: (fboId: u32, texId: u32, attachType: s32, texType: s32, mipLevel: s32) -> void #foreign raylib "rlFramebufferAttach";
+FramebufferAttach :: (fboId: u32, texId: u32, attachType: s32, texType: s32, mipLevel: s32) -> void #foreign libraylib "rlFramebufferAttach";
-FramebufferComplete :: (id: u32) -> bool #foreign raylib "rlFramebufferComplete";
+FramebufferComplete :: (id: u32) -> bool #foreign libraylib "rlFramebufferComplete";
-UnloadFramebuffer :: (id: u32) -> void #foreign raylib "rlUnloadFramebuffer";
+UnloadFramebuffer :: (id: u32) -> void #foreign libraylib "rlUnloadFramebuffer";
 
 // Shaders management
-LoadShaderCode :: (vsCode: *u8, fsCode: *u8) -> u32 #foreign raylib "rlLoadShaderCode";
+LoadShaderCode :: (vsCode: *u8, fsCode: *u8) -> u32 #foreign libraylib "rlLoadShaderCode";
-CompileShader :: (shaderCode: *u8, type: s32) -> u32 #foreign raylib "rlCompileShader";
+CompileShader :: (shaderCode: *u8, type: s32) -> u32 #foreign libraylib "rlCompileShader";
-LoadShaderProgram :: (vShaderId: u32, fShaderId: u32) -> u32 #foreign raylib "rlLoadShaderProgram";
+LoadShaderProgram :: (vShaderId: u32, fShaderId: u32) -> u32 #foreign libraylib "rlLoadShaderProgram";
-UnloadShaderProgram :: (id: u32) -> void #foreign raylib "rlUnloadShaderProgram";
+UnloadShaderProgram :: (id: u32) -> void #foreign libraylib "rlUnloadShaderProgram";
-GetLocationUniform :: (shaderId: u32, uniformName: *u8) -> s32 #foreign raylib "rlGetLocationUniform";
+GetLocationUniform :: (shaderId: u32, uniformName: *u8) -> s32 #foreign libraylib "rlGetLocationUniform";
-GetLocationAttrib :: (shaderId: u32, attribName: *u8) -> s32 #foreign raylib "rlGetLocationAttrib";
+GetLocationAttrib :: (shaderId: u32, attribName: *u8) -> s32 #foreign libraylib "rlGetLocationAttrib";
-SetUniform :: (locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign raylib "rlSetUniform";
+SetUniform :: (locIndex: s32, value: *void, uniformType: s32, count: s32) -> void #foreign libraylib "rlSetUniform";
-SetUniformMatrix :: (locIndex: s32, mat: Matrix) -> void #foreign raylib "rlSetUniformMatrix";
+SetUniformMatrix :: (locIndex: s32, mat: Matrix) -> void #foreign libraylib "rlSetUniformMatrix";
-SetUniformMatrices :: (locIndex: s32, mat: *Matrix, count: s32) -> void #foreign raylib "rlSetUniformMatrices";
+SetUniformMatrices :: (locIndex: s32, mat: *Matrix, count: s32) -> void #foreign libraylib "rlSetUniformMatrices";
-SetUniformSampler :: (locIndex: s32, textureId: u32) -> void #foreign raylib "rlSetUniformSampler";
+SetUniformSampler :: (locIndex: s32, textureId: u32) -> void #foreign libraylib "rlSetUniformSampler";
-SetShader :: (id: u32, locs: *s32) -> void #foreign raylib "rlSetShader";
+SetShader :: (id: u32, locs: *s32) -> void #foreign libraylib "rlSetShader";
 
 // Compute shader management
-LoadComputeShaderProgram :: (shaderId: u32) -> u32 #foreign raylib "rlLoadComputeShaderProgram";
+LoadComputeShaderProgram :: (shaderId: u32) -> u32 #foreign libraylib "rlLoadComputeShaderProgram";
-ComputeShaderDispatch :: (groupX: u32, groupY: u32, groupZ: u32) -> void #foreign raylib "rlComputeShaderDispatch";
+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";
+LoadShaderBuffer :: (size: u32, data: *void, usageHint: s32) -> u32 #foreign libraylib "rlLoadShaderBuffer";
-UnloadShaderBuffer :: (ssboId: u32) -> void #foreign raylib "rlUnloadShaderBuffer";
+UnloadShaderBuffer :: (ssboId: u32) -> void #foreign libraylib "rlUnloadShaderBuffer";
-UpdateShaderBuffer :: (id: u32, data: *void, dataSize: u32, offset: u32) -> void #foreign raylib "rlUpdateShaderBuffer";
+UpdateShaderBuffer :: (id: u32, data: *void, dataSize: u32, offset: u32) -> void #foreign libraylib "rlUpdateShaderBuffer";
-BindShaderBuffer :: (id: u32, index: u32) -> void #foreign raylib "rlBindShaderBuffer";
+BindShaderBuffer :: (id: u32, index: u32) -> void #foreign libraylib "rlBindShaderBuffer";
-ReadShaderBuffer :: (id: u32, dest: *void, count: u32, offset: u32) -> void #foreign raylib "rlReadShaderBuffer";
+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 raylib "rlCopyShaderBuffer";
+CopyShaderBuffer :: (destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32) -> void #foreign libraylib "rlCopyShaderBuffer";
-GetShaderBufferSize :: (id: u32) -> u32 #foreign raylib "rlGetShaderBufferSize";
+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";
+GetMatrixModelview :: () -> Matrix #foreign libraylib "rlGetMatrixModelview";
-GetMatrixProjection :: () -> Matrix #foreign raylib "rlGetMatrixProjection";
+GetMatrixProjection :: () -> Matrix #foreign libraylib "rlGetMatrixProjection";
-GetMatrixTransform :: () -> Matrix #foreign raylib "rlGetMatrixTransform";
+GetMatrixTransform :: () -> Matrix #foreign libraylib "rlGetMatrixTransform";
-GetMatrixProjectionStereo :: (eye: s32) -> Matrix #foreign raylib "rlGetMatrixProjectionStereo";
+GetMatrixProjectionStereo :: (eye: s32) -> Matrix #foreign libraylib "rlGetMatrixProjectionStereo";
-GetMatrixViewOffsetStereo :: (eye: s32) -> Matrix #foreign raylib "rlGetMatrixViewOffsetStereo";
+GetMatrixViewOffsetStereo :: (eye: s32) -> Matrix #foreign libraylib "rlGetMatrixViewOffsetStereo";
-SetMatrixProjection :: (proj: Matrix) -> void #foreign raylib "rlSetMatrixProjection";
+SetMatrixProjection :: (proj: Matrix) -> void #foreign libraylib "rlSetMatrixProjection";
-SetMatrixModelview :: (view: Matrix) -> void #foreign raylib "rlSetMatrixModelview";
+SetMatrixModelview :: (view: Matrix) -> void #foreign libraylib "rlSetMatrixModelview";
-SetMatrixProjectionStereo :: (right: Matrix, left: Matrix) -> void #foreign raylib "rlSetMatrixProjectionStereo";
+SetMatrixProjectionStereo :: (right: Matrix, left: Matrix) -> void #foreign libraylib "rlSetMatrixProjectionStereo";
-SetMatrixViewOffsetStereo :: (right: Matrix, left: Matrix) -> void #foreign raylib "rlSetMatrixViewOffsetStereo";
+SetMatrixViewOffsetStereo :: (right: Matrix, left: Matrix) -> void #foreign libraylib "rlSetMatrixViewOffsetStereo";
 
 // Quick and dirty cube/quad buffers load->draw->unload
-LoadDrawCube :: () -> void #foreign raylib "rlLoadDrawCube";
+LoadDrawCube :: () -> void #foreign libraylib "rlLoadDrawCube";
-LoadDrawQuad :: () -> void #foreign raylib "rlLoadDrawQuad";
+LoadDrawQuad :: () -> void #foreign libraylib "rlLoadDrawQuad";
 
 #scope_file
 
@@ -669,90 +667,140 @@ LoadDrawQuad :: () -> void #foreign raylib "rlLoadDrawQuad";
 
 #run {
     {
-        instance: Matrix;
+        info := type_info(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)));
+        for info.members {
-        assert(size_of(type_of(Matrix.m0)) == 4, "Matrix.m0 has unexpected size % instead of 4", size_of(type_of(Matrix.m0)));
+            if it.name == {
-        assert(((cast(*void)(*instance.m4)) - cast(*void)(*instance)) == 4, "Matrix.m4 has unexpected offset % instead of 4", ((cast(*void)(*instance.m4)) - cast(*void)(*instance)));
+                case "m0";
-        assert(size_of(type_of(Matrix.m4)) == 4, "Matrix.m4 has unexpected size % instead of 4", size_of(type_of(Matrix.m4)));
+                    assert(it.offset_in_bytes == 0, "Matrix.m0 has unexpected offset % instead of 0", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "Matrix.m0 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(Matrix.m8)) == 4, "Matrix.m8 has unexpected size % instead of 4", size_of(type_of(Matrix.m8)));
+                case "m4";
-        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(it.offset_in_bytes == 4, "Matrix.m4 has unexpected offset % instead of 4", it.offset_in_bytes);
-        assert(size_of(type_of(Matrix.m12)) == 4, "Matrix.m12 has unexpected size % instead of 4", size_of(type_of(Matrix.m12)));
+                    assert(it.type.runtime_size == 4, "Matrix.m4 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(((cast(*void)(*instance.m1)) - cast(*void)(*instance)) == 16, "Matrix.m1 has unexpected offset % instead of 16", ((cast(*void)(*instance.m1)) - cast(*void)(*instance)));
+                case "m8";
-        assert(size_of(type_of(Matrix.m1)) == 4, "Matrix.m1 has unexpected size % instead of 4", size_of(type_of(Matrix.m1)));
+                    assert(it.offset_in_bytes == 8, "Matrix.m8 has unexpected offset % instead of 8", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "Matrix.m8 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(Matrix.m5)) == 4, "Matrix.m5 has unexpected size % instead of 4", size_of(type_of(Matrix.m5)));
+                case "m12";
-        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(it.offset_in_bytes == 12, "Matrix.m12 has unexpected offset % instead of 12", it.offset_in_bytes);
-        assert(size_of(type_of(Matrix.m9)) == 4, "Matrix.m9 has unexpected size % instead of 4", size_of(type_of(Matrix.m9)));
+                    assert(it.type.runtime_size == 4, "Matrix.m12 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(((cast(*void)(*instance.m13)) - cast(*void)(*instance)) == 28, "Matrix.m13 has unexpected offset % instead of 28", ((cast(*void)(*instance.m13)) - cast(*void)(*instance)));
+                case "m1";
-        assert(size_of(type_of(Matrix.m13)) == 4, "Matrix.m13 has unexpected size % instead of 4", size_of(type_of(Matrix.m13)));
+                    assert(it.offset_in_bytes == 16, "Matrix.m1 has unexpected offset % instead of 16", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "Matrix.m1 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(Matrix.m2)) == 4, "Matrix.m2 has unexpected size % instead of 4", size_of(type_of(Matrix.m2)));
+                case "m5";
-        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(it.offset_in_bytes == 20, "Matrix.m5 has unexpected offset % instead of 20", it.offset_in_bytes);
-        assert(size_of(type_of(Matrix.m6)) == 4, "Matrix.m6 has unexpected size % instead of 4", size_of(type_of(Matrix.m6)));
+                    assert(it.type.runtime_size == 4, "Matrix.m5 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(((cast(*void)(*instance.m10)) - cast(*void)(*instance)) == 40, "Matrix.m10 has unexpected offset % instead of 40", ((cast(*void)(*instance.m10)) - cast(*void)(*instance)));
+                case "m9";
-        assert(size_of(type_of(Matrix.m10)) == 4, "Matrix.m10 has unexpected size % instead of 4", size_of(type_of(Matrix.m10)));
+                    assert(it.offset_in_bytes == 24, "Matrix.m9 has unexpected offset % instead of 24", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "Matrix.m9 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(Matrix.m14)) == 4, "Matrix.m14 has unexpected size % instead of 4", size_of(type_of(Matrix.m14)));
+                case "m13";
-        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(it.offset_in_bytes == 28, "Matrix.m13 has unexpected offset % instead of 28", it.offset_in_bytes);
-        assert(size_of(type_of(Matrix.m3)) == 4, "Matrix.m3 has unexpected size % instead of 4", size_of(type_of(Matrix.m3)));
+                    assert(it.type.runtime_size == 4, "Matrix.m13 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(((cast(*void)(*instance.m7)) - cast(*void)(*instance)) == 52, "Matrix.m7 has unexpected offset % instead of 52", ((cast(*void)(*instance.m7)) - cast(*void)(*instance)));
+                case "m2";
-        assert(size_of(type_of(Matrix.m7)) == 4, "Matrix.m7 has unexpected size % instead of 4", size_of(type_of(Matrix.m7)));
+                    assert(it.offset_in_bytes == 32, "Matrix.m2 has unexpected offset % instead of 32", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "Matrix.m2 has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(Matrix.m11)) == 4, "Matrix.m11 has unexpected size % instead of 4", size_of(type_of(Matrix.m11)));
+                case "m6";
-        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(it.offset_in_bytes == 36, "Matrix.m6 has unexpected offset % instead of 36", it.offset_in_bytes);
-        assert(size_of(type_of(Matrix.m15)) == 4, "Matrix.m15 has unexpected size % instead of 4", size_of(type_of(Matrix.m15)));
+                    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;
+        info := type_info(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)));
+        for info.members {
-        assert(size_of(type_of(VertexBuffer.elementCount)) == 4, "VertexBuffer.elementCount has unexpected size % instead of 4", size_of(type_of(VertexBuffer.elementCount)));
+            if it.name == {
-        assert(((cast(*void)(*instance.vertices)) - cast(*void)(*instance)) == 8, "VertexBuffer.vertices has unexpected offset % instead of 8", ((cast(*void)(*instance.vertices)) - cast(*void)(*instance)));
+                case "elementCount";
-        assert(size_of(type_of(VertexBuffer.vertices)) == 8, "VertexBuffer.vertices has unexpected size % instead of 8", size_of(type_of(VertexBuffer.vertices)));
+                    assert(it.offset_in_bytes == 0, "VertexBuffer.elementCount has unexpected offset % instead of 0", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "VertexBuffer.elementCount has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(VertexBuffer.texcoords)) == 8, "VertexBuffer.texcoords has unexpected size % instead of 8", size_of(type_of(VertexBuffer.texcoords)));
+                case "vertices";
-        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(it.offset_in_bytes == 8, "VertexBuffer.vertices has unexpected offset % instead of 8", it.offset_in_bytes);
-        assert(size_of(type_of(VertexBuffer.normals)) == 8, "VertexBuffer.normals has unexpected size % instead of 8", size_of(type_of(VertexBuffer.normals)));
+                    assert(it.type.runtime_size == 8, "VertexBuffer.vertices has unexpected size % instead of 8", it.type.runtime_size);
-        assert(((cast(*void)(*instance.colors)) - cast(*void)(*instance)) == 32, "VertexBuffer.colors has unexpected offset % instead of 32", ((cast(*void)(*instance.colors)) - cast(*void)(*instance)));
+                case "texcoords";
-        assert(size_of(type_of(VertexBuffer.colors)) == 8, "VertexBuffer.colors has unexpected size % instead of 8", size_of(type_of(VertexBuffer.colors)));
+                    assert(it.offset_in_bytes == 16, "VertexBuffer.texcoords has unexpected offset % instead of 16", it.offset_in_bytes);
-        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(it.type.runtime_size == 8, "VertexBuffer.texcoords has unexpected size % instead of 8", it.type.runtime_size);
-        assert(size_of(type_of(VertexBuffer.indices)) == 8, "VertexBuffer.indices has unexpected size % instead of 8", size_of(type_of(VertexBuffer.indices)));
+                case "normals";
-        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(it.offset_in_bytes == 24, "VertexBuffer.normals has unexpected offset % instead of 24", it.offset_in_bytes);
-        assert(size_of(type_of(VertexBuffer.vaoId)) == 4, "VertexBuffer.vaoId has unexpected size % instead of 4", size_of(type_of(VertexBuffer.vaoId)));
+                    assert(it.type.runtime_size == 8, "VertexBuffer.normals has unexpected size % instead of 8", it.type.runtime_size);
-        assert(((cast(*void)(*instance.vboId)) - cast(*void)(*instance)) == 52, "VertexBuffer.vboId has unexpected offset % instead of 52", ((cast(*void)(*instance.vboId)) - cast(*void)(*instance)));
+                case "colors";
-        assert(size_of(type_of(VertexBuffer.vboId)) == 20, "VertexBuffer.vboId has unexpected size % instead of 20", size_of(type_of(VertexBuffer.vboId)));
+                    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;
+        info := type_info(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)));
+        for info.members {
-        assert(size_of(type_of(DrawCall.mode)) == 4, "DrawCall.mode has unexpected size % instead of 4", size_of(type_of(DrawCall.mode)));
+            if it.name == {
-        assert(((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance)) == 4, "DrawCall.vertexCount has unexpected offset % instead of 4", ((cast(*void)(*instance.vertexCount)) - cast(*void)(*instance)));
+                case "mode";
-        assert(size_of(type_of(DrawCall.vertexCount)) == 4, "DrawCall.vertexCount has unexpected size % instead of 4", size_of(type_of(DrawCall.vertexCount)));
+                    assert(it.offset_in_bytes == 0, "DrawCall.mode has unexpected offset % instead of 0", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "DrawCall.mode has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(DrawCall.vertexAlignment)) == 4, "DrawCall.vertexAlignment has unexpected size % instead of 4", size_of(type_of(DrawCall.vertexAlignment)));
+                case "vertexCount";
-        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(it.offset_in_bytes == 4, "DrawCall.vertexCount has unexpected offset % instead of 4", it.offset_in_bytes);
-        assert(size_of(type_of(DrawCall.textureId)) == 4, "DrawCall.textureId has unexpected size % instead of 4", size_of(type_of(DrawCall.textureId)));
+                    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;
+        info := type_info(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)));
+        for info.members {
-        assert(size_of(type_of(RenderBatch.bufferCount)) == 4, "RenderBatch.bufferCount has unexpected size % instead of 4", size_of(type_of(RenderBatch.bufferCount)));
+            if it.name == {
-        assert(((cast(*void)(*instance.currentBuffer)) - cast(*void)(*instance)) == 4, "RenderBatch.currentBuffer has unexpected offset % instead of 4", ((cast(*void)(*instance.currentBuffer)) - cast(*void)(*instance)));
+                case "bufferCount";
-        assert(size_of(type_of(RenderBatch.currentBuffer)) == 4, "RenderBatch.currentBuffer has unexpected size % instead of 4", size_of(type_of(RenderBatch.currentBuffer)));
+                    assert(it.offset_in_bytes == 0, "RenderBatch.bufferCount has unexpected offset % instead of 0", it.offset_in_bytes);
-        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(it.type.runtime_size == 4, "RenderBatch.bufferCount has unexpected size % instead of 4", it.type.runtime_size);
-        assert(size_of(type_of(RenderBatch.vertexBuffer)) == 8, "RenderBatch.vertexBuffer has unexpected size % instead of 8", size_of(type_of(RenderBatch.vertexBuffer)));
+                case "currentBuffer";
-        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(it.offset_in_bytes == 4, "RenderBatch.currentBuffer has unexpected offset % instead of 4", it.offset_in_bytes);
-        assert(size_of(type_of(RenderBatch.draws)) == 8, "RenderBatch.draws has unexpected size % instead of 8", size_of(type_of(RenderBatch.draws)));
+                    assert(it.type.runtime_size == 4, "RenderBatch.currentBuffer has unexpected size % instead of 4", it.type.runtime_size);
-        assert(((cast(*void)(*instance.drawCounter)) - cast(*void)(*instance)) == 24, "RenderBatch.drawCounter has unexpected offset % instead of 24", ((cast(*void)(*instance.drawCounter)) - cast(*void)(*instance)));
+                case "vertexBuffer";
-        assert(size_of(type_of(RenderBatch.drawCounter)) == 4, "RenderBatch.drawCounter has unexpected size % instead of 4", size_of(type_of(RenderBatch.drawCounter)));
+                    assert(it.offset_in_bytes == 8, "RenderBatch.vertexBuffer has unexpected offset % instead of 8", it.offset_in_bytes);
-        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(it.type.runtime_size == 8, "RenderBatch.vertexBuffer has unexpected size % instead of 8", it.type.runtime_size);
-        assert(size_of(type_of(RenderBatch.currentDepth)) == 4, "RenderBatch.currentDepth has unexpected size % instead of 4", size_of(type_of(RenderBatch.currentDepth)));
+                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));
     }
 }