@gtkx/ffi 0.1.16 → 0.1.18

package/dist/cairo/cairo.d.ts

@@ -0,0 +1,30 @@
+export declare function moveTo(cr: unknown, x: number, y: number): void;
+export declare function lineTo(cr: unknown, x: number, y: number): void;
+export declare function curveTo(cr: unknown, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+export declare function arc(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+export declare function arcNegative(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+export declare function rectangle(cr: unknown, x: number, y: number, width: number, height: number): void;
+export declare function closePath(cr: unknown): void;
+export declare function newPath(cr: unknown): void;
+export declare function newSubPath(cr: unknown): void;
+export declare function stroke(cr: unknown): void;
+export declare function strokePreserve(cr: unknown): void;
+export declare function fill(cr: unknown): void;
+export declare function fillPreserve(cr: unknown): void;
+export declare function paint(cr: unknown): void;
+export declare function paintWithAlpha(cr: unknown, alpha: number): void;
+export declare function setSourceRgb(cr: unknown, red: number, green: number, blue: number): void;
+export declare function setSourceRgba(cr: unknown, red: number, green: number, blue: number, alpha: number): void;
+export declare function setLineWidth(cr: unknown, width: number): void;
+export declare function setLineCap(cr: unknown, lineCap: number): void;
+export declare function setLineJoin(cr: unknown, lineJoin: number): void;
+export declare function setDash(cr: unknown, dashes: number[], offset: number): void;
+export declare function save(cr: unknown): void;
+export declare function restore(cr: unknown): void;
+export declare function translate(cr: unknown, tx: number, ty: number): void;
+export declare function scale(cr: unknown, sx: number, sy: number): void;
+export declare function rotate(cr: unknown, angle: number): void;
+export declare function clip(cr: unknown): void;
+export declare function clipPreserve(cr: unknown): void;
+export declare function resetClip(cr: unknown): void;
+export declare function setOperator(cr: unknown, op: number): void;

package/dist/cairo/cairo.js

@@ -0,0 +1,171 @@
+import { call } from "@gtkx/native";
+const LIB = "libcairo.so.2";
+const CAIRO_T = { type: "int", size: 64, unsigned: true };
+export function moveTo(cr, x, y) {
+    call(LIB, "cairo_move_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+    ], { type: "undefined" });
+}
+export function lineTo(cr, x, y) {
+    call(LIB, "cairo_line_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+    ], { type: "undefined" });
+}
+export function curveTo(cr, x1, y1, x2, y2, x3, y3) {
+    call(LIB, "cairo_curve_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x1 },
+        { type: { type: "float", size: 64 }, value: y1 },
+        { type: { type: "float", size: 64 }, value: x2 },
+        { type: { type: "float", size: 64 }, value: y2 },
+        { type: { type: "float", size: 64 }, value: x3 },
+        { type: { type: "float", size: 64 }, value: y3 },
+    ], { type: "undefined" });
+}
+export function arc(cr, xc, yc, radius, angle1, angle2) {
+    call(LIB, "cairo_arc", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: xc },
+        { type: { type: "float", size: 64 }, value: yc },
+        { type: { type: "float", size: 64 }, value: radius },
+        { type: { type: "float", size: 64 }, value: angle1 },
+        { type: { type: "float", size: 64 }, value: angle2 },
+    ], { type: "undefined" });
+}
+export function arcNegative(cr, xc, yc, radius, angle1, angle2) {
+    call(LIB, "cairo_arc_negative", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: xc },
+        { type: { type: "float", size: 64 }, value: yc },
+        { type: { type: "float", size: 64 }, value: radius },
+        { type: { type: "float", size: 64 }, value: angle1 },
+        { type: { type: "float", size: 64 }, value: angle2 },
+    ], { type: "undefined" });
+}
+export function rectangle(cr, x, y, width, height) {
+    call(LIB, "cairo_rectangle", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+        { type: { type: "float", size: 64 }, value: width },
+        { type: { type: "float", size: 64 }, value: height },
+    ], { type: "undefined" });
+}
+export function closePath(cr) {
+    call(LIB, "cairo_close_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function newPath(cr) {
+    call(LIB, "cairo_new_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function newSubPath(cr) {
+    call(LIB, "cairo_new_sub_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function stroke(cr) {
+    call(LIB, "cairo_stroke", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function strokePreserve(cr) {
+    call(LIB, "cairo_stroke_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function fill(cr) {
+    call(LIB, "cairo_fill", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function fillPreserve(cr) {
+    call(LIB, "cairo_fill_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function paint(cr) {
+    call(LIB, "cairo_paint", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function paintWithAlpha(cr, alpha) {
+    call(LIB, "cairo_paint_with_alpha", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: alpha },
+    ], { type: "undefined" });
+}
+export function setSourceRgb(cr, red, green, blue) {
+    call(LIB, "cairo_set_source_rgb", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: red },
+        { type: { type: "float", size: 64 }, value: green },
+        { type: { type: "float", size: 64 }, value: blue },
+    ], { type: "undefined" });
+}
+export function setSourceRgba(cr, red, green, blue, alpha) {
+    call(LIB, "cairo_set_source_rgba", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: red },
+        { type: { type: "float", size: 64 }, value: green },
+        { type: { type: "float", size: 64 }, value: blue },
+        { type: { type: "float", size: 64 }, value: alpha },
+    ], { type: "undefined" });
+}
+export function setLineWidth(cr, width) {
+    call(LIB, "cairo_set_line_width", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: width },
+    ], { type: "undefined" });
+}
+export function setLineCap(cr, lineCap) {
+    call(LIB, "cairo_set_line_cap", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: lineCap },
+    ], { type: "undefined" });
+}
+export function setLineJoin(cr, lineJoin) {
+    call(LIB, "cairo_set_line_join", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: lineJoin },
+    ], { type: "undefined" });
+}
+export function setDash(cr, dashes, offset) {
+    call(LIB, "cairo_set_dash", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "array", itemType: { type: "float", size: 64 } }, value: dashes },
+        { type: { type: "int", size: 32, unsigned: false }, value: dashes.length },
+        { type: { type: "float", size: 64 }, value: offset },
+    ], { type: "undefined" });
+}
+export function save(cr) {
+    call(LIB, "cairo_save", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function restore(cr) {
+    call(LIB, "cairo_restore", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function translate(cr, tx, ty) {
+    call(LIB, "cairo_translate", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: tx },
+        { type: { type: "float", size: 64 }, value: ty },
+    ], { type: "undefined" });
+}
+export function scale(cr, sx, sy) {
+    call(LIB, "cairo_scale", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: sx },
+        { type: { type: "float", size: 64 }, value: sy },
+    ], { type: "undefined" });
+}
+export function rotate(cr, angle) {
+    call(LIB, "cairo_rotate", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: angle },
+    ], { type: "undefined" });
+}
+export function clip(cr) {
+    call(LIB, "cairo_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function clipPreserve(cr) {
+    call(LIB, "cairo_clip_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function resetClip(cr) {
+    call(LIB, "cairo_reset_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function setOperator(cr, op) {
+    call(LIB, "cairo_set_operator", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: op },
+    ], { type: "undefined" });
+}

package/dist/cairo/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../generated/cairo/index.js";
+export * from "./cairo.js";

package/dist/cairo/index.js

@@ -0,0 +1,2 @@
+export * from "../generated/cairo/index.js";
+export * from "./cairo.js";

package/dist/codegen/ffi-generator.js

@@ -1771,6 +1771,10 @@ ${indent}  }`;
             if (type.trampoline) {
                 parts.push(`trampoline: "${type.trampoline}"`);
             }
+            if (type.argTypes) {
+                const argTypesStr = type.argTypes.map((t) => this.generateTypeDescriptor(t)).join(", ");
+                parts.push(`argTypes: [${argTypesStr}]`);
+            }
             if (type.sourceType) {
                 parts.push(`sourceType: ${this.generateTypeDescriptor(type.sourceType)}`);
             }

package/dist/generated/gtk/drawing-area.d.ts

@@ -7,7 +7,7 @@ export declare class DrawingArea extends Widget {
     getContentWidth(): number;
     setContentHeight(height: number): void;
     setContentWidth(width: number): void;
-    setDrawFunc(destroy: () => void, drawFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    setDrawFunc(drawFunc?: (self: unknown, cr: unknown, width: number, height: number) => void | null): void;
     connect(signal: "resize", handler: (self: DrawingArea, width: number, height: number) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: DrawingArea, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/drawing-area.js

@@ -57,24 +57,25 @@ export class DrawingArea extends Widget {
             },
         ], { type: "undefined" });
     }
-    setDrawFunc(destroy, drawFunc, userData) {
+    setDrawFunc(drawFunc) {
         call("libgtk-4.so.1", "gtk_drawing_area_set_draw_func", [
             {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
             {
-                type: { type: "callback" },
+                type: {
+                    type: "callback",
+                    trampoline: "drawFunc",
+                    argTypes: [
+                        { type: "gobject", borrowed: true },
+                        { type: "int", size: 64, unsigned: true },
+                        { type: "int", size: 32, unsigned: false },
+                        { type: "int", size: 32, unsigned: false },
+                    ],
+                },
                 value: drawFunc,
             },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: destroy,
-            },
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {

package/dist/gl/constants.d.ts

@@ -0,0 +1,45 @@
+export declare const GL_DEPTH_BUFFER_BIT = 256;
+export declare const GL_STENCIL_BUFFER_BIT = 1024;
+export declare const GL_COLOR_BUFFER_BIT = 16384;
+export declare const GL_POINTS = 0;
+export declare const GL_LINES = 1;
+export declare const GL_LINE_LOOP = 2;
+export declare const GL_LINE_STRIP = 3;
+export declare const GL_TRIANGLES = 4;
+export declare const GL_TRIANGLE_STRIP = 5;
+export declare const GL_TRIANGLE_FAN = 6;
+export declare const GL_FRAGMENT_SHADER = 35632;
+export declare const GL_VERTEX_SHADER = 35633;
+export declare const GL_COMPILE_STATUS = 35713;
+export declare const GL_LINK_STATUS = 35714;
+export declare const GL_INFO_LOG_LENGTH = 35716;
+export declare const GL_ARRAY_BUFFER = 34962;
+export declare const GL_ELEMENT_ARRAY_BUFFER = 34963;
+export declare const GL_STREAM_DRAW = 35040;
+export declare const GL_STATIC_DRAW = 35044;
+export declare const GL_DYNAMIC_DRAW = 35048;
+export declare const GL_BYTE = 5120;
+export declare const GL_UNSIGNED_BYTE = 5121;
+export declare const GL_SHORT = 5122;
+export declare const GL_UNSIGNED_SHORT = 5123;
+export declare const GL_INT = 5124;
+export declare const GL_UNSIGNED_INT = 5125;
+export declare const GL_FLOAT = 5126;
+export declare const GL_CULL_FACE = 2884;
+export declare const GL_DEPTH_TEST = 2929;
+export declare const GL_BLEND = 3042;
+export declare const GL_FALSE = 0;
+export declare const GL_TRUE = 1;
+export declare const GL_NO_ERROR = 0;
+export declare const GL_INVALID_ENUM = 1280;
+export declare const GL_INVALID_VALUE = 1281;
+export declare const GL_INVALID_OPERATION = 1282;
+export declare const GL_OUT_OF_MEMORY = 1285;
+export declare const GL_SRC_ALPHA = 770;
+export declare const GL_ONE_MINUS_SRC_ALPHA = 771;
+export declare const GL_FRONT = 1028;
+export declare const GL_BACK = 1029;
+export declare const GL_FRONT_AND_BACK = 1032;
+export declare const GL_LESS = 513;
+export declare const GL_LEQUAL = 515;
+export declare const GL_FRAMEBUFFER_BINDING = 36006;

package/dist/gl/constants.js

@@ -0,0 +1,45 @@
+export const GL_DEPTH_BUFFER_BIT = 0x00000100;
+export const GL_STENCIL_BUFFER_BIT = 0x00000400;
+export const GL_COLOR_BUFFER_BIT = 0x00004000;
+export const GL_POINTS = 0x0000;
+export const GL_LINES = 0x0001;
+export const GL_LINE_LOOP = 0x0002;
+export const GL_LINE_STRIP = 0x0003;
+export const GL_TRIANGLES = 0x0004;
+export const GL_TRIANGLE_STRIP = 0x0005;
+export const GL_TRIANGLE_FAN = 0x0006;
+export const GL_FRAGMENT_SHADER = 0x8b30;
+export const GL_VERTEX_SHADER = 0x8b31;
+export const GL_COMPILE_STATUS = 0x8b81;
+export const GL_LINK_STATUS = 0x8b82;
+export const GL_INFO_LOG_LENGTH = 0x8b84;
+export const GL_ARRAY_BUFFER = 0x8892;
+export const GL_ELEMENT_ARRAY_BUFFER = 0x8893;
+export const GL_STREAM_DRAW = 0x88e0;
+export const GL_STATIC_DRAW = 0x88e4;
+export const GL_DYNAMIC_DRAW = 0x88e8;
+export const GL_BYTE = 0x1400;
+export const GL_UNSIGNED_BYTE = 0x1401;
+export const GL_SHORT = 0x1402;
+export const GL_UNSIGNED_SHORT = 0x1403;
+export const GL_INT = 0x1404;
+export const GL_UNSIGNED_INT = 0x1405;
+export const GL_FLOAT = 0x1406;
+export const GL_CULL_FACE = 0x0b44;
+export const GL_DEPTH_TEST = 0x0b71;
+export const GL_BLEND = 0x0be2;
+export const GL_FALSE = 0;
+export const GL_TRUE = 1;
+export const GL_NO_ERROR = 0;
+export const GL_INVALID_ENUM = 0x0500;
+export const GL_INVALID_VALUE = 0x0501;
+export const GL_INVALID_OPERATION = 0x0502;
+export const GL_OUT_OF_MEMORY = 0x0505;
+export const GL_SRC_ALPHA = 0x0302;
+export const GL_ONE_MINUS_SRC_ALPHA = 0x0303;
+export const GL_FRONT = 0x0404;
+export const GL_BACK = 0x0405;
+export const GL_FRONT_AND_BACK = 0x0408;
+export const GL_LESS = 0x0201;
+export const GL_LEQUAL = 0x0203;
+export const GL_FRAMEBUFFER_BINDING = 0x8ca6;

package/dist/gl/gl.d.ts

@@ -0,0 +1,42 @@
+export declare function glClear(mask: number): void;
+export declare function glClearColor(red: number, green: number, blue: number, alpha: number): void;
+export declare function glViewport(x: number, y: number, width: number, height: number): void;
+export declare function glEnable(cap: number): void;
+export declare function glDisable(cap: number): void;
+export declare function glClearDepth(depth: number): void;
+export declare function glDepthFunc(func: number): void;
+export declare function glCreateShader(type: number): number;
+export declare function glShaderSource(shader: number, source: string): void;
+export declare function glCompileShader(shader: number): void;
+export declare function glGetShaderiv(shader: number, pname: number): number;
+export declare function glGetShaderInfoLog(shader: number, _maxLength: number): string;
+export declare function glDeleteShader(shader: number): void;
+export declare function glCreateProgram(): number;
+export declare function glAttachShader(program: number, shader: number): void;
+export declare function glLinkProgram(program: number): void;
+export declare function glUseProgram(program: number): void;
+export declare function glGetProgramiv(program: number, pname: number): number;
+export declare function glGetProgramInfoLog(program: number, _maxLength: number): string;
+export declare function glDeleteProgram(program: number): void;
+export declare function glGetUniformLocation(program: number, name: string): number;
+export declare function glUniform1f(location: number, v0: number): void;
+export declare function glUniform2f(location: number, v0: number, v1: number): void;
+export declare function glUniform3f(location: number, v0: number, v1: number, v2: number): void;
+export declare function glUniform4f(location: number, v0: number, v1: number, v2: number, v3: number): void;
+export declare function glUniform1i(location: number, v0: number): void;
+export declare function glUniformMatrix4fv(location: number, count: number, transpose: boolean, value: number[]): void;
+export declare function glGenVertexArray(): number;
+export declare function glBindVertexArray(array: number): void;
+export declare function glDeleteVertexArray(array: number): void;
+export declare function glGenBuffer(): number;
+export declare function glBindBuffer(target: number, buffer: number): void;
+export declare function glDeleteBuffer(buffer: number): void;
+export declare function glBufferData(target: number, data: number[], usage: number): void;
+export declare function glVertexAttribPointer(index: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void;
+export declare function glEnableVertexAttribArray(index: number): void;
+export declare function glDisableVertexAttribArray(index: number): void;
+export declare function glDrawArrays(mode: number, first: number, count: number): void;
+export declare function glDrawElements(mode: number, count: number, type: number, offset: number): void;
+export declare function glGetAttribLocation(program: number, name: string): number;
+export declare function glBindAttribLocation(program: number, index: number, name: string): void;
+export declare function glGetError(): number;

package/dist/gl/gl.js

@@ -0,0 +1,263 @@
+import { call, createRef } from "@gtkx/native";
+const LIB = "libGL.so.1";
+export function glClear(mask) {
+    call(LIB, "glClear", [{ type: { type: "int", size: 32, unsigned: true }, value: mask }], { type: "undefined" });
+}
+export function glClearColor(red, green, blue, alpha) {
+    call(LIB, "glClearColor", [
+        { type: { type: "float", size: 32 }, value: red },
+        { type: { type: "float", size: 32 }, value: green },
+        { type: { type: "float", size: 32 }, value: blue },
+        { type: { type: "float", size: 32 }, value: alpha },
+    ], { type: "undefined" });
+}
+export function glViewport(x, y, width, height) {
+    call(LIB, "glViewport", [
+        { type: { type: "int", size: 32, unsigned: false }, value: x },
+        { type: { type: "int", size: 32, unsigned: false }, value: y },
+        { type: { type: "int", size: 32, unsigned: false }, value: width },
+        { type: { type: "int", size: 32, unsigned: false }, value: height },
+    ], { type: "undefined" });
+}
+export function glEnable(cap) {
+    call(LIB, "glEnable", [{ type: { type: "int", size: 32, unsigned: true }, value: cap }], { type: "undefined" });
+}
+export function glDisable(cap) {
+    call(LIB, "glDisable", [{ type: { type: "int", size: 32, unsigned: true }, value: cap }], { type: "undefined" });
+}
+export function glClearDepth(depth) {
+    call(LIB, "glClearDepth", [{ type: { type: "float", size: 64 }, value: depth }], { type: "undefined" });
+}
+export function glDepthFunc(func) {
+    call(LIB, "glDepthFunc", [{ type: { type: "int", size: 32, unsigned: true }, value: func }], { type: "undefined" });
+}
+export function glCreateShader(type) {
+    return call(LIB, "glCreateShader", [{ type: { type: "int", size: 32, unsigned: true }, value: type }], {
+        type: "int",
+        size: 32,
+        unsigned: true,
+    });
+}
+export function glShaderSource(shader, source) {
+    call(LIB, "glShaderSource", [
+        { type: { type: "int", size: 32, unsigned: true }, value: shader },
+        { type: { type: "int", size: 32, unsigned: false }, value: 1 },
+        { type: { type: "array", itemType: { type: "string" } }, value: [source] },
+        { type: { type: "int", size: 64, unsigned: true }, value: 0 },
+    ], { type: "undefined" });
+}
+export function glCompileShader(shader) {
+    call(LIB, "glCompileShader", [{ type: { type: "int", size: 32, unsigned: true }, value: shader }], {
+        type: "undefined",
+    });
+}
+export function glGetShaderiv(shader, pname) {
+    const params = createRef(0);
+    call(LIB, "glGetShaderiv", [
+        { type: { type: "int", size: 32, unsigned: true }, value: shader },
+        { type: { type: "int", size: 32, unsigned: true }, value: pname },
+        { type: { type: "ref", innerType: { type: "int", size: 32, unsigned: false } }, value: params },
+    ], { type: "undefined" });
+    return params.value;
+}
+export function glGetShaderInfoLog(shader, _maxLength) {
+    const logLength = glGetShaderiv(shader, 0x8b84);
+    if (logLength <= 0) {
+        return "";
+    }
+    return `Shader info log length: ${logLength} (use console.error for details)`;
+}
+export function glDeleteShader(shader) {
+    call(LIB, "glDeleteShader", [{ type: { type: "int", size: 32, unsigned: true }, value: shader }], {
+        type: "undefined",
+    });
+}
+export function glCreateProgram() {
+    return call(LIB, "glCreateProgram", [], { type: "int", size: 32, unsigned: true });
+}
+export function glAttachShader(program, shader) {
+    call(LIB, "glAttachShader", [
+        { type: { type: "int", size: 32, unsigned: true }, value: program },
+        { type: { type: "int", size: 32, unsigned: true }, value: shader },
+    ], { type: "undefined" });
+}
+export function glLinkProgram(program) {
+    call(LIB, "glLinkProgram", [{ type: { type: "int", size: 32, unsigned: true }, value: program }], {
+        type: "undefined",
+    });
+}
+export function glUseProgram(program) {
+    call(LIB, "glUseProgram", [{ type: { type: "int", size: 32, unsigned: true }, value: program }], {
+        type: "undefined",
+    });
+}
+export function glGetProgramiv(program, pname) {
+    const params = createRef(0);
+    call(LIB, "glGetProgramiv", [
+        { type: { type: "int", size: 32, unsigned: true }, value: program },
+        { type: { type: "int", size: 32, unsigned: true }, value: pname },
+        { type: { type: "ref", innerType: { type: "int", size: 32, unsigned: false } }, value: params },
+    ], { type: "undefined" });
+    return params.value;
+}
+export function glGetProgramInfoLog(program, _maxLength) {
+    const logLength = glGetProgramiv(program, 0x8b84);
+    if (logLength <= 0) {
+        return "";
+    }
+    return `Program info log length: ${logLength} (use console.error for details)`;
+}
+export function glDeleteProgram(program) {
+    call(LIB, "glDeleteProgram", [{ type: { type: "int", size: 32, unsigned: true }, value: program }], {
+        type: "undefined",
+    });
+}
+export function glGetUniformLocation(program, name) {
+    return call(LIB, "glGetUniformLocation", [
+        { type: { type: "int", size: 32, unsigned: true }, value: program },
+        { type: { type: "string" }, value: name },
+    ], { type: "int", size: 32, unsigned: false });
+}
+export function glUniform1f(location, v0) {
+    call(LIB, "glUniform1f", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "float", size: 32 }, value: v0 },
+    ], { type: "undefined" });
+}
+export function glUniform2f(location, v0, v1) {
+    call(LIB, "glUniform2f", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "float", size: 32 }, value: v0 },
+        { type: { type: "float", size: 32 }, value: v1 },
+    ], { type: "undefined" });
+}
+export function glUniform3f(location, v0, v1, v2) {
+    call(LIB, "glUniform3f", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "float", size: 32 }, value: v0 },
+        { type: { type: "float", size: 32 }, value: v1 },
+        { type: { type: "float", size: 32 }, value: v2 },
+    ], { type: "undefined" });
+}
+export function glUniform4f(location, v0, v1, v2, v3) {
+    call(LIB, "glUniform4f", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "float", size: 32 }, value: v0 },
+        { type: { type: "float", size: 32 }, value: v1 },
+        { type: { type: "float", size: 32 }, value: v2 },
+        { type: { type: "float", size: 32 }, value: v3 },
+    ], { type: "undefined" });
+}
+export function glUniform1i(location, v0) {
+    call(LIB, "glUniform1i", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "int", size: 32, unsigned: false }, value: v0 },
+    ], { type: "undefined" });
+}
+export function glUniformMatrix4fv(location, count, transpose, value) {
+    call(LIB, "glUniformMatrix4fv", [
+        { type: { type: "int", size: 32, unsigned: false }, value: location },
+        { type: { type: "int", size: 32, unsigned: false }, value: count },
+        { type: { type: "boolean" }, value: transpose },
+        { type: { type: "array", itemType: { type: "float", size: 32 } }, value },
+    ], { type: "undefined" });
+}
+export function glGenVertexArray() {
+    const array = createRef(0);
+    call(LIB, "glGenVertexArrays", [
+        { type: { type: "int", size: 32, unsigned: false }, value: 1 },
+        { type: { type: "ref", innerType: { type: "int", size: 32, unsigned: true } }, value: array },
+    ], { type: "undefined" });
+    return array.value;
+}
+export function glBindVertexArray(array) {
+    call(LIB, "glBindVertexArray", [{ type: { type: "int", size: 32, unsigned: true }, value: array }], {
+        type: "undefined",
+    });
+}
+export function glDeleteVertexArray(array) {
+    call(LIB, "glDeleteVertexArrays", [
+        { type: { type: "int", size: 32, unsigned: false }, value: 1 },
+        { type: { type: "array", itemType: { type: "int", size: 32, unsigned: true } }, value: [array] },
+    ], { type: "undefined" });
+}
+export function glGenBuffer() {
+    const buffer = createRef(0);
+    call(LIB, "glGenBuffers", [
+        { type: { type: "int", size: 32, unsigned: false }, value: 1 },
+        { type: { type: "ref", innerType: { type: "int", size: 32, unsigned: true } }, value: buffer },
+    ], { type: "undefined" });
+    return buffer.value;
+}
+export function glBindBuffer(target, buffer) {
+    call(LIB, "glBindBuffer", [
+        { type: { type: "int", size: 32, unsigned: true }, value: target },
+        { type: { type: "int", size: 32, unsigned: true }, value: buffer },
+    ], { type: "undefined" });
+}
+export function glDeleteBuffer(buffer) {
+    call(LIB, "glDeleteBuffers", [
+        { type: { type: "int", size: 32, unsigned: false }, value: 1 },
+        { type: { type: "array", itemType: { type: "int", size: 32, unsigned: true } }, value: [buffer] },
+    ], { type: "undefined" });
+}
+export function glBufferData(target, data, usage) {
+    const size = data.length * 4;
+    call(LIB, "glBufferData", [
+        { type: { type: "int", size: 32, unsigned: true }, value: target },
+        { type: { type: "int", size: 64, unsigned: false }, value: size },
+        { type: { type: "array", itemType: { type: "float", size: 32 } }, value: data },
+        { type: { type: "int", size: 32, unsigned: true }, value: usage },
+    ], { type: "undefined" });
+}
+export function glVertexAttribPointer(index, size, type, normalized, stride, offset) {
+    call(LIB, "glVertexAttribPointer", [
+        { type: { type: "int", size: 32, unsigned: true }, value: index },
+        { type: { type: "int", size: 32, unsigned: false }, value: size },
+        { type: { type: "int", size: 32, unsigned: true }, value: type },
+        { type: { type: "boolean" }, value: normalized },
+        { type: { type: "int", size: 32, unsigned: false }, value: stride },
+        { type: { type: "int", size: 64, unsigned: true }, value: offset },
+    ], { type: "undefined" });
+}
+export function glEnableVertexAttribArray(index) {
+    call(LIB, "glEnableVertexAttribArray", [{ type: { type: "int", size: 32, unsigned: true }, value: index }], {
+        type: "undefined",
+    });
+}
+export function glDisableVertexAttribArray(index) {
+    call(LIB, "glDisableVertexAttribArray", [{ type: { type: "int", size: 32, unsigned: true }, value: index }], {
+        type: "undefined",
+    });
+}
+export function glDrawArrays(mode, first, count) {
+    call(LIB, "glDrawArrays", [
+        { type: { type: "int", size: 32, unsigned: true }, value: mode },
+        { type: { type: "int", size: 32, unsigned: false }, value: first },
+        { type: { type: "int", size: 32, unsigned: false }, value: count },
+    ], { type: "undefined" });
+}
+export function glDrawElements(mode, count, type, offset) {
+    call(LIB, "glDrawElements", [
+        { type: { type: "int", size: 32, unsigned: true }, value: mode },
+        { type: { type: "int", size: 32, unsigned: false }, value: count },
+        { type: { type: "int", size: 32, unsigned: true }, value: type },
+        { type: { type: "int", size: 64, unsigned: true }, value: offset },
+    ], { type: "undefined" });
+}
+export function glGetAttribLocation(program, name) {
+    return call(LIB, "glGetAttribLocation", [
+        { type: { type: "int", size: 32, unsigned: true }, value: program },
+        { type: { type: "string" }, value: name },
+    ], { type: "int", size: 32, unsigned: false });
+}
+export function glBindAttribLocation(program, index, name) {
+    call(LIB, "glBindAttribLocation", [
+        { type: { type: "int", size: 32, unsigned: true }, value: program },
+        { type: { type: "int", size: 32, unsigned: true }, value: index },
+        { type: { type: "string" }, value: name },
+    ], { type: "undefined" });
+}
+export function glGetError() {
+    return call(LIB, "glGetError", [], { type: "int", size: 32, unsigned: true });
+}

package/dist/gl/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./constants.js";
+export * from "./gl.js";

package/dist/gl/index.js

@@ -0,0 +1,2 @@
+export * from "./constants.js";
+export * from "./gl.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/ffi",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Generated TypeScript FFI bindings for GTK4 libraries",
   "keywords": [
     "gtk",
@@ -30,6 +30,16 @@
       "development": "./src/index.ts",
       "default": "./dist/index.js"
     },
+    "./gl": {
+      "types": "./dist/gl/index.d.ts",
+      "development": "./src/gl/index.ts",
+      "default": "./dist/gl/index.js"
+    },
+    "./cairo": {
+      "types": "./dist/cairo/index.d.ts",
+      "development": "./src/cairo/index.ts",
+      "default": "./dist/cairo/index.js"
+    },
     "./*": {
       "types": "./dist/generated/*/index.d.ts",
       "development": "./src/generated/*/index.ts",
@@ -40,10 +50,10 @@
     "dist"
   ],
   "dependencies": {
-    "@gtkx/native": "0.1.16"
+    "@gtkx/native": "0.1.18"
   },
   "devDependencies": {
-    "@gtkx/gir": "0.1.16"
+    "@gtkx/gir": "0.1.18"
   },
   "scripts": {
     "build": "tsc -b",