@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/graphene/quaternion.js

@@ -1,7 +1,18 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A quaternion.
+ *
+ * The contents of the #graphene_quaternion_t structure are private
+ * and should never be accessed directly.
+ */
 export class Quaternion {
     ptr;
+    /**
+     * Allocates a new #graphene_quaternion_t.
+     *
+     * The contents of the returned value are undefined.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +23,11 @@ export class Quaternion {
             innerType: "GrapheneQuaternion",
         });
     }
+    /**
+     * Adds two #graphene_quaternion_t `a` and @b.
+     * @param b - a #graphene_quaternion_t
+     * @param res - the result of the operation
+     */
     add(b, res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_add", [
             {
@@ -40,6 +56,10 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the dot product of two #graphene_quaternion_t.
+     * @param b - a #graphene_quaternion_t
+     */
     dot(b) {
         return call("libgraphene-1.0.so.0", "graphene_quaternion_dot", [
             {
@@ -57,6 +77,10 @@ export class Quaternion {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Checks whether the given quaternions are equal.
+     * @param b - a #graphene_quaternion_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_quaternion_equal", [
             {
@@ -74,6 +98,9 @@ export class Quaternion {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Releases the resources allocated by graphene_quaternion_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_quaternion_free", [
             {
@@ -82,6 +109,13 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the given four values.
+     * @param x - the first component of the quaternion
+     * @param y - the second component of the quaternion
+     * @param z - the third component of the quaternion
+     * @param w - the fourth component of the quaternion
+     */
     init(x, y, z, w) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init", [
             {
@@ -112,6 +146,12 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using an `angle` on a
+     * specific @axis.
+     * @param angle - the rotation on a given axis, in degrees
+     * @param axis - the axis of rotation, expressed as a vector
+     */
     initFromAngleVec3(angle, axis) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_angle_vec3", [
             {
@@ -139,6 +179,16 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the values of
+     * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+     * on each axis.
+     *
+     * See also: graphene_quaternion_init_from_euler()
+     * @param degX - rotation angle on the X axis (yaw), in degrees
+     * @param degY - rotation angle on the Y axis (pitch), in degrees
+     * @param degZ - rotation angle on the Z axis (roll), in degrees
+     */
     initFromAngles(degX, degY, degZ) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_angles", [
             {
@@ -165,6 +215,10 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the given #graphene_euler_t.
+     * @param e - a #graphene_euler_t
+     */
     initFromEuler(e) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_euler", [
             {
@@ -188,6 +242,11 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the rotation components
+     * of a transformation matrix.
+     * @param m - a #graphene_matrix_t
+     */
     initFromMatrix(m) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_matrix", [
             {
@@ -211,6 +270,10 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t with the values from @src.
+     * @param src - a #graphene_quaternion_t
+     */
     initFromQuaternion(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_quaternion", [
             {
@@ -234,6 +297,16 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the values of
+     * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+     * on each axis.
+     *
+     * See also: graphene_quaternion_init_from_euler()
+     * @param radX - rotation angle on the X axis (yaw), in radians
+     * @param radY - rotation angle on the Y axis (pitch), in radians
+     * @param radZ - rotation angle on the Z axis (roll), in radians
+     */
     initFromRadians(radX, radY, radZ) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_radians", [
             {
@@ -260,6 +333,10 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t with the values from @src.
+     * @param src - a #graphene_vec4_t
+     */
     initFromVec4(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_from_vec4", [
             {
@@ -283,6 +360,10 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Initializes a #graphene_quaternion_t using the identity
+     * transformation.
+     */
     initIdentity() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_quaternion_init_identity", [
             {
@@ -297,6 +378,11 @@ export class Quaternion {
         });
         return getObject(ptr, Quaternion);
     }
+    /**
+     * Inverts a #graphene_quaternion_t, and returns the conjugate
+     * quaternion of @q.
+     * @param res - return location for the inverted
+     */
     invert(res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_invert", [
             {
@@ -316,6 +402,11 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Multiplies two #graphene_quaternion_t `a` and @b.
+     * @param b - a #graphene_quaternion_t
+     * @param res - the result of the operation
+     */
     multiply(b, res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_multiply", [
             {
@@ -344,6 +435,10 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Normalizes a #graphene_quaternion_t.
+     * @param res - return location for the normalized
+     */
     normalize(res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_normalize", [
             {
@@ -363,6 +458,12 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Scales all the elements of a #graphene_quaternion_t `q` using
+     * the given scalar factor.
+     * @param factor - a scaling factor
+     * @param res - the result of the operation
+     */
     scale(factor, res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_scale", [
             {
@@ -386,6 +487,14 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Interpolates between the two given quaternions using a spherical
+     * linear interpolation, or [SLERP](http://en.wikipedia.org/wiki/Slerp),
+     * using the given interpolation @factor.
+     * @param b - a #graphene_quaternion_t
+     * @param factor - the linear interpolation factor
+     * @param res - return location for the interpolated
+     */
     slerp(b, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_slerp", [
             {
@@ -418,6 +527,11 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a quaternion into an @angle, `axis` pair.
+     * @param angle - return location for the angle, in degrees
+     * @param axis - return location for the rotation axis
+     */
     toAngleVec3(angle, axis) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_to_angle_vec3", [
             {
@@ -441,6 +555,14 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a #graphene_quaternion_t to its corresponding rotations
+     * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+     * on each axis.
+     * @param degX - return location for the rotation angle on
+     * @param degY - return location for the rotation angle on
+     * @param degZ - return location for the rotation angle on
+     */
     toAngles(degX, degY, degZ) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_to_angles", [
             {
@@ -464,6 +586,11 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a quaternion into a transformation matrix expressing
+     * the rotation defined by the #graphene_quaternion_t.
+     * @param m - a #graphene_matrix_t
+     */
     toMatrix(m) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_to_matrix", [
             {
@@ -483,6 +610,14 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a #graphene_quaternion_t to its corresponding rotations
+     * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+     * on each axis.
+     * @param radX - return location for the rotation angle on
+     * @param radY - return location for the rotation angle on
+     * @param radZ - return location for the rotation angle on
+     */
     toRadians(radX, radY, radZ) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_to_radians", [
             {
@@ -506,6 +641,11 @@ export class Quaternion {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Copies the components of a #graphene_quaternion_t into a
+     * #graphene_vec4_t.
+     * @param res - return location for a
+     */
     toVec4(res) {
         call("libgraphene-1.0.so.0", "graphene_quaternion_to_vec4", [
             {

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

@@ -6,25 +6,133 @@ import { Point3D } from "./point3d.js";
 import { Sphere } from "./sphere.js";
 import { Triangle } from "./triangle.js";
 import { Vec3 } from "./vec3.js";
+/**
+ * A ray emitted from an origin in a given direction.
+ *
+ * The contents of the `graphene_ray_t` structure are private, and should not
+ * be modified directly.
+ */
 export declare class Ray {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_ray_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Checks whether the two given #graphene_ray_t are equal.
+     * @param b - a #graphene_ray_t
+     */
     equal(b: Ray): boolean;
+    /**
+     * Frees the resources allocated by graphene_ray_alloc().
+     */
     free(): void;
+    /**
+     * Computes the point on the given #graphene_ray_t that is closest to the
+     * given point @p.
+     * @param p - a #graphene_point3d_t
+     * @param res - return location for the closest point3d
+     */
     getClosestPointToPoint(p: Point3D, res: Ref<Point3D>): void;
+    /**
+     * Retrieves the direction of the given #graphene_ray_t.
+     * @param direction - return location for the direction
+     */
     getDirection(direction: Ref<Vec3>): void;
+    /**
+     * Computes the distance of the origin of the given #graphene_ray_t from the
+     * given plane.
+     *
+     * If the ray does not intersect the plane, this function returns `INFINITY`.
+     * @param p - a #graphene_plane_t
+     */
     getDistanceToPlane(p: Plane): number;
+    /**
+     * Computes the distance of the closest approach between the
+     * given #graphene_ray_t `r` and the point @p.
+     *
+     * The closest approach to a ray from a point is the distance
+     * between the point and the projection of the point on the
+     * ray itself.
+     * @param p - a #graphene_point3d_t
+     */
     getDistanceToPoint(p: Point3D): number;
+    /**
+     * Retrieves the origin of the given #graphene_ray_t.
+     * @param origin - return location for the origin
+     */
     getOrigin(origin: Ref<Point3D>): void;
+    /**
+     * Retrieves the coordinates of a point at the distance `t` along the
+     * given #graphene_ray_t.
+     * @param t - the distance along the ray
+     * @param position - return location for the position
+     */
     getPositionAt(t: number, position: Ref<Point3D>): void;
+    /**
+     * Initializes the given #graphene_ray_t using the given `origin` and `direction` values.
+     * @param origin - the origin of the ray
+     * @param direction - the direction vector
+     */
     init(origin?: Point3D | null, direction?: Vec3 | null): Ray;
+    /**
+     * Initializes the given #graphene_ray_t using the origin and direction
+     * values of another #graphene_ray_t.
+     * @param src - a #graphene_ray_t
+     */
     initFromRay(src: Ray): Ray;
+    /**
+     * Initializes the given #graphene_ray_t using the given vectors.
+     * @param origin - a #graphene_vec3_t
+     * @param direction - a #graphene_vec3_t
+     */
     initFromVec3(origin?: Vec3 | null, direction?: Vec3 | null): Ray;
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_box_t @b.
+     * @param b - a #graphene_box_t
+     * @param tOut - the distance of the point on the ray that intersects the box
+     */
     intersectBox(b: Box, tOut: Ref<number>): RayIntersectionKind;
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_sphere_t @s.
+     * @param s - a #graphene_sphere_t
+     * @param tOut - the distance of the point on the ray that intersects the sphere
+     */
     intersectSphere(s: Sphere, tOut: Ref<number>): RayIntersectionKind;
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_triangle_t @t.
+     * @param t - a #graphene_triangle_t
+     * @param tOut - the distance of the point on the ray that intersects the triangle
+     */
     intersectTriangle(t: Triangle, tOut: Ref<number>): RayIntersectionKind;
+    /**
+     * Checks whether the given #graphene_ray_t `r` intersects the
+     * given #graphene_box_t @b.
+     *
+     * See also: graphene_ray_intersect_box()
+     * @param b - a #graphene_box_t
+     */
     intersectsBox(b: Box): boolean;
+    /**
+     * Checks if the given #graphene_ray_t `r` intersects the
+     * given #graphene_sphere_t @s.
+     *
+     * See also: graphene_ray_intersect_sphere()
+     * @param s - a #graphene_sphere_t
+     */
     intersectsSphere(s: Sphere): boolean;
+    /**
+     * Checks whether the given #graphene_ray_t `r` intersects the
+     * given #graphene_triangle_t @b.
+     *
+     * See also: graphene_ray_intersect_triangle()
+     * @param t - a #graphene_triangle_t
+     */
     intersectsTriangle(t: Triangle): boolean;
 }

package/dist/generated/graphene/ray.js

@@ -1,7 +1,18 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A ray emitted from an origin in a given direction.
+ *
+ * The contents of the `graphene_ray_t` structure are private, and should not
+ * be modified directly.
+ */
 export class Ray {
     ptr;
+    /**
+     * Allocates a new #graphene_ray_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +23,10 @@ export class Ray {
             innerType: "GrapheneRay",
         });
     }
+    /**
+     * Checks whether the two given #graphene_ray_t are equal.
+     * @param b - a #graphene_ray_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_ray_equal", [
             {
@@ -29,6 +44,9 @@ export class Ray {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by graphene_ray_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_ray_free", [
             {
@@ -37,6 +55,12 @@ export class Ray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the point on the given #graphene_ray_t that is closest to the
+     * given point @p.
+     * @param p - a #graphene_point3d_t
+     * @param res - return location for the closest point3d
+     */
     getClosestPointToPoint(p, res) {
         call("libgraphene-1.0.so.0", "graphene_ray_get_closest_point_to_point", [
             {
@@ -65,6 +89,10 @@ export class Ray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the direction of the given #graphene_ray_t.
+     * @param direction - return location for the direction
+     */
     getDirection(direction) {
         call("libgraphene-1.0.so.0", "graphene_ray_get_direction", [
             {
@@ -84,6 +112,13 @@ export class Ray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the distance of the origin of the given #graphene_ray_t from the
+     * given plane.
+     *
+     * If the ray does not intersect the plane, this function returns `INFINITY`.
+     * @param p - a #graphene_plane_t
+     */
     getDistanceToPlane(p) {
         return call("libgraphene-1.0.so.0", "graphene_ray_get_distance_to_plane", [
             {
@@ -101,6 +136,15 @@ export class Ray {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Computes the distance of the closest approach between the
+     * given #graphene_ray_t `r` and the point @p.
+     *
+     * The closest approach to a ray from a point is the distance
+     * between the point and the projection of the point on the
+     * ray itself.
+     * @param p - a #graphene_point3d_t
+     */
     getDistanceToPoint(p) {
         return call("libgraphene-1.0.so.0", "graphene_ray_get_distance_to_point", [
             {
@@ -118,6 +162,10 @@ export class Ray {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the origin of the given #graphene_ray_t.
+     * @param origin - return location for the origin
+     */
     getOrigin(origin) {
         call("libgraphene-1.0.so.0", "graphene_ray_get_origin", [
             {
@@ -137,6 +185,12 @@ export class Ray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the coordinates of a point at the distance `t` along the
+     * given #graphene_ray_t.
+     * @param t - the distance along the ray
+     * @param position - return location for the position
+     */
     getPositionAt(t, position) {
         call("libgraphene-1.0.so.0", "graphene_ray_get_position_at", [
             {
@@ -160,6 +214,11 @@ export class Ray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Initializes the given #graphene_ray_t using the given `origin` and `direction` values.
+     * @param origin - the origin of the ray
+     * @param direction - the direction vector
+     */
     init(origin, direction) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_ray_init", [
             {
@@ -194,6 +253,11 @@ export class Ray {
         });
         return getObject(ptr, Ray);
     }
+    /**
+     * Initializes the given #graphene_ray_t using the origin and direction
+     * values of another #graphene_ray_t.
+     * @param src - a #graphene_ray_t
+     */
     initFromRay(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_ray_init_from_ray", [
             {
@@ -217,6 +281,11 @@ export class Ray {
         });
         return getObject(ptr, Ray);
     }
+    /**
+     * Initializes the given #graphene_ray_t using the given vectors.
+     * @param origin - a #graphene_vec3_t
+     * @param direction - a #graphene_vec3_t
+     */
     initFromVec3(origin, direction) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_ray_init_from_vec3", [
             {
@@ -251,6 +320,12 @@ export class Ray {
         });
         return getObject(ptr, Ray);
     }
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_box_t @b.
+     * @param b - a #graphene_box_t
+     * @param tOut - the distance of the point on the ray that intersects the box
+     */
     intersectBox(b, tOut) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersect_box", [
             {
@@ -272,6 +347,12 @@ export class Ray {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_sphere_t @s.
+     * @param s - a #graphene_sphere_t
+     * @param tOut - the distance of the point on the ray that intersects the sphere
+     */
     intersectSphere(s, tOut) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersect_sphere", [
             {
@@ -293,6 +374,12 @@ export class Ray {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Intersects the given #graphene_ray_t `r` with the given
+     * #graphene_triangle_t @t.
+     * @param t - a #graphene_triangle_t
+     * @param tOut - the distance of the point on the ray that intersects the triangle
+     */
     intersectTriangle(t, tOut) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersect_triangle", [
             {
@@ -314,6 +401,13 @@ export class Ray {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Checks whether the given #graphene_ray_t `r` intersects the
+     * given #graphene_box_t @b.
+     *
+     * See also: graphene_ray_intersect_box()
+     * @param b - a #graphene_box_t
+     */
     intersectsBox(b) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersects_box", [
             {
@@ -331,6 +425,13 @@ export class Ray {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if the given #graphene_ray_t `r` intersects the
+     * given #graphene_sphere_t @s.
+     *
+     * See also: graphene_ray_intersect_sphere()
+     * @param s - a #graphene_sphere_t
+     */
     intersectsSphere(s) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersects_sphere", [
             {
@@ -348,6 +449,13 @@ export class Ray {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the given #graphene_ray_t `r` intersects the
+     * given #graphene_triangle_t @b.
+     *
+     * See also: graphene_ray_intersect_triangle()
+     * @param t - a #graphene_triangle_t
+     */
     intersectsTriangle(t) {
         return call("libgraphene-1.0.so.0", "graphene_ray_intersects_triangle", [
             {