@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,31 +1,158 @@
 import { Ref } from "@gtkx/native";
+/**
+ * A structure capable of holding a vector with two dimensions, x and y.
+ *
+ * The contents of the #graphene_vec2_t structure are private and should
+ * never be accessed directly.
+ */
 export declare class Vec2 {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_vec2_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     *
+     * Use graphene_vec2_init() to initialize the vector.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Retrieves a constant vector with (1, 1) components.
+     */
     static one(): Vec2;
+    /**
+     * Retrieves a constant vector with (1, 0) components.
+     */
     static xAxis(): Vec2;
+    /**
+     * Retrieves a constant vector with (0, 1) components.
+     */
     static yAxis(): Vec2;
+    /**
+     * Retrieves a constant vector with (0, 0) components.
+     */
     static zero(): Vec2;
+    /**
+     * Adds each component of the two passed vectors and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     add(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Divides each component of the first operand `a` by the corresponding
+     * component of the second operand @b, and places the results into the
+     * vector @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     divide(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Computes the dot product of the two given vectors.
+     * @param b - a #graphene_vec2_t
+     */
     dot(b: Vec2): number;
+    /**
+     * Checks whether the two given #graphene_vec2_t are equal.
+     * @param v2 - a #graphene_vec2_t
+     */
     equal(v2: Vec2): boolean;
+    /**
+     * Frees the resources allocated by @v
+     */
     free(): void;
+    /**
+     * Retrieves the X component of the #graphene_vec2_t.
+     */
     getX(): number;
+    /**
+     * Retrieves the Y component of the #graphene_vec2_t.
+     */
     getY(): number;
+    /**
+     * Initializes a #graphene_vec2_t using the given values.
+     *
+     * This function can be called multiple times.
+     * @param x - the X field of the vector
+     * @param y - the Y field of the vector
+     */
     init(x: number, y: number): Vec2;
+    /**
+     * Initializes `v` with the contents of the given array.
+     * @param src - an array of floating point values
+     */
     initFromFloat(src: number[]): Vec2;
+    /**
+     * Copies the contents of `src` into @v.
+     * @param src - a #graphene_vec2_t
+     */
     initFromVec2(src: Vec2): Vec2;
+    /**
+     * Linearly interpolates `v1` and `v2` using the given @factor.
+     * @param v2 - a #graphene_vec2_t
+     * @param factor - the interpolation factor
+     * @param res - the interpolated vector
+     */
     interpolate(v2: Vec2, factor: number, res: Ref<Vec2>): void;
+    /**
+     * Computes the length of the given vector.
+     */
     length(): number;
+    /**
+     * Compares the two given vectors and places the maximum
+     * values of each component into @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - the resulting vector
+     */
     max(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Compares the two given vectors and places the minimum
+     * values of each component into @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - the resulting vector
+     */
     min(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Multiplies each component of the two passed vectors and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     multiply(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Compares the two given #graphene_vec2_t vectors and checks
+     * whether their values are within the given @epsilon.
+     * @param v2 - a #graphene_vec2_t
+     * @param epsilon - the threshold between the two vectors
+     */
     near(v2: Vec2, epsilon: number): boolean;
+    /**
+     * Negates the given #graphene_vec2_t.
+     * @param res - return location for the result vector
+     */
     negate(res: Ref<Vec2>): void;
+    /**
+     * Computes the normalized vector for the given vector @v.
+     * @param res - return location for the
+     */
     normalize(res: Ref<Vec2>): void;
+    /**
+     * Multiplies all components of the given vector with the given scalar @factor.
+     * @param factor - the scalar factor
+     * @param res - return location for the result vector
+     */
     scale(factor: number, res: Ref<Vec2>): void;
+    /**
+     * Subtracts from each component of the first operand `a` the
+     * corresponding component of the second operand `b` and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     subtract(b: Vec2, res: Ref<Vec2>): void;
+    /**
+     * Stores the components of `v` into an array.
+     * @param dest - return location
+     */
     toFloat(dest: Ref<number[]>): void;
 }

package/dist/generated/graphene/vec2.js

@@ -1,7 +1,20 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A structure capable of holding a vector with two dimensions, x and y.
+ *
+ * The contents of the #graphene_vec2_t structure are private and should
+ * never be accessed directly.
+ */
 export class Vec2 {
     ptr;
+    /**
+     * Allocates a new #graphene_vec2_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     *
+     * Use graphene_vec2_init() to initialize the vector.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +25,9 @@ export class Vec2 {
             innerType: "GrapheneVec2",
         });
     }
+    /**
+     * Retrieves a constant vector with (1, 1) components.
+     */
     static one() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_one", [], {
             type: "boxed",
@@ -21,6 +37,9 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Retrieves a constant vector with (1, 0) components.
+     */
     static xAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_x_axis", [], {
             type: "boxed",
@@ -30,6 +49,9 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Retrieves a constant vector with (0, 1) components.
+     */
     static yAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_y_axis", [], {
             type: "boxed",
@@ -39,6 +61,9 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Retrieves a constant vector with (0, 0) components.
+     */
     static zero() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_zero", [], {
             type: "boxed",
@@ -48,6 +73,12 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Adds each component of the two passed vectors and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     add(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_add", [
             {
@@ -76,6 +107,13 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Divides each component of the first operand `a` by the corresponding
+     * component of the second operand @b, and places the results into the
+     * vector @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     divide(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_divide", [
             {
@@ -104,6 +142,10 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the dot product of the two given vectors.
+     * @param b - a #graphene_vec2_t
+     */
     dot(b) {
         return call("libgraphene-1.0.so.0", "graphene_vec2_dot", [
             {
@@ -121,6 +163,10 @@ export class Vec2 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Checks whether the two given #graphene_vec2_t are equal.
+     * @param v2 - a #graphene_vec2_t
+     */
     equal(v2) {
         return call("libgraphene-1.0.so.0", "graphene_vec2_equal", [
             {
@@ -138,6 +184,9 @@ export class Vec2 {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by @v
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_vec2_free", [
             {
@@ -146,6 +195,9 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the X component of the #graphene_vec2_t.
+     */
     getX() {
         return call("libgraphene-1.0.so.0", "graphene_vec2_get_x", [
             {
@@ -154,6 +206,9 @@ export class Vec2 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the Y component of the #graphene_vec2_t.
+     */
     getY() {
         return call("libgraphene-1.0.so.0", "graphene_vec2_get_y", [
             {
@@ -162,6 +217,13 @@ export class Vec2 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Initializes a #graphene_vec2_t using the given values.
+     *
+     * This function can be called multiple times.
+     * @param x - the X field of the vector
+     * @param y - the Y field of the vector
+     */
     init(x, y) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_init", [
             {
@@ -184,6 +246,10 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Initializes `v` with the contents of the given array.
+     * @param src - an array of floating point values
+     */
     initFromFloat(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_init_from_float", [
             {
@@ -202,6 +268,10 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Copies the contents of `src` into @v.
+     * @param src - a #graphene_vec2_t
+     */
     initFromVec2(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec2_init_from_vec2", [
             {
@@ -225,6 +295,12 @@ export class Vec2 {
         });
         return getObject(ptr, Vec2);
     }
+    /**
+     * Linearly interpolates `v1` and `v2` using the given @factor.
+     * @param v2 - a #graphene_vec2_t
+     * @param factor - the interpolation factor
+     * @param res - the interpolated vector
+     */
     interpolate(v2, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_interpolate", [
             {
@@ -257,6 +333,9 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the length of the given vector.
+     */
     length() {
         return call("libgraphene-1.0.so.0", "graphene_vec2_length", [
             {
@@ -265,6 +344,12 @@ export class Vec2 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Compares the two given vectors and places the maximum
+     * values of each component into @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - the resulting vector
+     */
     max(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_max", [
             {
@@ -293,6 +378,12 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compares the two given vectors and places the minimum
+     * values of each component into @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - the resulting vector
+     */
     min(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_min", [
             {
@@ -321,6 +412,12 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Multiplies each component of the two passed vectors and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     multiply(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_multiply", [
             {
@@ -349,6 +446,12 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compares the two given #graphene_vec2_t vectors and checks
+     * whether their values are within the given @epsilon.
+     * @param v2 - a #graphene_vec2_t
+     * @param epsilon - the threshold between the two vectors
+     */
     near(v2, epsilon) {
         return call("libgraphene-1.0.so.0", "graphene_vec2_near", [
             {
@@ -370,6 +473,10 @@ export class Vec2 {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Negates the given #graphene_vec2_t.
+     * @param res - return location for the result vector
+     */
     negate(res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_negate", [
             {
@@ -389,6 +496,10 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the normalized vector for the given vector @v.
+     * @param res - return location for the
+     */
     normalize(res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_normalize", [
             {
@@ -408,6 +519,11 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Multiplies all components of the given vector with the given scalar @factor.
+     * @param factor - the scalar factor
+     * @param res - return location for the result vector
+     */
     scale(factor, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_scale", [
             {
@@ -431,6 +547,13 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Subtracts from each component of the first operand `a` the
+     * corresponding component of the second operand `b` and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec2_t
+     * @param res - return location for the result
+     */
     subtract(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec2_subtract", [
             {
@@ -459,6 +582,10 @@ export class Vec2 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Stores the components of `v` into an array.
+     * @param dest - return location
+     */
     toFloat(dest) {
         call("libgraphene-1.0.so.0", "graphene_vec2_to_float", [
             {

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

@@ -1,41 +1,210 @@
 import { Ref } from "@gtkx/native";
 import { Vec2 } from "./vec2.js";
 import { Vec4 } from "./vec4.js";
+/**
+ * A structure capable of holding a vector with three dimensions: x, y, and z.
+ *
+ * The contents of the #graphene_vec3_t structure are private and should
+ * never be accessed directly.
+ */
 export declare class Vec3 {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_vec3_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     *
+     * Use graphene_vec3_init() to initialize the vector.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Provides a constant pointer to a vector with three components,
+     * all sets to 1.
+     */
     static one(): Vec3;
+    /**
+     * Provides a constant pointer to a vector with three components
+     * with values set to (1, 0, 0).
+     */
     static xAxis(): Vec3;
+    /**
+     * Provides a constant pointer to a vector with three components
+     * with values set to (0, 1, 0).
+     */
     static yAxis(): Vec3;
+    /**
+     * Provides a constant pointer to a vector with three components
+     * with values set to (0, 0, 1).
+     */
     static zAxis(): Vec3;
+    /**
+     * Provides a constant pointer to a vector with three components,
+     * all sets to 0.
+     */
     static zero(): Vec3;
+    /**
+     * Adds each component of the two given vectors.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the resulting vector
+     */
     add(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Computes the cross product of the two given vectors.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the resulting vector
+     */
     cross(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Divides each component of the first operand `a` by the corresponding
+     * component of the second operand @b, and places the results into the
+     * vector @res.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the resulting vector
+     */
     divide(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Computes the dot product of the two given vectors.
+     * @param b - a #graphene_vec3_t
+     */
     dot(b: Vec3): number;
+    /**
+     * Checks whether the two given #graphene_vec3_t are equal.
+     * @param v2 - a #graphene_vec3_t
+     */
     equal(v2: Vec3): boolean;
+    /**
+     * Frees the resources allocated by @v
+     */
     free(): void;
+    /**
+     * Retrieves the first component of the given vector @v.
+     */
     getX(): number;
+    /**
+     * Creates a #graphene_vec2_t that contains the first and second
+     * components of the given #graphene_vec3_t.
+     * @param res - return location for a #graphene_vec2_t
+     */
     getXy(res: Ref<Vec2>): void;
+    /**
+     * Creates a #graphene_vec3_t that contains the first two components of
+     * the given #graphene_vec3_t, and the third component set to 0.
+     * @param res - return location for a #graphene_vec3_t
+     */
     getXy0(res: Ref<Vec3>): void;
+    /**
+     * Converts a #graphene_vec3_t in a #graphene_vec4_t using 0.0
+     * as the value for the fourth component of the resulting vector.
+     * @param res - return location for the vector
+     */
     getXyz0(res: Ref<Vec4>): void;
+    /**
+     * Converts a #graphene_vec3_t in a #graphene_vec4_t using 1.0
+     * as the value for the fourth component of the resulting vector.
+     * @param res - return location for the vector
+     */
     getXyz1(res: Ref<Vec4>): void;
+    /**
+     * Converts a #graphene_vec3_t in a #graphene_vec4_t using `w` as
+     * the value of the fourth component of the resulting vector.
+     * @param w - the value of the W component
+     * @param res - return location for the vector
+     */
     getXyzw(w: number, res: Ref<Vec4>): void;
+    /**
+     * Retrieves the second component of the given vector @v.
+     */
     getY(): number;
+    /**
+     * Retrieves the third component of the given vector @v.
+     */
     getZ(): number;
+    /**
+     * Initializes a #graphene_vec3_t using the given values.
+     *
+     * This function can be called multiple times.
+     * @param x - the X field of the vector
+     * @param y - the Y field of the vector
+     * @param z - the Z field of the vector
+     */
     init(x: number, y: number, z: number): Vec3;
+    /**
+     * Initializes a #graphene_vec3_t with the values from an array.
+     * @param src - an array of 3 floating point values
+     */
     initFromFloat(src: number[]): Vec3;
+    /**
+     * Initializes a #graphene_vec3_t with the values of another
+     * #graphene_vec3_t.
+     * @param src - a #graphene_vec3_t
+     */
     initFromVec3(src: Vec3): Vec3;
+    /**
+     * Linearly interpolates `v1` and `v2` using the given @factor.
+     * @param v2 - a #graphene_vec3_t
+     * @param factor - the interpolation factor
+     * @param res - the interpolated vector
+     */
     interpolate(v2: Vec3, factor: number, res: Ref<Vec3>): void;
+    /**
+     * Retrieves the length of the given vector @v.
+     */
     length(): number;
+    /**
+     * Compares each component of the two given vectors and creates a
+     * vector that contains the maximum values.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the result vector
+     */
     max(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Compares each component of the two given vectors and creates a
+     * vector that contains the minimum values.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the result vector
+     */
     min(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Multiplies each component of the two given vectors.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the resulting vector
+     */
     multiply(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Compares the two given #graphene_vec3_t vectors and checks
+     * whether their values are within the given @epsilon.
+     * @param v2 - a #graphene_vec3_t
+     * @param epsilon - the threshold between the two vectors
+     */
     near(v2: Vec3, epsilon: number): boolean;
+    /**
+     * Negates the given #graphene_vec3_t.
+     * @param res - return location for the result vector
+     */
     negate(res: Ref<Vec3>): void;
+    /**
+     * Normalizes the given #graphene_vec3_t.
+     * @param res - return location for the normalized vector
+     */
     normalize(res: Ref<Vec3>): void;
+    /**
+     * Multiplies all components of the given vector with the given scalar @factor.
+     * @param factor - the scalar factor
+     * @param res - return location for the result vector
+     */
     scale(factor: number, res: Ref<Vec3>): void;
+    /**
+     * Subtracts from each component of the first operand `a` the
+     * corresponding component of the second operand `b` and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec3_t
+     * @param res - return location for the resulting vector
+     */
     subtract(b: Vec3, res: Ref<Vec3>): void;
+    /**
+     * Copies the components of a #graphene_vec3_t into the given array.
+     * @param dest - return location for
+     */
     toFloat(dest: Ref<number[]>): void;
 }