@gtkx/ffi 0.1.5 → 0.1.6

package/dist/generated/graphene/quaternion.js

@@ -0,0 +1,502 @@
+import { call } from "@gtkx/native";
+export class Quaternion {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr([]);
+    }
+    createPtr(_args) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_alloc", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+        });
+    }
+    add(b, res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_add", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    dot(b) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_dot", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "float", size: 32 });
+    }
+    equal(b) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "boolean" });
+    }
+    free() {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    init(x, y, z, w) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: x,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: y,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: z,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: w,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromAngleVec3(angle, axis) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_angle_vec3", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: angle,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: axis,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromAngles(degX, degY, degZ) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_angles", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: degX,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: degY,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: degZ,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromEuler(e) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_euler", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneEuler",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: e,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromMatrix(m) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_matrix", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneMatrix",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: m,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromQuaternion(src) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_quaternion", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: src,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromRadians(radX, radY, radZ) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_radians", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: radX,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: radY,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: radZ,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromVec4(src) {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_vec4", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec4",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: src,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initIdentity() {
+        return call("libgraphene-1.0.so.0", "graphene_quaternion_init_identity", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneQuaternion",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    invert(res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_invert", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    multiply(b, res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_multiply", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    normalize(res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_normalize", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    scale(factor, res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_scale", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: factor,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    slerp(b, factor, res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_slerp", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneQuaternion",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: factor,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneQuaternion",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    toAngleVec3(angle, axis) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_to_angle_vec3", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: angle,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneVec3",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: axis,
+            },
+        ], { type: "undefined" });
+    }
+    toAngles(degX, degY, degZ) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_to_angles", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: degX,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: degY,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: degZ,
+            },
+        ], { type: "undefined" });
+    }
+    toMatrix(m) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_to_matrix", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneMatrix",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: m,
+            },
+        ], { type: "undefined" });
+    }
+    toRadians(radX, radY, radZ) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_to_radians", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: radX,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: radY,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: radZ,
+            },
+        ], { type: "undefined" });
+    }
+    toVec4(res) {
+        call("libgraphene-1.0.so.0", "graphene_quaternion_to_vec4", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneVec4",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { Ref } from "@gtkx/native";
+import { RayIntersectionKind } from "./enums.js";
+import type { Box } from "./box.js";
+import type { Plane } from "./plane.js";
+import type { Point3D } from "./point3d.js";
+import type { Sphere } from "./sphere.js";
+import type { Triangle } from "./triangle.js";
+import type { Vec3 } from "./vec3.js";
+export declare class Ray {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_args: unknown[]): unknown;
+    equal(b: Ray): boolean;
+    free(): void;
+    getClosestPointToPoint(p: Point3D, res: Ref<Point3D>): void;
+    getDirection(direction: Ref<Vec3>): void;
+    getDistanceToPlane(p: Plane): number;
+    getDistanceToPoint(p: Point3D): number;
+    getOrigin(origin: Ref<Point3D>): void;
+    getPositionAt(t: number, position: Ref<Point3D>): void;
+    init(origin?: Point3D, direction?: Vec3): Ray;
+    initFromRay(src: Ray): Ray;
+    initFromVec3(origin?: Vec3, direction?: Vec3): Ray;
+    intersectBox(b: Box, tOut: Ref<number>): RayIntersectionKind;
+    intersectSphere(s: Sphere, tOut: Ref<number>): RayIntersectionKind;
+    intersectTriangle(t: Triangle, tOut: Ref<number>): RayIntersectionKind;
+    intersectsBox(b: Box): boolean;
+    intersectsSphere(s: Sphere): boolean;
+    intersectsTriangle(t: Triangle): boolean;
+}