@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/graphene/enums.js

@@ -1,40 +1,108 @@
+/**
+ * Specify the order of the rotations on each axis.
+ *
+ * The %GRAPHENE_EULER_ORDER_DEFAULT value is special, and is used
+ * as an alias for one of the other orders.
+ */
 export var EulerOrder;
 (function (EulerOrder) {
+    /**
+     * Rotate in the default order; the
+     * default order is one of the following enumeration values
+     */
     EulerOrder[EulerOrder["DEFAULT"] = -1] = "DEFAULT";
+    /**
+     * Rotate in the X, Y, and Z order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXYZ
+     */
     EulerOrder[EulerOrder["XYZ"] = 0] = "XYZ";
+    /**
+     * Rotate in the Y, Z, and X order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYZX
+     */
     EulerOrder[EulerOrder["YZX"] = 1] = "YZX";
+    /**
+     * Rotate in the Z, X, and Y order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZXY
+     */
     EulerOrder[EulerOrder["ZXY"] = 2] = "ZXY";
+    /**
+     * Rotate in the X, Z, and Y order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXZY
+     */
     EulerOrder[EulerOrder["XZY"] = 3] = "XZY";
+    /**
+     * Rotate in the Y, X, and Z order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYXZ
+     */
     EulerOrder[EulerOrder["YXZ"] = 4] = "YXZ";
+    /**
+     * Rotate in the Z, Y, and X order. Deprecated in
+     * Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZYX
+     */
     EulerOrder[EulerOrder["ZYX"] = 5] = "ZYX";
+    /** Defines a static rotation along the X, Y, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["SXYZ"] = 6] = "SXYZ";
+    /** Defines a static rotation along the X, Y, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["SXYX"] = 7] = "SXYX";
+    /** Defines a static rotation along the X, Z, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["SXZY"] = 8] = "SXZY";
+    /** Defines a static rotation along the X, Z, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["SXZX"] = 9] = "SXZX";
+    /** Defines a static rotation along the Y, Z, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["SYZX"] = 10] = "SYZX";
+    /** Defines a static rotation along the Y, Z, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["SYZY"] = 11] = "SYZY";
+    /** Defines a static rotation along the Y, X, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["SYXZ"] = 12] = "SYXZ";
+    /** Defines a static rotation along the Y, X, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["SYXY"] = 13] = "SYXY";
+    /** Defines a static rotation along the Z, X, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["SZXY"] = 14] = "SZXY";
+    /** Defines a static rotation along the Z, X, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["SZXZ"] = 15] = "SZXZ";
+    /** Defines a static rotation along the Z, Y, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["SZYX"] = 16] = "SZYX";
+    /** Defines a static rotation along the Z, Y, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["SZYZ"] = 17] = "SZYZ";
+    /** Defines a relative rotation along the Z, Y, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["RZYX"] = 18] = "RZYX";
+    /** Defines a relative rotation along the X, Y, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["RXYX"] = 19] = "RXYX";
+    /** Defines a relative rotation along the Y, Z, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["RYZX"] = 20] = "RYZX";
+    /** Defines a relative rotation along the X, Z, and X axes (Since: 1.10) */
     EulerOrder[EulerOrder["RXZX"] = 21] = "RXZX";
+    /** Defines a relative rotation along the X, Z, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["RXZY"] = 22] = "RXZY";
+    /** Defines a relative rotation along the Y, Z, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["RYZY"] = 23] = "RYZY";
+    /** Defines a relative rotation along the Z, X, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["RZXY"] = 24] = "RZXY";
+    /** Defines a relative rotation along the Y, X, and Y axes (Since: 1.10) */
     EulerOrder[EulerOrder["RYXY"] = 25] = "RYXY";
+    /** Defines a relative rotation along the Y, X, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["RYXZ"] = 26] = "RYXZ";
+    /** Defines a relative rotation along the Z, X, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["RZXZ"] = 27] = "RZXZ";
+    /** Defines a relative rotation along the X, Y, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["RXYZ"] = 28] = "RXYZ";
+    /** Defines a relative rotation along the Z, Y, and Z axes (Since: 1.10) */
     EulerOrder[EulerOrder["RZYZ"] = 29] = "RZYZ";
 })(EulerOrder || (EulerOrder = {}));
+/** The type of intersection. */
 export var RayIntersectionKind;
 (function (RayIntersectionKind) {
+    /** No intersection */
     RayIntersectionKind[RayIntersectionKind["NONE"] = 0] = "NONE";
+    /**
+     * The ray is entering the intersected
+     * object
+     */
     RayIntersectionKind[RayIntersectionKind["ENTER"] = 1] = "ENTER";
+    /**
+     * The ray is leaving the intersected
+     * object
+     */
     RayIntersectionKind[RayIntersectionKind["LEAVE"] = 2] = "LEAVE";
 })(RayIntersectionKind || (RayIntersectionKind = {}));

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

@@ -3,28 +3,175 @@ import { EulerOrder } from "./enums.js";
 import { Matrix } from "./matrix.js";
 import { Quaternion } from "./quaternion.js";
 import { Vec3 } from "./vec3.js";
+/**
+ * Describe a rotation using Euler angles.
+ *
+ * The contents of the #graphene_euler_t structure are private
+ * and should never be accessed directly.
+ */
 export declare class Euler {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_euler_t.
+     *
+     * The contents of the returned structure are undefined.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Checks if two #graphene_euler_t are equal.
+     * @param b - a #graphene_euler_t
+     */
     equal(b: Euler): boolean;
+    /**
+     * Frees the resources allocated by graphene_euler_alloc().
+     */
     free(): void;
+    /**
+     * Retrieves the first component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_x()
+     */
     getAlpha(): number;
+    /**
+     * Retrieves the second component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_y()
+     */
     getBeta(): number;
+    /**
+     * Retrieves the third component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_z()
+     */
     getGamma(): number;
+    /**
+     * Retrieves the order used to apply the rotations described in the
+     * #graphene_euler_t structure, when converting to and from other
+     * structures, like #graphene_quaternion_t and #graphene_matrix_t.
+     *
+     * This function does not return the %GRAPHENE_EULER_ORDER_DEFAULT
+     * enumeration value; it will return the effective order of rotation
+     * instead.
+     */
     getOrder(): EulerOrder;
+    /**
+     * Retrieves the rotation angle on the X axis, in degrees.
+     */
     getX(): number;
+    /**
+     * Retrieves the rotation angle on the Y axis, in degrees.
+     */
     getY(): number;
+    /**
+     * Retrieves the rotation angle on the Z axis, in degrees.
+     */
     getZ(): number;
+    /**
+     * Initializes a #graphene_euler_t using the given angles.
+     *
+     * The order of the rotations is %GRAPHENE_EULER_ORDER_DEFAULT.
+     * @param x - rotation angle on the X axis, in degrees
+     * @param y - rotation angle on the Y axis, in degrees
+     * @param z - rotation angle on the Z axis, in degrees
+     */
     init(x: number, y: number, z: number): Euler;
+    /**
+     * Initializes a #graphene_euler_t using the angles and order of
+     * another #graphene_euler_t.
+     *
+     * If the #graphene_euler_t `src` is %NULL, this function is equivalent
+     * to calling graphene_euler_init() with all angles set to 0.
+     * @param src - a #graphene_euler_t
+     */
     initFromEuler(src?: Euler | null): Euler;
+    /**
+     * Initializes a #graphene_euler_t using the given rotation matrix.
+     *
+     * If the #graphene_matrix_t `m` is %NULL, the #graphene_euler_t will
+     * be initialized with all angles set to 0.
+     * @param m - a rotation matrix
+     * @param order - the order used to apply the rotations
+     */
     initFromMatrix(order: EulerOrder, m?: Matrix | null): Euler;
+    /**
+     * Initializes a #graphene_euler_t using the given normalized quaternion.
+     *
+     * If the #graphene_quaternion_t `q` is %NULL, the #graphene_euler_t will
+     * be initialized with all angles set to 0.
+     * @param q - a normalized #graphene_quaternion_t
+     * @param order - the order used to apply the rotations
+     */
     initFromQuaternion(order: EulerOrder, q?: Quaternion | null): Euler;
+    /**
+     * Initializes a #graphene_euler_t using the given angles
+     * and order of rotation.
+     * @param x - rotation angle on the X axis, in radians
+     * @param y - rotation angle on the Y axis, in radians
+     * @param z - rotation angle on the Z axis, in radians
+     * @param order - order of rotations
+     */
     initFromRadians(x: number, y: number, z: number, order: EulerOrder): Euler;
+    /**
+     * Initializes a #graphene_euler_t using the angles contained in a
+     * #graphene_vec3_t.
+     *
+     * If the #graphene_vec3_t `v` is %NULL, the #graphene_euler_t will be
+     * initialized with all angles set to 0.
+     * @param v - a #graphene_vec3_t containing the rotation
+     * @param order - the order used to apply the rotations
+     */
     initFromVec3(order: EulerOrder, v?: Vec3 | null): Euler;
+    /**
+     * Initializes a #graphene_euler_t with the given angles and @order.
+     * @param x - rotation angle on the X axis, in degrees
+     * @param y - rotation angle on the Y axis, in degrees
+     * @param z - rotation angle on the Z axis, in degrees
+     * @param order - the order used to apply the rotations
+     */
     initWithOrder(x: number, y: number, z: number, order: EulerOrder): Euler;
+    /**
+     * Reorders a #graphene_euler_t using @order.
+     *
+     * This function is equivalent to creating a #graphene_quaternion_t from the
+     * given #graphene_euler_t, and then converting the quaternion into another
+     * #graphene_euler_t.
+     * @param order - the new order
+     * @param res - return location for the reordered
+     */
     reorder(order: EulerOrder, res: Ref<Euler>): void;
+    /**
+     * Converts a #graphene_euler_t into a transformation matrix expressing
+     * the extrinsic composition of rotations described by the Euler angles.
+     *
+     * The rotations are applied over the reference frame axes in the order
+     * associated with the #graphene_euler_t; for instance, if the order
+     * used to initialize `e` is %GRAPHENE_EULER_ORDER_XYZ:
+     *
+     * * the first rotation moves the body around the X axis with
+     * an angle φ
+     * * the second rotation moves the body around the Y axis with
+     * an angle of ϑ
+     * * the third rotation moves the body around the Z axis with
+     * an angle of ψ
+     *
+     * The rotation sign convention is right-handed, to preserve compatibility
+     * between Euler-based, quaternion-based, and angle-axis-based rotations.
+     * @param res - return location for a #graphene_matrix_t
+     */
     toMatrix(res: Ref<Matrix>): void;
+    /**
+     * Converts a #graphene_euler_t into a #graphene_quaternion_t.
+     * @param res - return location for a #graphene_quaternion_t
+     */
     toQuaternion(res: Ref<Quaternion>): void;
+    /**
+     * Retrieves the angles of a #graphene_euler_t and initializes a
+     * #graphene_vec3_t with them.
+     * @param res - return location for a #graphene_vec3_t
+     */
     toVec3(res: Ref<Vec3>): void;
 }

package/dist/generated/graphene/euler.js

@@ -1,7 +1,18 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * Describe a rotation using Euler angles.
+ *
+ * The contents of the #graphene_euler_t structure are private
+ * and should never be accessed directly.
+ */
 export class Euler {
     ptr;
+    /**
+     * Allocates a new #graphene_euler_t.
+     *
+     * The contents of the returned structure are undefined.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +23,10 @@ export class Euler {
             innerType: "GrapheneEuler",
         });
     }
+    /**
+     * Checks if two #graphene_euler_t are equal.
+     * @param b - a #graphene_euler_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_euler_equal", [
             {
@@ -29,6 +44,9 @@ export class Euler {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by graphene_euler_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_euler_free", [
             {
@@ -37,6 +55,12 @@ export class Euler {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the first component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_x()
+     */
     getAlpha() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_alpha", [
             {
@@ -45,6 +69,12 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the second component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_y()
+     */
     getBeta() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_beta", [
             {
@@ -53,6 +83,12 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the third component of the Euler angle vector,
+     * depending on the order of rotation.
+     *
+     * See also: graphene_euler_get_z()
+     */
     getGamma() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_gamma", [
             {
@@ -61,6 +97,15 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the order used to apply the rotations described in the
+     * #graphene_euler_t structure, when converting to and from other
+     * structures, like #graphene_quaternion_t and #graphene_matrix_t.
+     *
+     * This function does not return the %GRAPHENE_EULER_ORDER_DEFAULT
+     * enumeration value; it will return the effective order of rotation
+     * instead.
+     */
     getOrder() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_order", [
             {
@@ -69,6 +114,9 @@ export class Euler {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the rotation angle on the X axis, in degrees.
+     */
     getX() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_x", [
             {
@@ -77,6 +125,9 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the rotation angle on the Y axis, in degrees.
+     */
     getY() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_y", [
             {
@@ -85,6 +136,9 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the rotation angle on the Z axis, in degrees.
+     */
     getZ() {
         return call("libgraphene-1.0.so.0", "graphene_euler_get_z", [
             {
@@ -93,6 +147,14 @@ export class Euler {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Initializes a #graphene_euler_t using the given angles.
+     *
+     * The order of the rotations is %GRAPHENE_EULER_ORDER_DEFAULT.
+     * @param x - rotation angle on the X axis, in degrees
+     * @param y - rotation angle on the Y axis, in degrees
+     * @param z - rotation angle on the Z axis, in degrees
+     */
     init(x, y, z) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init", [
             {
@@ -119,6 +181,14 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t using the angles and order of
+     * another #graphene_euler_t.
+     *
+     * If the #graphene_euler_t `src` is %NULL, this function is equivalent
+     * to calling graphene_euler_init() with all angles set to 0.
+     * @param src - a #graphene_euler_t
+     */
     initFromEuler(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_from_euler", [
             {
@@ -143,6 +213,14 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t using the given rotation matrix.
+     *
+     * If the #graphene_matrix_t `m` is %NULL, the #graphene_euler_t will
+     * be initialized with all angles set to 0.
+     * @param m - a rotation matrix
+     * @param order - the order used to apply the rotations
+     */
     initFromMatrix(order, m) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_from_matrix", [
             {
@@ -171,6 +249,14 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t using the given normalized quaternion.
+     *
+     * If the #graphene_quaternion_t `q` is %NULL, the #graphene_euler_t will
+     * be initialized with all angles set to 0.
+     * @param q - a normalized #graphene_quaternion_t
+     * @param order - the order used to apply the rotations
+     */
     initFromQuaternion(order, q) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_from_quaternion", [
             {
@@ -199,6 +285,14 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t using the given angles
+     * and order of rotation.
+     * @param x - rotation angle on the X axis, in radians
+     * @param y - rotation angle on the Y axis, in radians
+     * @param z - rotation angle on the Z axis, in radians
+     * @param order - order of rotations
+     */
     initFromRadians(x, y, z, order) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_from_radians", [
             {
@@ -229,6 +323,15 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t using the angles contained in a
+     * #graphene_vec3_t.
+     *
+     * If the #graphene_vec3_t `v` is %NULL, the #graphene_euler_t will be
+     * initialized with all angles set to 0.
+     * @param v - a #graphene_vec3_t containing the rotation
+     * @param order - the order used to apply the rotations
+     */
     initFromVec3(order, v) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_from_vec3", [
             {
@@ -257,6 +360,13 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Initializes a #graphene_euler_t with the given angles and @order.
+     * @param x - rotation angle on the X axis, in degrees
+     * @param y - rotation angle on the Y axis, in degrees
+     * @param z - rotation angle on the Z axis, in degrees
+     * @param order - the order used to apply the rotations
+     */
     initWithOrder(x, y, z, order) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_euler_init_with_order", [
             {
@@ -287,6 +397,15 @@ export class Euler {
         });
         return getObject(ptr, Euler);
     }
+    /**
+     * Reorders a #graphene_euler_t using @order.
+     *
+     * This function is equivalent to creating a #graphene_quaternion_t from the
+     * given #graphene_euler_t, and then converting the quaternion into another
+     * #graphene_euler_t.
+     * @param order - the new order
+     * @param res - return location for the reordered
+     */
     reorder(order, res) {
         call("libgraphene-1.0.so.0", "graphene_euler_reorder", [
             {
@@ -310,6 +429,25 @@ export class Euler {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a #graphene_euler_t into a transformation matrix expressing
+     * the extrinsic composition of rotations described by the Euler angles.
+     *
+     * The rotations are applied over the reference frame axes in the order
+     * associated with the #graphene_euler_t; for instance, if the order
+     * used to initialize `e` is %GRAPHENE_EULER_ORDER_XYZ:
+     *
+     * * the first rotation moves the body around the X axis with
+     * an angle φ
+     * * the second rotation moves the body around the Y axis with
+     * an angle of ϑ
+     * * the third rotation moves the body around the Z axis with
+     * an angle of ψ
+     *
+     * The rotation sign convention is right-handed, to preserve compatibility
+     * between Euler-based, quaternion-based, and angle-axis-based rotations.
+     * @param res - return location for a #graphene_matrix_t
+     */
     toMatrix(res) {
         call("libgraphene-1.0.so.0", "graphene_euler_to_matrix", [
             {
@@ -329,6 +467,10 @@ export class Euler {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a #graphene_euler_t into a #graphene_quaternion_t.
+     * @param res - return location for a #graphene_quaternion_t
+     */
     toQuaternion(res) {
         call("libgraphene-1.0.so.0", "graphene_euler_to_quaternion", [
             {
@@ -348,6 +490,11 @@ export class Euler {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the angles of a #graphene_euler_t and initializes a
+     * #graphene_vec3_t with them.
+     * @param res - return location for a #graphene_vec3_t
+     */
     toVec3(res) {
         call("libgraphene-1.0.so.0", "graphene_euler_to_vec3", [
             {

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

@@ -4,17 +4,73 @@ import { Matrix } from "./matrix.js";
 import { Plane } from "./plane.js";
 import { Point3D } from "./point3d.js";
 import { Sphere } from "./sphere.js";
+/**
+ * A 3D volume delimited by 2D clip planes.
+ *
+ * The contents of the `graphene_frustum_t` are private, and should not be
+ * modified directly.
+ */
 export declare class Frustum {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_frustum_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Checks whether a point is inside the volume defined by the given
+     * #graphene_frustum_t.
+     * @param point - a #graphene_point3d_t
+     */
     containsPoint(point: Point3D): boolean;
+    /**
+     * Checks whether the two given #graphene_frustum_t are equal.
+     * @param b - a #graphene_frustum_t
+     */
     equal(b: Frustum): boolean;
+    /**
+     * Frees the resources allocated by graphene_frustum_alloc().
+     */
     free(): void;
+    /**
+     * Retrieves the planes that define the given #graphene_frustum_t.
+     * @param planes - return location for an array
+     */
     getPlanes(planes: Ref<Plane[]>): void;
+    /**
+     * Initializes the given #graphene_frustum_t using the provided
+     * clipping planes.
+     * @param p0 - a clipping plane
+     * @param p1 - a clipping plane
+     * @param p2 - a clipping plane
+     * @param p3 - a clipping plane
+     * @param p4 - a clipping plane
+     * @param p5 - a clipping plane
+     */
     init(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
+    /**
+     * Initializes the given #graphene_frustum_t using the clipping
+     * planes of another #graphene_frustum_t.
+     * @param src - a #graphene_frustum_t
+     */
     initFromFrustum(src: Frustum): Frustum;
+    /**
+     * Initializes a #graphene_frustum_t using the given @matrix.
+     * @param matrix - a #graphene_matrix_t
+     */
     initFromMatrix(matrix: Matrix): Frustum;
+    /**
+     * Checks whether the given `box` intersects a plane of
+     * a #graphene_frustum_t.
+     * @param box - a #graphene_box_t
+     */
     intersectsBox(box: Box): boolean;
+    /**
+     * Checks whether the given `sphere` intersects a plane of
+     * a #graphene_frustum_t.
+     * @param sphere - a #graphene_sphere_t
+     */
     intersectsSphere(sphere: Sphere): boolean;
 }