@gtkx/ffi 0.1.4 → 0.1.6

package/dist/generated/graphene/ray.js

@@ -0,0 +1,345 @@
+import { call } from "@gtkx/native";
+export class Ray {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr([]);
+    }
+    createPtr(_args) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_alloc", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneRay",
+        });
+    }
+    equal(b) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneRay",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "boolean" });
+    }
+    free() {
+        call("libgraphene-1.0.so.0", "graphene_ray_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getClosestPointToPoint(p, res) {
+        call("libgraphene-1.0.so.0", "graphene_ray_get_closest_point_to_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: p,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: res,
+            },
+        ], { type: "undefined" });
+    }
+    getDirection(direction) {
+        call("libgraphene-1.0.so.0", "graphene_ray_get_direction", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GrapheneVec3",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: direction,
+            },
+        ], { type: "undefined" });
+    }
+    getDistanceToPlane(p) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_get_distance_to_plane", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePlane",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: p,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getDistanceToPoint(p) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_get_distance_to_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: p,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getOrigin(origin) {
+        call("libgraphene-1.0.so.0", "graphene_ray_get_origin", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: origin,
+            },
+        ], { type: "undefined" });
+    }
+    getPositionAt(t, position) {
+        call("libgraphene-1.0.so.0", "graphene_ray_get_position_at", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: t,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GraphenePoint3D",
+                        lib: "libgraphene-1.0.so.0",
+                    },
+                },
+                value: position,
+            },
+        ], { type: "undefined" });
+    }
+    init(origin, direction) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_init", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GraphenePoint3D",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: origin,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: direction,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneRay",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromRay(src) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_init_from_ray", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneRay",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: src,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneRay",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    initFromVec3(origin, direction) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_init_from_vec3", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: origin,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneVec3",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: direction,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GrapheneRay",
+            lib: "libgraphene-1.0.so.0",
+        });
+    }
+    intersectBox(b, tOut) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersect_box", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: tOut,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    intersectSphere(s, tOut) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersect_sphere", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneSphere",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: s,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: tOut,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    intersectTriangle(t, tOut) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersect_triangle", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneTriangle",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: t,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: tOut,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    intersectsBox(b) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersects_box", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneBox",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: b,
+            },
+        ], { type: "boolean" });
+    }
+    intersectsSphere(s) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersects_sphere", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneSphere",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: s,
+            },
+        ], { type: "boolean" });
+    }
+    intersectsTriangle(t) {
+        return call("libgraphene-1.0.so.0", "graphene_ray_intersects_triangle", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GrapheneTriangle",
+                    lib: "libgraphene-1.0.so.0",
+                },
+                value: t,
+            },
+        ], { type: "boolean" });
+    }
+}

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

@@ -0,0 +1,44 @@
+import { Ref } from "@gtkx/native";
+import type { Point } from "./point.js";
+import type { Size } from "./size.js";
+import type { Vec2 } from "./vec2.js";
+export declare class Rect {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+    static alloc(): Rect;
+    static zero(): Rect;
+    containsPoint(p: Point): boolean;
+    containsRect(b: Rect): boolean;
+    equal(b: Rect): boolean;
+    expand(p: Point, res: Ref<Rect>): void;
+    free(): void;
+    getArea(): number;
+    getBottomLeft(p: Ref<Point>): void;
+    getBottomRight(p: Ref<Point>): void;
+    getCenter(p: Ref<Point>): void;
+    getHeight(): number;
+    getTopLeft(p: Ref<Point>): void;
+    getTopRight(p: Ref<Point>): void;
+    getVertices(vertices: Ref<Vec2[]>): void;
+    getWidth(): number;
+    getX(): number;
+    getY(): number;
+    init(x: number, y: number, width: number, height: number): Rect;
+    initFromRect(src: Rect): Rect;
+    inset(dX: number, dY: number): Rect;
+    insetR(dX: number, dY: number, res: Ref<Rect>): void;
+    interpolate(b: Rect, factor: number, res: Ref<Rect>): void;
+    intersection(b: Rect, res?: Ref<Rect>): boolean;
+    normalize(): Rect;
+    normalizeR(res: Ref<Rect>): void;
+    offset(dX: number, dY: number): Rect;
+    offsetR(dX: number, dY: number, res: Ref<Rect>): void;
+    round(res: Ref<Rect>): void;
+    roundExtents(res: Ref<Rect>): void;
+    roundToPixel(): Rect;
+    scale(sH: number, sV: number, res: Ref<Rect>): void;
+    union(b: Rect, res: Ref<Rect>): void;
+    get origin(): Point;
+    get size(): Size;
+}