@gtkx/ffi 0.1.4 → 0.1.6

package/dist/generated/graphene/box.d.ts

@@ -0,0 +1,38 @@
+import { Ref } from "@gtkx/native";
+import type { Point3D } from "./point3d.js";
+import type { Sphere } from "./sphere.js";
+import type { Vec3 } from "./vec3.js";
+export declare class Box {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_args: unknown[]): unknown;
+    static empty(): Box;
+    static infinite(): Box;
+    static minusOne(): Box;
+    static one(): Box;
+    static oneMinusOne(): Box;
+    static zero(): Box;
+    containsBox(b: Box): boolean;
+    containsPoint(point: Point3D): boolean;
+    equal(b: Box): boolean;
+    expand(point: Point3D, res: Ref<Box>): void;
+    expandScalar(scalar: number, res: Ref<Box>): void;
+    expandVec3(vec: Vec3, res: Ref<Box>): void;
+    free(): void;
+    getBoundingSphere(sphere: Ref<Sphere>): void;
+    getCenter(center: Ref<Point3D>): void;
+    getDepth(): number;
+    getHeight(): number;
+    getMax(max: Ref<Point3D>): void;
+    getMin(min: Ref<Point3D>): void;
+    getSize(size: Ref<Vec3>): void;
+    getVertices(vertices: Ref<Vec3[]>): void;
+    getWidth(): number;
+    init(min?: Point3D, max?: Point3D): Box;
+    initFromBox(src: Box): Box;
+    initFromPoints(nPoints: number, points: Point3D[]): Box;
+    initFromVec3(min?: Vec3, max?: Vec3): Box;
+    initFromVectors(nVectors: number, vectors: Vec3[]): Box;
+    intersection(b: Box, res?: Ref<Box>): boolean;
+    union(b: Box, res: Ref<Box>): void;
+}

package/dist/generated/graphene/box.js

@@ -0,0 +1,543 @@
+import { call } from "@gtkx/native";
+export class Box {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr([]);
+    }
+    createPtr(_args) {
+        return call("libgraphene-1.0.so.0", "graphene_box_alloc", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+        });
+    }
+    static empty() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_empty", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static infinite() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_infinite", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static minusOne() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_minus_one", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static one() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_one", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static oneMinusOne() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_one_minus_one", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static zero() {
+        const ptr = call("libgraphene-1.0.so.0", "graphene_box_zero", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+        const instance = Object.create(Box.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    containsBox(b) {
+        return call("libgraphene-1.0.so.0", "graphene_box_contains_box", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "boolean" });
+    }
+    containsPoint(point) {
+        return call("libgraphene-1.0.so.0", "graphene_box_contains_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: point,
+            },
+        ], { type: "boolean" });
+    }
+    equal(b) {
+        return call("libgraphene-1.0.so.0", "graphene_box_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "boolean" });
+    }
+    expand(point, res) {
+        call("libgraphene-1.0.so.0", "graphene_box_expand", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: point,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneBox",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    expandScalar(scalar, res) {
+        call("libgraphene-1.0.so.0", "graphene_box_expand_scalar", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: scalar,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneBox",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    expandVec3(vec, res) {
+        call("libgraphene-1.0.so.0", "graphene_box_expand_vec3", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: vec,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneBox",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    free() {
+        call("libgraphene-1.0.so.0", "graphene_box_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getBoundingSphere(sphere) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_bounding_sphere", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneSphere",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: sphere,
+            },
+        ], { type: "undefined" });
+    }
+    getCenter(center) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_center", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: center,
+            },
+        ], { type: "undefined" });
+    }
+    getDepth() {
+        return call("libgraphene-1.0.so.0", "graphene_box_get_depth", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getHeight() {
+        return call("libgraphene-1.0.so.0", "graphene_box_get_height", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getMax(max) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_max", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: max,
+            },
+        ], { type: "undefined" });
+    }
+    getMin(min) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_min", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: min,
+            },
+        ], { type: "undefined" });
+    }
+    getSize(size) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_size", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneVec3",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: size,
+            },
+        ], { type: "undefined" });
+    }
+    getVertices(vertices) {
+        call("libgraphene-1.0.so.0", "graphene_box_get_vertices", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: {
+                            type: "boxed",
+                            innerType: "GrapheneVec3",
+                            lib: "libgraphene-1.0.so.0",
+                        },
+                    },
+                },
+                value: vertices,
+            },
+        ], { type: "undefined" });
+    }
+    getWidth() {
+        return call("libgraphene-1.0.so.0", "graphene_box_get_width", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "float", size: 32 });
+    }
+    init(min, max) {
+        return call("libgraphene-1.0.so.0", "graphene_box_init", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: min,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: max,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromBox(src) {
+        return call("libgraphene-1.0.so.0", "graphene_box_init_from_box", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: src,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromPoints(nPoints, points) {
+        return call("libgraphene-1.0.so.0", "graphene_box_init_from_points", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nPoints,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: points,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromVec3(min, max) {
+        return call("libgraphene-1.0.so.0", "graphene_box_init_from_vec3", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: min,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: max,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromVectors(nVectors, vectors) {
+        return call("libgraphene-1.0.so.0", "graphene_box_init_from_vectors", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: true },
+                value: nVectors,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GrapheneVec3",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: vectors,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneBox",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    intersection(b, res) {
+        return call("libgraphene-1.0.so.0", "graphene_box_intersection", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneBox",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "boolean" });
+    }
+    union(b, res) {
+        call("libgraphene-1.0.so.0", "graphene_box_union", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneBox",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/graphene/euler.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from "@gtkx/native";
+import { EulerOrder } from "./enums.js";
+import type { Matrix } from "./matrix.js";
+import type { Quaternion } from "./quaternion.js";
+import type { Vec3 } from "./vec3.js";
+export declare class Euler {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_args: unknown[]): unknown;
+    equal(b: Euler): boolean;
+    free(): void;
+    getAlpha(): number;
+    getBeta(): number;
+    getGamma(): number;
+    getOrder(): EulerOrder;
+    getX(): number;
+    getY(): number;
+    getZ(): number;
+    init(x: number, y: number, z: number): Euler;
+    initFromEuler(src?: Euler): Euler;
+    initFromMatrix(order: EulerOrder, m?: Matrix): Euler;
+    initFromQuaternion(order: EulerOrder, q?: Quaternion): Euler;
+    initFromRadians(x: number, y: number, z: number, order: EulerOrder): Euler;
+    initFromVec3(order: EulerOrder, v?: Vec3): Euler;
+    initWithOrder(x: number, y: number, z: number, order: EulerOrder): Euler;
+    reorder(order: EulerOrder, res: Ref<Euler>): void;
+    toMatrix(res: Ref<Matrix>): void;
+    toQuaternion(res: Ref<Quaternion>): void;
+    toVec3(res: Ref<Vec3>): void;
+}