...

2025-10-17 14:45:55 +02:00
parent 21a5f016a0
commit f471e40471
10 changed files with 1783 additions and 285 deletions
--- a/examples/raylib/generate.py
+++ b/examples/raylib/generate.py
@@ -1,134 +0,0 @@
-import sys
-import os
-import clang.cindex
-from clang.cindex import CursorKind, TypeKind, Type
-
-
-def map_type(clang_type: Type):
-    canonical = clang_type.get_canonical()
-    kind = canonical.kind
-    spelling = (
-        canonical.spelling.replace("const ", "")
-        .replace("volatile ", "")
-        .replace("restrict ", "")
-    )
-
-    if kind == TypeKind.POINTER:
-        pointee = canonical.get_pointee()
-        if pointee.kind == TypeKind.CHAR_S or pointee.kind == TypeKind.CHAR_U:
-            return "cstring"
-
-        if pointee.kind == TypeKind.FUNCTIONPROTO:
-            arg_types = []
-
-            for arg in pointee.get_canonical().argument_types():
-                arg_types.append(map_type(arg))
-
-            mapped_return = map_type(pointee.get_canonical().get_result())
-            args_str = ", ".join(arg_types)
-
-            return f"func({args_str}): {mapped_return}"
-
-        return f"^{map_type(pointee)}"
-
-    if kind == TypeKind.CONSTANTARRAY:
-        element_type = canonical.get_array_element_type()
-        size = canonical.get_array_size()
-        return f"[{size}]{map_type(element_type)}"
-
-    if kind == TypeKind.FUNCTIONPROTO or kind == TypeKind.FUNCTIONNOPROTO:
-        arg_types = []
-
-        for arg in canonical.argument_types():
-            arg_types.append(map_type(arg))
-
-        mapped_return = map_type(canonical.get_result())
-        args_str = ", ".join(arg_types)
-
-        return f"func({args_str}): {mapped_return}"
-
-    if kind == TypeKind.VOID:
-        return "void"
-
-    if kind == TypeKind.BOOL:
-        return "bool"
-
-    if kind in [TypeKind.CHAR_S, TypeKind.SCHAR]:
-        return "i8"
-    if kind == TypeKind.CHAR_U or kind == TypeKind.UCHAR:
-        return "u8"
-    if kind == TypeKind.SHORT:
-        return "i16"
-    if kind == TypeKind.USHORT:
-        return "u16"
-    if kind == TypeKind.INT:
-        return "i32"
-    if kind == TypeKind.UINT:
-        return "u32"
-    if kind in [TypeKind.LONG, TypeKind.LONGLONG]:
-        return "i64"
-    if kind in [TypeKind.ULONG, TypeKind.ULONGLONG]:
-        return "u64"
-
-    if kind == TypeKind.FLOAT:
-        return "f32"
-    if kind == TypeKind.DOUBLE or kind == TypeKind.LONGDOUBLE:
-        return "f64"
-
-    if kind == TypeKind.RECORD:
-        if not spelling.startswith("struct "):
-            raise Exception(f"Unknown custom type: {spelling}")
-
-        return spelling.replace("struct ", "")
-
-    raise Exception(f"Unresolved type: {spelling}")
-
-
-if len(sys.argv) != 2:
-    print("Usage: python3 generate.py [path to header]", file=sys.stderr)
-    sys.exit(1)
-
-filename = sys.argv[1]
-
-index = clang.cindex.Index.create()
-
-tu = index.parse(filename, ["-x", "c", "-std=c23"])
-
-if tu.diagnostics:
-    for diag in tu.diagnostics:
-        if diag.severity >= clang.cindex.Diagnostic.Error:
-            print(f"Error: {diag.spelling}", file=sys.stderr)
-
-print(f'module "{os.path.basename(filename).split(".")[0]}"')
-print()
-
-for cursor in tu.cursor.walk_preorder():
-    if cursor.location.file and cursor.location.file.name != filename:
-        continue
-
-    if cursor.kind == CursorKind.FUNCTION_DECL:
-        name = cursor.spelling
-        return_type = map_type(cursor.result_type)
-
-        params = []
-        for arg in cursor.get_arguments():
-            param_name = arg.spelling
-            param_type = map_type(arg.type)
-            params.append(f"{param_name}: {param_type}")
-
-        params_str = ", ".join(params)
-
-        print(f'export extern "{name}" func {name}({params_str}): {return_type}')
-
-    elif cursor.kind == CursorKind.STRUCT_DECL:
-        name = cursor.spelling
-        print(f"export struct {name}")
-        print("{")
-        for field in cursor.get_children():
-            if field.kind == CursorKind.FIELD_DECL:
-                field_name = field.spelling
-                field_type = map_type(field.type)
-                print(f"    {field_name}: {field_type}")
-            else:
-                raise Exception(f"Unsupported child of struct: {field.spelling}")
-        print("}")
--- a/examples/raylib/generated/raylib.nub
+++ b/examples/raylib/generated/raylib.nub
--- a/examples/raylib/generated/raymath.nub
+++ b/examples/raylib/generated/raymath.nub
@@ -0,0 +1,235 @@
+module "raymath"
+
+export struct Vector2
+{
+    x: f32
+    y: f32
+}
+export struct Vector2
+{
+    x: f32
+    y: f32
+}
+export struct Vector3
+{
+    x: f32
+    y: f32
+    z: f32
+}
+export struct Vector3
+{
+    x: f32
+    y: f32
+    z: f32
+}
+export struct Vector4
+{
+    x: f32
+    y: f32
+    z: f32
+    w: f32
+}
+export struct Vector4
+{
+    x: f32
+    y: f32
+    z: f32
+    w: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct float3
+{
+    v: [3]f32
+}
+export struct float3
+{
+    v: [3]f32
+}
+export struct float16
+{
+    v: [16]f32
+}
+export struct float16
+{
+    v: [16]f32
+}
+export extern "Clamp" func Clamp(value: f32, min: f32, max: f32): f32
+export extern "Lerp" func Lerp(start: f32, end: f32, amount: f32): f32
+export extern "Normalize" func Normalize(value: f32, start: f32, end: f32): f32
+export extern "Remap" func Remap(value: f32, inputStart: f32, inputEnd: f32, outputStart: f32, outputEnd: f32): f32
+export extern "Wrap" func Wrap(value: f32, min: f32, max: f32): f32
+export extern "FloatEquals" func FloatEquals(x: f32, y: f32): i32
+export extern "Vector2Zero" func Vector2Zero(): Vector2
+export extern "Vector2One" func Vector2One(): Vector2
+export extern "Vector2Add" func Vector2Add(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2AddValue" func Vector2AddValue(v: Vector2, add: f32): Vector2
+export extern "Vector2Subtract" func Vector2Subtract(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2SubtractValue" func Vector2SubtractValue(v: Vector2, sub: f32): Vector2
+export extern "Vector2Length" func Vector2Length(v: Vector2): f32
+export extern "Vector2LengthSqr" func Vector2LengthSqr(v: Vector2): f32
+export extern "Vector2DotProduct" func Vector2DotProduct(v1: Vector2, v2: Vector2): f32
+export extern "Vector2Distance" func Vector2Distance(v1: Vector2, v2: Vector2): f32
+export extern "Vector2DistanceSqr" func Vector2DistanceSqr(v1: Vector2, v2: Vector2): f32
+export extern "Vector2Angle" func Vector2Angle(v1: Vector2, v2: Vector2): f32
+export extern "Vector2LineAngle" func Vector2LineAngle(start: Vector2, end: Vector2): f32
+export extern "Vector2Scale" func Vector2Scale(v: Vector2, scale: f32): Vector2
+export extern "Vector2Multiply" func Vector2Multiply(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Negate" func Vector2Negate(v: Vector2): Vector2
+export extern "Vector2Divide" func Vector2Divide(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Normalize" func Vector2Normalize(v: Vector2): Vector2
+export extern "Vector2Transform" func Vector2Transform(v: Vector2, mat: Matrix): Vector2
+export extern "Vector2Lerp" func Vector2Lerp(v1: Vector2, v2: Vector2, amount: f32): Vector2
+export extern "Vector2Reflect" func Vector2Reflect(v: Vector2, normal: Vector2): Vector2
+export extern "Vector2Min" func Vector2Min(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Max" func Vector2Max(v1: Vector2, v2: Vector2): Vector2
+export extern "Vector2Rotate" func Vector2Rotate(v: Vector2, angle: f32): Vector2
+export extern "Vector2MoveTowards" func Vector2MoveTowards(v: Vector2, target: Vector2, maxDistance: f32): Vector2
+export extern "Vector2Invert" func Vector2Invert(v: Vector2): Vector2
+export extern "Vector2Clamp" func Vector2Clamp(v: Vector2, min: Vector2, max: Vector2): Vector2
+export extern "Vector2ClampValue" func Vector2ClampValue(v: Vector2, min: f32, max: f32): Vector2
+export extern "Vector2Equals" func Vector2Equals(p: Vector2, q: Vector2): i32
+export extern "Vector2Refract" func Vector2Refract(v: Vector2, n: Vector2, r: f32): Vector2
+export extern "Vector3Zero" func Vector3Zero(): Vector3
+export extern "Vector3One" func Vector3One(): Vector3
+export extern "Vector3Add" func Vector3Add(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3AddValue" func Vector3AddValue(v: Vector3, add: f32): Vector3
+export extern "Vector3Subtract" func Vector3Subtract(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3SubtractValue" func Vector3SubtractValue(v: Vector3, sub: f32): Vector3
+export extern "Vector3Scale" func Vector3Scale(v: Vector3, scalar: f32): Vector3
+export extern "Vector3Multiply" func Vector3Multiply(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3CrossProduct" func Vector3CrossProduct(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Perpendicular" func Vector3Perpendicular(v: Vector3): Vector3
+export extern "Vector3Length" func Vector3Length(v: Vector3): f32
+export extern "Vector3LengthSqr" func Vector3LengthSqr(v: Vector3): f32
+export extern "Vector3DotProduct" func Vector3DotProduct(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Distance" func Vector3Distance(v1: Vector3, v2: Vector3): f32
+export extern "Vector3DistanceSqr" func Vector3DistanceSqr(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Angle" func Vector3Angle(v1: Vector3, v2: Vector3): f32
+export extern "Vector3Negate" func Vector3Negate(v: Vector3): Vector3
+export extern "Vector3Divide" func Vector3Divide(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Normalize" func Vector3Normalize(v: Vector3): Vector3
+export extern "Vector3Project" func Vector3Project(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Reject" func Vector3Reject(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3OrthoNormalize" func Vector3OrthoNormalize(v1: ^Vector3, v2: ^Vector3): void
+export extern "Vector3Transform" func Vector3Transform(v: Vector3, mat: Matrix): Vector3
+export extern "Vector3RotateByQuaternion" func Vector3RotateByQuaternion(v: Vector3, q: Vector4): Vector3
+export extern "Vector3RotateByAxisAngle" func Vector3RotateByAxisAngle(v: Vector3, axis: Vector3, angle: f32): Vector3
+export extern "Vector3MoveTowards" func Vector3MoveTowards(v: Vector3, target: Vector3, maxDistance: f32): Vector3
+export extern "Vector3Lerp" func Vector3Lerp(v1: Vector3, v2: Vector3, amount: f32): Vector3
+export extern "Vector3CubicHermite" func Vector3CubicHermite(v1: Vector3, tangent1: Vector3, v2: Vector3, tangent2: Vector3, amount: f32): Vector3
+export extern "Vector3Reflect" func Vector3Reflect(v: Vector3, normal: Vector3): Vector3
+export extern "Vector3Min" func Vector3Min(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Max" func Vector3Max(v1: Vector3, v2: Vector3): Vector3
+export extern "Vector3Barycenter" func Vector3Barycenter(p: Vector3, a: Vector3, b: Vector3, c: Vector3): Vector3
+export extern "Vector3Unproject" func Vector3Unproject(source: Vector3, projection: Matrix, view: Matrix): Vector3
+export extern "Vector3ToFloatV" func Vector3ToFloatV(v: Vector3): float3
+export extern "Vector3Invert" func Vector3Invert(v: Vector3): Vector3
+export extern "Vector3Clamp" func Vector3Clamp(v: Vector3, min: Vector3, max: Vector3): Vector3
+export extern "Vector3ClampValue" func Vector3ClampValue(v: Vector3, min: f32, max: f32): Vector3
+export extern "Vector3Equals" func Vector3Equals(p: Vector3, q: Vector3): i32
+export extern "Vector3Refract" func Vector3Refract(v: Vector3, n: Vector3, r: f32): Vector3
+export extern "Vector4Zero" func Vector4Zero(): Vector4
+export extern "Vector4One" func Vector4One(): Vector4
+export extern "Vector4Add" func Vector4Add(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4AddValue" func Vector4AddValue(v: Vector4, add: f32): Vector4
+export extern "Vector4Subtract" func Vector4Subtract(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4SubtractValue" func Vector4SubtractValue(v: Vector4, add: f32): Vector4
+export extern "Vector4Length" func Vector4Length(v: Vector4): f32
+export extern "Vector4LengthSqr" func Vector4LengthSqr(v: Vector4): f32
+export extern "Vector4DotProduct" func Vector4DotProduct(v1: Vector4, v2: Vector4): f32
+export extern "Vector4Distance" func Vector4Distance(v1: Vector4, v2: Vector4): f32
+export extern "Vector4DistanceSqr" func Vector4DistanceSqr(v1: Vector4, v2: Vector4): f32
+export extern "Vector4Scale" func Vector4Scale(v: Vector4, scale: f32): Vector4
+export extern "Vector4Multiply" func Vector4Multiply(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Negate" func Vector4Negate(v: Vector4): Vector4
+export extern "Vector4Divide" func Vector4Divide(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Normalize" func Vector4Normalize(v: Vector4): Vector4
+export extern "Vector4Min" func Vector4Min(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Max" func Vector4Max(v1: Vector4, v2: Vector4): Vector4
+export extern "Vector4Lerp" func Vector4Lerp(v1: Vector4, v2: Vector4, amount: f32): Vector4
+export extern "Vector4MoveTowards" func Vector4MoveTowards(v: Vector4, target: Vector4, maxDistance: f32): Vector4
+export extern "Vector4Invert" func Vector4Invert(v: Vector4): Vector4
+export extern "Vector4Equals" func Vector4Equals(p: Vector4, q: Vector4): i32
+export extern "MatrixDeterminant" func MatrixDeterminant(mat: Matrix): f32
+export extern "MatrixTrace" func MatrixTrace(mat: Matrix): f32
+export extern "MatrixTranspose" func MatrixTranspose(mat: Matrix): Matrix
+export extern "MatrixInvert" func MatrixInvert(mat: Matrix): Matrix
+export extern "MatrixIdentity" func MatrixIdentity(): Matrix
+export extern "MatrixAdd" func MatrixAdd(left: Matrix, right: Matrix): Matrix
+export extern "MatrixSubtract" func MatrixSubtract(left: Matrix, right: Matrix): Matrix
+export extern "MatrixMultiply" func MatrixMultiply(left: Matrix, right: Matrix): Matrix
+export extern "MatrixTranslate" func MatrixTranslate(x: f32, y: f32, z: f32): Matrix
+export extern "MatrixRotate" func MatrixRotate(axis: Vector3, angle: f32): Matrix
+export extern "MatrixRotateX" func MatrixRotateX(angle: f32): Matrix
+export extern "MatrixRotateY" func MatrixRotateY(angle: f32): Matrix
+export extern "MatrixRotateZ" func MatrixRotateZ(angle: f32): Matrix
+export extern "MatrixRotateXYZ" func MatrixRotateXYZ(angle: Vector3): Matrix
+export extern "MatrixRotateZYX" func MatrixRotateZYX(angle: Vector3): Matrix
+export extern "MatrixScale" func MatrixScale(x: f32, y: f32, z: f32): Matrix
+export extern "MatrixFrustum" func MatrixFrustum(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixPerspective" func MatrixPerspective(fovY: f64, aspect: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixOrtho" func MatrixOrtho(left: f64, right: f64, bottom: f64, top: f64, nearPlane: f64, farPlane: f64): Matrix
+export extern "MatrixLookAt" func MatrixLookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix
+export extern "MatrixToFloatV" func MatrixToFloatV(mat: Matrix): float16
+export extern "QuaternionAdd" func QuaternionAdd(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionAddValue" func QuaternionAddValue(q: Vector4, add: f32): Vector4
+export extern "QuaternionSubtract" func QuaternionSubtract(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionSubtractValue" func QuaternionSubtractValue(q: Vector4, sub: f32): Vector4
+export extern "QuaternionIdentity" func QuaternionIdentity(): Vector4
+export extern "QuaternionLength" func QuaternionLength(q: Vector4): f32
+export extern "QuaternionNormalize" func QuaternionNormalize(q: Vector4): Vector4
+export extern "QuaternionInvert" func QuaternionInvert(q: Vector4): Vector4
+export extern "QuaternionMultiply" func QuaternionMultiply(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionScale" func QuaternionScale(q: Vector4, mul: f32): Vector4
+export extern "QuaternionDivide" func QuaternionDivide(q1: Vector4, q2: Vector4): Vector4
+export extern "QuaternionLerp" func QuaternionLerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionNlerp" func QuaternionNlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionSlerp" func QuaternionSlerp(q1: Vector4, q2: Vector4, amount: f32): Vector4
+export extern "QuaternionCubicHermiteSpline" func QuaternionCubicHermiteSpline(q1: Vector4, outTangent1: Vector4, q2: Vector4, inTangent2: Vector4, t: f32): Vector4
+export extern "QuaternionFromVector3ToVector3" func QuaternionFromVector3ToVector3(from: Vector3, to: Vector3): Vector4
+export extern "QuaternionFromMatrix" func QuaternionFromMatrix(mat: Matrix): Vector4
+export extern "QuaternionToMatrix" func QuaternionToMatrix(q: Vector4): Matrix
+export extern "QuaternionFromAxisAngle" func QuaternionFromAxisAngle(axis: Vector3, angle: f32): Vector4
+export extern "QuaternionToAxisAngle" func QuaternionToAxisAngle(q: Vector4, outAxis: ^Vector3, outAngle: ^f32): void
+export extern "QuaternionFromEuler" func QuaternionFromEuler(pitch: f32, yaw: f32, roll: f32): Vector4
+export extern "QuaternionToEuler" func QuaternionToEuler(q: Vector4): Vector3
+export extern "QuaternionTransform" func QuaternionTransform(q: Vector4, mat: Matrix): Vector4
+export extern "QuaternionEquals" func QuaternionEquals(p: Vector4, q: Vector4): i32
+export extern "MatrixDecompose" func MatrixDecompose(mat: Matrix, translation: ^Vector3, rotation: ^Vector4, scale: ^Vector3): void
--- a/examples/raylib/generated/rlgl.nub
+++ b/examples/raylib/generated/rlgl.nub
@@ -0,0 +1,248 @@
+module "rlgl"
+
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct Matrix
+{
+    m0: f32
+    m4: f32
+    m8: f32
+    m12: f32
+    m1: f32
+    m5: f32
+    m9: f32
+    m13: f32
+    m2: f32
+    m6: f32
+    m10: f32
+    m14: f32
+    m3: f32
+    m7: f32
+    m11: f32
+    m15: f32
+}
+export struct rlVertexBuffer
+{
+    elementCount: i32
+    vertices: ^f32
+    texcoords: ^f32
+    normals: ^f32
+    colors: ^u8
+    indices: ^u32
+    vaoId: u32
+    vboId: [5]u32
+}
+export struct rlVertexBuffer
+{
+    elementCount: i32
+    vertices: ^f32
+    texcoords: ^f32
+    normals: ^f32
+    colors: ^u8
+    indices: ^u32
+    vaoId: u32
+    vboId: [5]u32
+}
+export struct rlDrawCall
+{
+    mode: i32
+    vertexCount: i32
+    vertexAlignment: i32
+    textureId: u32
+}
+export struct rlDrawCall
+{
+    mode: i32
+    vertexCount: i32
+    vertexAlignment: i32
+    textureId: u32
+}
+export struct rlRenderBatch
+{
+    bufferCount: i32
+    currentBuffer: i32
+    vertexBuffer: ^rlVertexBuffer
+    draws: ^rlDrawCall
+    drawCounter: i32
+    currentDepth: f32
+}
+export struct rlRenderBatch
+{
+    bufferCount: i32
+    currentBuffer: i32
+    vertexBuffer: ^rlVertexBuffer
+    draws: ^rlDrawCall
+    drawCounter: i32
+    currentDepth: f32
+}
+export extern "rlMatrixMode" func rlMatrixMode(mode: i32): void
+export extern "rlPushMatrix" func rlPushMatrix(): void
+export extern "rlPopMatrix" func rlPopMatrix(): void
+export extern "rlLoadIdentity" func rlLoadIdentity(): void
+export extern "rlTranslatef" func rlTranslatef(x: f32, y: f32, z: f32): void
+export extern "rlRotatef" func rlRotatef(angle: f32, x: f32, y: f32, z: f32): void
+export extern "rlScalef" func rlScalef(x: f32, y: f32, z: f32): void
+export extern "rlMultMatrixf" func rlMultMatrixf(matf: ^f32): void
+export extern "rlFrustum" func rlFrustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void
+export extern "rlOrtho" func rlOrtho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64): void
+export extern "rlViewport" func rlViewport(x: i32, y: i32, width: i32, height: i32): void
+export extern "rlSetClipPlanes" func rlSetClipPlanes(nearPlane: f64, farPlane: f64): void
+export extern "rlGetCullDistanceNear" func rlGetCullDistanceNear(): f64
+export extern "rlGetCullDistanceFar" func rlGetCullDistanceFar(): f64
+export extern "rlBegin" func rlBegin(mode: i32): void
+export extern "rlEnd" func rlEnd(): void
+export extern "rlVertex2i" func rlVertex2i(x: i32, y: i32): void
+export extern "rlVertex2f" func rlVertex2f(x: f32, y: f32): void
+export extern "rlVertex3f" func rlVertex3f(x: f32, y: f32, z: f32): void
+export extern "rlTexCoord2f" func rlTexCoord2f(x: f32, y: f32): void
+export extern "rlNormal3f" func rlNormal3f(x: f32, y: f32, z: f32): void
+export extern "rlColor4ub" func rlColor4ub(r: u8, g: u8, b: u8, a: u8): void
+export extern "rlColor3f" func rlColor3f(x: f32, y: f32, z: f32): void
+export extern "rlColor4f" func rlColor4f(x: f32, y: f32, z: f32, w: f32): void
+export extern "rlEnableVertexArray" func rlEnableVertexArray(vaoId: u32): bool
+export extern "rlDisableVertexArray" func rlDisableVertexArray(): void
+export extern "rlEnableVertexBuffer" func rlEnableVertexBuffer(id: u32): void
+export extern "rlDisableVertexBuffer" func rlDisableVertexBuffer(): void
+export extern "rlEnableVertexBufferElement" func rlEnableVertexBufferElement(id: u32): void
+export extern "rlDisableVertexBufferElement" func rlDisableVertexBufferElement(): void
+export extern "rlEnableVertexAttribute" func rlEnableVertexAttribute(index: u32): void
+export extern "rlDisableVertexAttribute" func rlDisableVertexAttribute(index: u32): void
+export extern "rlActiveTextureSlot" func rlActiveTextureSlot(slot: i32): void
+export extern "rlEnableTexture" func rlEnableTexture(id: u32): void
+export extern "rlDisableTexture" func rlDisableTexture(): void
+export extern "rlEnableTextureCubemap" func rlEnableTextureCubemap(id: u32): void
+export extern "rlDisableTextureCubemap" func rlDisableTextureCubemap(): void
+export extern "rlTextureParameters" func rlTextureParameters(id: u32, param: i32, value: i32): void
+export extern "rlCubemapParameters" func rlCubemapParameters(id: u32, param: i32, value: i32): void
+export extern "rlEnableShader" func rlEnableShader(id: u32): void
+export extern "rlDisableShader" func rlDisableShader(): void
+export extern "rlEnableFramebuffer" func rlEnableFramebuffer(id: u32): void
+export extern "rlDisableFramebuffer" func rlDisableFramebuffer(): void
+export extern "rlGetActiveFramebuffer" func rlGetActiveFramebuffer(): u32
+export extern "rlActiveDrawBuffers" func rlActiveDrawBuffers(count: i32): void
+export extern "rlBlitFramebuffer" func rlBlitFramebuffer(srcX: i32, srcY: i32, srcWidth: i32, srcHeight: i32, dstX: i32, dstY: i32, dstWidth: i32, dstHeight: i32, bufferMask: i32): void
+export extern "rlBindFramebuffer" func rlBindFramebuffer(target: u32, framebuffer: u32): void
+export extern "rlEnableColorBlend" func rlEnableColorBlend(): void
+export extern "rlDisableColorBlend" func rlDisableColorBlend(): void
+export extern "rlEnableDepthTest" func rlEnableDepthTest(): void
+export extern "rlDisableDepthTest" func rlDisableDepthTest(): void
+export extern "rlEnableDepthMask" func rlEnableDepthMask(): void
+export extern "rlDisableDepthMask" func rlDisableDepthMask(): void
+export extern "rlEnableBackfaceCulling" func rlEnableBackfaceCulling(): void
+export extern "rlDisableBackfaceCulling" func rlDisableBackfaceCulling(): void
+export extern "rlColorMask" func rlColorMask(r: bool, g: bool, b: bool, a: bool): void
+export extern "rlSetCullFace" func rlSetCullFace(mode: i32): void
+export extern "rlEnableScissorTest" func rlEnableScissorTest(): void
+export extern "rlDisableScissorTest" func rlDisableScissorTest(): void
+export extern "rlScissor" func rlScissor(x: i32, y: i32, width: i32, height: i32): void
+export extern "rlEnableWireMode" func rlEnableWireMode(): void
+export extern "rlEnablePointMode" func rlEnablePointMode(): void
+export extern "rlDisableWireMode" func rlDisableWireMode(): void
+export extern "rlSetLineWidth" func rlSetLineWidth(width: f32): void
+export extern "rlGetLineWidth" func rlGetLineWidth(): f32
+export extern "rlEnableSmoothLines" func rlEnableSmoothLines(): void
+export extern "rlDisableSmoothLines" func rlDisableSmoothLines(): void
+export extern "rlEnableStereoRender" func rlEnableStereoRender(): void
+export extern "rlDisableStereoRender" func rlDisableStereoRender(): void
+export extern "rlIsStereoRenderEnabled" func rlIsStereoRenderEnabled(): bool
+export extern "rlClearColor" func rlClearColor(r: u8, g: u8, b: u8, a: u8): void
+export extern "rlClearScreenBuffers" func rlClearScreenBuffers(): void
+export extern "rlCheckErrors" func rlCheckErrors(): void
+export extern "rlSetBlendMode" func rlSetBlendMode(mode: i32): void
+export extern "rlSetBlendFactors" func rlSetBlendFactors(glSrcFactor: i32, glDstFactor: i32, glEquation: i32): void
+export extern "rlSetBlendFactorsSeparate" func rlSetBlendFactorsSeparate(glSrcRGB: i32, glDstRGB: i32, glSrcAlpha: i32, glDstAlpha: i32, glEqRGB: i32, glEqAlpha: i32): void
+export extern "rlglInit" func rlglInit(width: i32, height: i32): void
+export extern "rlglClose" func rlglClose(): void
+export extern "rlLoadExtensions" func rlLoadExtensions(loader: ^void): void
+export extern "rlGetVersion" func rlGetVersion(): i32
+export extern "rlSetFramebufferWidth" func rlSetFramebufferWidth(width: i32): void
+export extern "rlGetFramebufferWidth" func rlGetFramebufferWidth(): i32
+export extern "rlSetFramebufferHeight" func rlSetFramebufferHeight(height: i32): void
+export extern "rlGetFramebufferHeight" func rlGetFramebufferHeight(): i32
+export extern "rlGetTextureIdDefault" func rlGetTextureIdDefault(): u32
+export extern "rlGetShaderIdDefault" func rlGetShaderIdDefault(): u32
+export extern "rlGetShaderLocsDefault" func rlGetShaderLocsDefault(): ^i32
+export extern "rlLoadRenderBatch" func rlLoadRenderBatch(numBuffers: i32, bufferElements: i32): rlRenderBatch
+export extern "rlUnloadRenderBatch" func rlUnloadRenderBatch(batch: rlRenderBatch): void
+export extern "rlDrawRenderBatch" func rlDrawRenderBatch(batch: ^rlRenderBatch): void
+export extern "rlSetRenderBatchActive" func rlSetRenderBatchActive(batch: ^rlRenderBatch): void
+export extern "rlDrawRenderBatchActive" func rlDrawRenderBatchActive(): void
+export extern "rlCheckRenderBatchLimit" func rlCheckRenderBatchLimit(vCount: i32): bool
+export extern "rlSetTexture" func rlSetTexture(id: u32): void
+export extern "rlLoadVertexArray" func rlLoadVertexArray(): u32
+export extern "rlLoadVertexBuffer" func rlLoadVertexBuffer(buffer: ^void, size: i32, dynamic: bool): u32
+export extern "rlLoadVertexBufferElement" func rlLoadVertexBufferElement(buffer: ^void, size: i32, dynamic: bool): u32
+export extern "rlUpdateVertexBuffer" func rlUpdateVertexBuffer(bufferId: u32, data: ^void, dataSize: i32, offset: i32): void
+export extern "rlUpdateVertexBufferElements" func rlUpdateVertexBufferElements(id: u32, data: ^void, dataSize: i32, offset: i32): void
+export extern "rlUnloadVertexArray" func rlUnloadVertexArray(vaoId: u32): void
+export extern "rlUnloadVertexBuffer" func rlUnloadVertexBuffer(vboId: u32): void
+export extern "rlSetVertexAttribute" func rlSetVertexAttribute(index: u32, compSize: i32, type: i32, normalized: bool, stride: i32, offset: i32): void
+export extern "rlSetVertexAttributeDivisor" func rlSetVertexAttributeDivisor(index: u32, divisor: i32): void
+export extern "rlSetVertexAttributeDefault" func rlSetVertexAttributeDefault(locIndex: i32, value: ^void, attribType: i32, count: i32): void
+export extern "rlDrawVertexArray" func rlDrawVertexArray(offset: i32, count: i32): void
+export extern "rlDrawVertexArrayElements" func rlDrawVertexArrayElements(offset: i32, count: i32, buffer: ^void): void
+export extern "rlDrawVertexArrayInstanced" func rlDrawVertexArrayInstanced(offset: i32, count: i32, instances: i32): void
+export extern "rlDrawVertexArrayElementsInstanced" func rlDrawVertexArrayElementsInstanced(offset: i32, count: i32, buffer: ^void, instances: i32): void
+export extern "rlLoadTexture" func rlLoadTexture(data: ^void, width: i32, height: i32, format: i32, mipmapCount: i32): u32
+export extern "rlLoadTextureDepth" func rlLoadTextureDepth(width: i32, height: i32, useRenderBuffer: bool): u32
+export extern "rlLoadTextureCubemap" func rlLoadTextureCubemap(data: ^void, size: i32, format: i32, mipmapCount: i32): u32
+export extern "rlUpdateTexture" func rlUpdateTexture(id: u32, offsetX: i32, offsetY: i32, width: i32, height: i32, format: i32, data: ^void): void
+export extern "rlGetGlTextureFormats" func rlGetGlTextureFormats(format: i32, glInternalFormat: ^u32, glFormat: ^u32, glType: ^u32): void
+export extern "rlGetPixelFormatName" func rlGetPixelFormatName(format: u32): cstring
+export extern "rlUnloadTexture" func rlUnloadTexture(id: u32): void
+export extern "rlGenTextureMipmaps" func rlGenTextureMipmaps(id: u32, width: i32, height: i32, format: i32, mipmaps: ^i32): void
+export extern "rlReadTexturePixels" func rlReadTexturePixels(id: u32, width: i32, height: i32, format: i32): ^void
+export extern "rlReadScreenPixels" func rlReadScreenPixels(width: i32, height: i32): ^u8
+export extern "rlLoadFramebuffer" func rlLoadFramebuffer(): u32
+export extern "rlFramebufferAttach" func rlFramebufferAttach(fboId: u32, texId: u32, attachType: i32, texType: i32, mipLevel: i32): void
+export extern "rlFramebufferComplete" func rlFramebufferComplete(id: u32): bool
+export extern "rlUnloadFramebuffer" func rlUnloadFramebuffer(id: u32): void
+export extern "rlLoadShaderCode" func rlLoadShaderCode(vsCode: cstring, fsCode: cstring): u32
+export extern "rlCompileShader" func rlCompileShader(shaderCode: cstring, type: i32): u32
+export extern "rlLoadShaderProgram" func rlLoadShaderProgram(vShaderId: u32, fShaderId: u32): u32
+export extern "rlUnloadShaderProgram" func rlUnloadShaderProgram(id: u32): void
+export extern "rlGetLocationUniform" func rlGetLocationUniform(shaderId: u32, uniformName: cstring): i32
+export extern "rlGetLocationAttrib" func rlGetLocationAttrib(shaderId: u32, attribName: cstring): i32
+export extern "rlSetUniform" func rlSetUniform(locIndex: i32, value: ^void, uniformType: i32, count: i32): void
+export extern "rlSetUniformMatrix" func rlSetUniformMatrix(locIndex: i32, mat: Matrix): void
+export extern "rlSetUniformMatrices" func rlSetUniformMatrices(locIndex: i32, mat: ^Matrix, count: i32): void
+export extern "rlSetUniformSampler" func rlSetUniformSampler(locIndex: i32, textureId: u32): void
+export extern "rlSetShader" func rlSetShader(id: u32, locs: ^i32): void
+export extern "rlLoadComputeShaderProgram" func rlLoadComputeShaderProgram(shaderId: u32): u32
+export extern "rlComputeShaderDispatch" func rlComputeShaderDispatch(groupX: u32, groupY: u32, groupZ: u32): void
+export extern "rlLoadShaderBuffer" func rlLoadShaderBuffer(size: u32, data: ^void, usageHint: i32): u32
+export extern "rlUnloadShaderBuffer" func rlUnloadShaderBuffer(ssboId: u32): void
+export extern "rlUpdateShaderBuffer" func rlUpdateShaderBuffer(id: u32, data: ^void, dataSize: u32, offset: u32): void
+export extern "rlBindShaderBuffer" func rlBindShaderBuffer(id: u32, index: u32): void
+export extern "rlReadShaderBuffer" func rlReadShaderBuffer(id: u32, dest: ^void, count: u32, offset: u32): void
+export extern "rlCopyShaderBuffer" func rlCopyShaderBuffer(destId: u32, srcId: u32, destOffset: u32, srcOffset: u32, count: u32): void
+export extern "rlGetShaderBufferSize" func rlGetShaderBufferSize(id: u32): u32
+export extern "rlBindImageTexture" func rlBindImageTexture(id: u32, index: u32, format: i32, readonly: bool): void
+export extern "rlGetMatrixModelview" func rlGetMatrixModelview(): Matrix
+export extern "rlGetMatrixProjection" func rlGetMatrixProjection(): Matrix
+export extern "rlGetMatrixTransform" func rlGetMatrixTransform(): Matrix
+export extern "rlGetMatrixProjectionStereo" func rlGetMatrixProjectionStereo(eye: i32): Matrix
+export extern "rlGetMatrixViewOffsetStereo" func rlGetMatrixViewOffsetStereo(eye: i32): Matrix
+export extern "rlSetMatrixProjection" func rlSetMatrixProjection(proj: Matrix): void
+export extern "rlSetMatrixModelview" func rlSetMatrixModelview(view: Matrix): void
+export extern "rlSetMatrixProjectionStereo" func rlSetMatrixProjectionStereo(right: Matrix, left: Matrix): void
+export extern "rlSetMatrixViewOffsetStereo" func rlSetMatrixViewOffsetStereo(right: Matrix, left: Matrix): void
+export extern "rlLoadDrawCube" func rlLoadDrawCube(): void
+export extern "rlLoadDrawQuad" func rlLoadDrawQuad(): void
--- a/examples/raylib/makefile
+++ b/examples/raylib/makefile
@@ -3,11 +3,8 @@ NUBC = ../../compiler/NubLang.CLI/bin/Debug/net9.0/nubc
 out: .build/out.o
 	gcc -nostartfiles -lm -o out x86_64.s .build/out.o raylib-5.5_linux_amd64/lib/libraylib.a

-.build/out.o: $(NUBC) main.nub raylib.nub
-	$(NUBC) main.nub raylib.nub
-
-raylib.nub:
-	python3 generate.py raylib-5.5_linux_amd64/include/raylib.h > raylib.nub
+.build/out.o: $(NUBC) main.nub generated/raylib.nub
+	$(NUBC) main.nub generated/raylib.nub

 .PHONY: $(NUBC)
 $(NUBC):