@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/graphene/matrix.js

@@ -1,7 +1,16 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A structure capable of holding a 4x4 matrix.
+ *
+ * The contents of the #graphene_matrix_t structure are private and
+ * should never be accessed directly.
+ */
 export class Matrix {
     ptr;
+    /**
+     * Allocates a new #graphene_matrix_t.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +21,20 @@ export class Matrix {
             innerType: "GrapheneMatrix",
         });
     }
+    /**
+     * Decomposes a transformation matrix into its component transformations.
+     *
+     * The algorithm for decomposing a matrix is taken from the
+     * [CSS3 Transforms specification](http://dev.w3.org/csswg/css-transforms/);
+     * specifically, the decomposition code is based on the equivalent code
+     * published in "Graphics Gems II", edited by Jim Arvo, and
+     * [available online](http://web.archive.org/web/20150512160205/http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c).
+     * @param translate - the translation vector
+     * @param scale - the scale vector
+     * @param rotate - the rotation quaternion
+     * @param shear - the shear vector
+     * @param perspective - the perspective vector
+     */
     decompose(translate, scale, rotate, shear, perspective) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_decompose", [
             {
@@ -75,6 +98,9 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Computes the determinant of the given matrix.
+     */
     determinant() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_determinant", [
             {
@@ -83,6 +109,10 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Checks whether the two given #graphene_matrix_t matrices are equal.
+     * @param b - a #graphene_matrix_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_equal", [
             {
@@ -100,6 +130,32 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the two given #graphene_matrix_t matrices are
+     * byte-by-byte equal.
+     *
+     * While this function is faster than graphene_matrix_equal(), it
+     * can also return false negatives, so it should be used in
+     * conjuction with either graphene_matrix_equal() or
+     * graphene_matrix_near(). For instance:
+     *
+     * |[<!-- language="C" -->
+     * if (graphene_matrix_equal_fast (a, b))
+     * {
+     * // matrices are definitely the same
+     * }
+     * else
+     * {
+     * if (graphene_matrix_equal (a, b))
+     * // matrices contain the same values within an epsilon of FLT_EPSILON
+     * else if (graphene_matrix_near (a, b, 0.0001))
+     * // matrices contain the same values within an epsilon of 0.0001
+     * else
+     * // matrices are not equal
+     * }
+     * ]|
+     * @param b - a #graphene_matrix_t
+     */
     equalFast(b) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_equal_fast", [
             {
@@ -117,6 +173,9 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by graphene_matrix_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_matrix_free", [
             {
@@ -125,6 +184,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the given row vector at `index_` inside a matrix.
+     * @param index_ - the index of the row vector, between 0 and 3
+     * @param res - return location for the #graphene_vec4_t
+     */
     getRow(index_, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_get_row", [
             {
@@ -148,6 +212,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the value at the given `row` and `col` index.
+     * @param row - the row index
+     * @param col - the column index
+     */
     getValue(row, col) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_value", [
             {
@@ -164,6 +233,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the scaling factor on the X axis in @m.
+     */
     getXScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_x_scale", [
             {
@@ -172,6 +244,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the translation component on the X axis from @m.
+     */
     getXTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_x_translation", [
             {
@@ -180,6 +255,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the scaling factor on the Y axis in @m.
+     */
     getYScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_y_scale", [
             {
@@ -188,6 +266,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the translation component on the Y axis from @m.
+     */
     getYTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_y_translation", [
             {
@@ -196,6 +277,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the scaling factor on the Z axis in @m.
+     */
     getZScale() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_z_scale", [
             {
@@ -204,6 +288,9 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the translation component on the Z axis from @m.
+     */
     getZTranslation() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_get_z_translation", [
             {
@@ -212,6 +299,27 @@ export class Matrix {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Initializes a #graphene_matrix_t from the values of an affine
+     * transformation matrix.
+     *
+     * The arguments map to the following matrix layout:
+     *
+     * |[<!-- language="plain" -->
+     * ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+     * ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+     * ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+     * ]|
+     *
+     * This function can be used to convert between an affine matrix type
+     * from other libraries and a #graphene_matrix_t.
+     * @param xx - the xx member
+     * @param yx - the yx member
+     * @param xy - the xy member
+     * @param yy - the yy member
+     * @param x_0 - the x0 member
+     * @param y_0 - the y0 member
+     */
     initFrom_2d(xx, yx, xy, yy, x_0, y_0) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_2d", [
             {
@@ -250,6 +358,11 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with the given array of floating
+     * point values.
+     * @param v - an array of at least 16 floating
+     */
     initFromFloat(v) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_float", [
             {
@@ -268,6 +381,11 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t using the values of the
+     * given matrix.
+     * @param src - a #graphene_matrix_t
+     */
     initFromMatrix(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_matrix", [
             {
@@ -291,6 +409,14 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with the given four row
+     * vectors.
+     * @param v0 - the first row vector
+     * @param v1 - the second row vector
+     * @param v2 - the third row vector
+     * @param v3 - the fourth row vector
+     */
     initFromVec4(v0, v1, v2, v3) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_from_vec4", [
             {
@@ -341,6 +467,17 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t compatible with #graphene_frustum_t.
+     *
+     * See also: graphene_frustum_init_from_matrix()
+     * @param left - distance of the left clipping plane
+     * @param right - distance of the right clipping plane
+     * @param bottom - distance of the bottom clipping plane
+     * @param top - distance of the top clipping plane
+     * @param zNear - distance of the near clipping plane
+     * @param zFar - distance of the far clipping plane
+     */
     initFrustum(left, right, bottom, top, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_frustum", [
             {
@@ -379,6 +516,9 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with the identity matrix.
+     */
     initIdentity() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_identity", [
             {
@@ -393,6 +533,26 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t so that it positions the "camera"
+     * at the given `eye` coordinates towards an object at the `center` coordinates. The top of the camera is aligned to the direction
+     * of the `up` vector.
+     *
+     * Before the transform, the camera is assumed to be placed at the
+     * origin, looking towards the negative Z axis, with the top side of
+     * the camera facing in the direction of the Y axis and the right
+     * side in the direction of the X axis.
+     *
+     * In theory, one could use `m` to transform a model of such a camera
+     * into world-space. However, it is more common to use the inverse of
+     * `m` to transform another object from world coordinates to the view
+     * coordinates of the camera. Typically you would then apply the
+     * camera projection transform to get from view to screen
+     * coordinates.
+     * @param eye - the vector describing the position to look from
+     * @param center - the vector describing the position to look at
+     * @param up - the vector describing the world's upward direction; usually,
+     */
     initLookAt(eye, center, up) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_look_at", [
             {
@@ -434,6 +594,15 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with an orthographic projection.
+     * @param left - the left edge of the clipping plane
+     * @param right - the right edge of the clipping plane
+     * @param top - the top edge of the clipping plane
+     * @param bottom - the bottom edge of the clipping plane
+     * @param zNear - the distance of the near clipping plane
+     * @param zFar - the distance of the far clipping plane
+     */
     initOrtho(left, right, top, bottom, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_ortho", [
             {
@@ -472,6 +641,13 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with a perspective projection.
+     * @param fovy - the field of view angle, in degrees
+     * @param aspect - the aspect value
+     * @param zNear - the near Z plane
+     * @param zFar - the far Z plane
+     */
     initPerspective(fovy, aspect, zNear, zFar) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_perspective", [
             {
@@ -502,6 +678,12 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes `m` to represent a rotation of `angle` degrees on
+     * the axis represented by the `axis` vector.
+     * @param angle - the rotation angle, in degrees
+     * @param axis - the axis vector as a #graphene_vec3_t
+     */
     initRotate(angle, axis) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_rotate", [
             {
@@ -529,6 +711,12 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with the given scaling factors.
+     * @param x - the scale factor on the X axis
+     * @param y - the scale factor on the Y axis
+     * @param z - the scale factor on the Z axis
+     */
     initScale(x, y, z) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_scale", [
             {
@@ -555,6 +743,12 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with a skew transformation
+     * with the given factors.
+     * @param xSkew - skew factor, in radians, on the X axis
+     * @param ySkew - skew factor, in radians, on the Y axis
+     */
     initSkew(xSkew, ySkew) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_skew", [
             {
@@ -577,6 +771,11 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Initializes a #graphene_matrix_t with a translation to the
+     * given coordinates.
+     * @param p - the translation coordinates
+     */
     initTranslate(p) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_matrix_init_translate", [
             {
@@ -600,6 +799,17 @@ export class Matrix {
         });
         return getObject(ptr, Matrix);
     }
+    /**
+     * Linearly interpolates the two given #graphene_matrix_t by
+     * interpolating the decomposed transformations separately.
+     *
+     * If either matrix cannot be reduced to their transformations
+     * then the interpolation cannot be performed, and this function
+     * will return an identity matrix.
+     * @param b - a #graphene_matrix_t
+     * @param factor - the linear interpolation factor
+     * @param res - return location for the
+     */
     interpolate(b, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_interpolate", [
             {
@@ -632,6 +842,10 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inverts the given matrix.
+     * @param res - return location for the
+     */
     inverse(res) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_inverse", [
             {
@@ -651,6 +865,10 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the given #graphene_matrix_t is compatible with an
+     * a 2D affine transformation matrix.
+     */
     is_2d() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_2d", [
             {
@@ -659,6 +877,9 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether a #graphene_matrix_t has a visible back face.
+     */
     isBackfaceVisible() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_backface_visible", [
             {
@@ -667,6 +888,9 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the given #graphene_matrix_t is the identity matrix.
+     */
     isIdentity() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_identity", [
             {
@@ -675,6 +899,9 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether a matrix is singular.
+     */
     isSingular() {
         return call("libgraphene-1.0.so.0", "graphene_matrix_is_singular", [
             {
@@ -683,6 +910,14 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Multiplies two #graphene_matrix_t.
+     *
+     * Matrix multiplication is not commutative in general; the order of the factors matters.
+     * The product of this multiplication is (`a` × @b)
+     * @param b - a #graphene_matrix_t
+     * @param res - return location for the matrix
+     */
     multiply(b, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_multiply", [
             {
@@ -711,6 +946,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compares the two given #graphene_matrix_t matrices and checks
+     * whether their values are within the given `epsilon` of each
+     * other.
+     * @param b - a #graphene_matrix_t
+     * @param epsilon - the threshold between the two matrices
+     */
     near(b, epsilon) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_near", [
             {
@@ -732,6 +974,10 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Normalizes the given #graphene_matrix_t.
+     * @param res - return location for the normalized matrix
+     */
     normalize(res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_normalize", [
             {
@@ -751,6 +997,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Applies a perspective of `depth` to the matrix.
+     * @param depth - the depth of the perspective
+     * @param res - return location for the
+     */
     perspective(depth, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_perspective", [
             {
@@ -774,6 +1025,12 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Prints the contents of a matrix to the standard error stream.
+     *
+     * This function is only useful for debugging; there are no guarantees
+     * made on the format of the output.
+     */
     print() {
         call("libgraphene-1.0.so.0", "graphene_matrix_print", [
             {
@@ -782,6 +1039,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Projects a #graphene_point_t using the matrix @m.
+     * @param p - a #graphene_point_t
+     * @param res - return location for the projected
+     */
     projectPoint(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_point", [
             {
@@ -810,6 +1072,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Projects all corners of a #graphene_rect_t using the given matrix.
+     *
+     * See also: graphene_matrix_project_point()
+     * @param r - a #graphene_rect_t
+     * @param res - return location for the projected
+     */
     projectRect(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_rect", [
             {
@@ -838,6 +1107,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Projects a #graphene_rect_t using the given matrix.
+     *
+     * The resulting rectangle is the axis aligned bounding rectangle capable
+     * of fully containing the projected rectangle.
+     * @param r - a #graphene_rect_t
+     * @param res - return location for the projected
+     */
     projectRectBounds(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_project_rect_bounds", [
             {
@@ -866,6 +1143,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation to @m, using the given `angle` and `axis` vector.
+     *
+     * This is the equivalent of calling graphene_matrix_init_rotate() and
+     * then multiplying the matrix `m` with the rotation matrix.
+     * @param angle - the rotation angle, in degrees
+     * @param axis - the rotation axis, as a #graphene_vec3_t
+     */
     rotate(angle, axis) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate", [
             {
@@ -887,6 +1172,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation to @m, using the given
+     * #graphene_euler_t.
+     * @param e - a rotation described by a #graphene_euler_t
+     */
     rotateEuler(e) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_euler", [
             {
@@ -904,6 +1194,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation to @m, using the given
+     * #graphene_quaternion_t.
+     *
+     * This is the equivalent of calling graphene_quaternion_to_matrix() and
+     * then multiplying `m` with the rotation matrix.
+     * @param q - a rotation described by a #graphene_quaternion_t
+     */
     rotateQuaternion(q) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_quaternion", [
             {
@@ -921,6 +1219,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation around the X axis to @m, using
+     * the given @angle.
+     *
+     * See also: graphene_matrix_rotate()
+     * @param angle - the rotation angle, in degrees
+     */
     rotateX(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_x", [
             {
@@ -933,6 +1238,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation around the Y axis to @m, using
+     * the given @angle.
+     *
+     * See also: graphene_matrix_rotate()
+     * @param angle - the rotation angle, in degrees
+     */
     rotateY(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_y", [
             {
@@ -945,6 +1257,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a rotation transformation around the Z axis to @m, using
+     * the given @angle.
+     *
+     * See also: graphene_matrix_rotate()
+     * @param angle - the rotation angle, in degrees
+     */
     rotateZ(angle) {
         call("libgraphene-1.0.so.0", "graphene_matrix_rotate_z", [
             {
@@ -957,6 +1276,16 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a scaling transformation to @m, using the three
+     * given factors.
+     *
+     * This is the equivalent of calling graphene_matrix_init_scale() and then
+     * multiplying the matrix `m` with the scale matrix.
+     * @param factorX - scaling factor on the X axis
+     * @param factorY - scaling factor on the Y axis
+     * @param factorZ - scaling factor on the Z axis
+     */
     scale(factorX, factorY, factorZ) {
         call("libgraphene-1.0.so.0", "graphene_matrix_scale", [
             {
@@ -977,6 +1306,10 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a skew of `factor` on the X and Y axis to the given matrix.
+     * @param factor - skew factor
+     */
     skewXy(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_xy", [
             {
@@ -989,6 +1322,10 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a skew of `factor` on the X and Z axis to the given matrix.
+     * @param factor - skew factor
+     */
     skewXz(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_xz", [
             {
@@ -1001,6 +1338,10 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a skew of `factor` on the Y and Z axis to the given matrix.
+     * @param factor - skew factor
+     */
     skewYz(factor) {
         call("libgraphene-1.0.so.0", "graphene_matrix_skew_yz", [
             {
@@ -1013,6 +1354,27 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Converts a #graphene_matrix_t to an affine transformation
+     * matrix, if the given matrix is compatible.
+     *
+     * The returned values have the following layout:
+     *
+     * |[<!-- language="plain" -->
+     * ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+     * ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+     * ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+     * ]|
+     *
+     * This function can be used to convert between a #graphene_matrix_t
+     * and an affine matrix type from other libraries.
+     * @param xx - return location for the xx member
+     * @param yx - return location for the yx member
+     * @param xy - return location for the xy member
+     * @param yy - return location for the yy member
+     * @param x_0 - return location for the x0 member
+     * @param y_0 - return location for the y0 member
+     */
     to_2d(xx, yx, xy, yy, x_0, y_0) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_to_2d", [
             {
@@ -1045,6 +1407,11 @@ export class Matrix {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Converts a #graphene_matrix_t to an array of floating point
+     * values.
+     * @param v - return location
+     */
     toFloat(v) {
         call("libgraphene-1.0.so.0", "graphene_matrix_to_float", [
             {
@@ -1060,6 +1427,16 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms each corner of a #graphene_rect_t using the given matrix @m.
+     *
+     * The result is the axis aligned bounding rectangle containing the coplanar
+     * quadrilateral.
+     *
+     * See also: graphene_matrix_transform_point()
+     * @param r - a #graphene_rect_t
+     * @param res - return location for the bounds
+     */
     transformBounds(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_bounds", [
             {
@@ -1088,6 +1465,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the vertices of a #graphene_box_t using the given matrix @m.
+     *
+     * The result is the axis aligned bounding box containing the transformed
+     * vertices.
+     * @param b - a #graphene_box_t
+     * @param res - return location for the bounds
+     */
     transformBox(b, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_box", [
             {
@@ -1116,6 +1501,17 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the given #graphene_point_t using the matrix @m.
+     *
+     * Unlike graphene_matrix_transform_vec3(), this function will take into
+     * account the fourth row vector of the #graphene_matrix_t when computing
+     * the dot product of each row vector of the matrix.
+     *
+     * See also: graphene_simd4x4f_point3_mul()
+     * @param p - a #graphene_point_t
+     * @param res - return location for the
+     */
     transformPoint(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_point", [
             {
@@ -1144,6 +1540,17 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the given #graphene_point3d_t using the matrix @m.
+     *
+     * Unlike graphene_matrix_transform_vec3(), this function will take into
+     * account the fourth row vector of the #graphene_matrix_t when computing
+     * the dot product of each row vector of the matrix.
+     *
+     * See also: graphene_simd4x4f_point3_mul()
+     * @param p - a #graphene_point3d_t
+     * @param res - return location for the result
+     */
     transformPoint3d(p, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_point3d", [
             {
@@ -1172,6 +1579,11 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transform a #graphene_ray_t using the given matrix @m.
+     * @param r - a #graphene_ray_t
+     * @param res - return location for the
+     */
     transformRay(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_ray", [
             {
@@ -1200,6 +1612,15 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms each corner of a #graphene_rect_t using the given matrix @m.
+     *
+     * The result is a coplanar quadrilateral.
+     *
+     * See also: graphene_matrix_transform_point()
+     * @param r - a #graphene_rect_t
+     * @param res - return location for the
+     */
     transformRect(r, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_rect", [
             {
@@ -1228,6 +1649,12 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms a #graphene_sphere_t using the given matrix @m. The
+     * result is the bounding sphere containing the transformed sphere.
+     * @param s - a #graphene_sphere_t
+     * @param res - return location for the bounds
+     */
     transformSphere(s, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_sphere", [
             {
@@ -1256,6 +1683,16 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the given #graphene_vec3_t using the matrix @m.
+     *
+     * This function will multiply the X, Y, and Z row vectors of the matrix `m` with the corresponding components of the vector @v. The W row vector will
+     * be ignored.
+     *
+     * See also: graphene_simd4x4f_vec3_mul()
+     * @param v - a #graphene_vec3_t
+     * @param res - return location for a #graphene_vec3_t
+     */
     transformVec3(v, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_vec3", [
             {
@@ -1284,6 +1721,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transforms the given #graphene_vec4_t using the matrix @m.
+     *
+     * See also: graphene_simd4x4f_vec4_mul()
+     * @param v - a #graphene_vec4_t
+     * @param res - return location for a #graphene_vec4_t
+     */
     transformVec4(v, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transform_vec4", [
             {
@@ -1312,6 +1756,14 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a translation transformation to `m` using the coordinates
+     * of the given #graphene_point3d_t.
+     *
+     * This is the equivalent of calling graphene_matrix_init_translate() and
+     * then multiplying `m` with the translation matrix.
+     * @param pos - a #graphene_point3d_t
+     */
     translate(pos) {
         call("libgraphene-1.0.so.0", "graphene_matrix_translate", [
             {
@@ -1329,6 +1781,10 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Transposes the given matrix.
+     * @param res - return location for the
+     */
     transpose(res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_transpose", [
             {
@@ -1348,6 +1804,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unprojects the given `point` using the `projection` matrix and
+     * a `modelview` matrix.
+     * @param modelview - a #graphene_matrix_t for the modelview matrix; this is
+     * @param point - a #graphene_point3d_t with the coordinates of the point
+     * @param res - return location for the unprojected
+     */
     unprojectPoint3d(modelview, point, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_unproject_point3d", [
             {
@@ -1385,6 +1848,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the transformation on the corners of a #graphene_rect_t using the
+     * given matrix, within the given axis aligned rectangular @bounds.
+     * @param r - a #graphene_rect_t
+     * @param bounds - the bounds of the transformation
+     * @param res - return location for the
+     */
     untransformBounds(r, bounds, res) {
         call("libgraphene-1.0.so.0", "graphene_matrix_untransform_bounds", [
             {
@@ -1422,6 +1892,13 @@ export class Matrix {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the transformation of a #graphene_point_t using the
+     * given matrix, within the given axis aligned rectangular @bounds.
+     * @param p - a #graphene_point_t
+     * @param bounds - the bounds of the transformation
+     * @param res - return location for the
+     */
     untransformPoint(p, bounds, res) {
         return call("libgraphene-1.0.so.0", "graphene_matrix_untransform_point", [
             {