Struct graphene::Matrix

pub fn decompose(&self) -> Option<(Vec3, Vec3, Quaternion, Vec3, Vec4)>

Decomposes a transformation matrix into its component transformations.

The algorithm for decomposing a matrix is taken from the CSS3 Transforms specification; specifically, the decomposition code is based on the equivalent code published in “Graphics Gems II”, edited by Jim Arvo, and available online.

Returns

true if the matrix could be decomposed

`translate`

the translation vector

`scale`

the scale vector

`rotate`

the rotation quaternion

`shear`

the shear vector

`perspective`

the perspective vector

pub fn determinant(&self) -> f32

Computes the determinant of the given matrix.

Returns

the value of the determinant

pub fn equal_fast(&self, b: &Matrix) -> bool

Checks whether the two given Matrix 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 near(). For instance:

⚠️ The following code is in 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
    }

`b`

Returns

true if the matrices are equal. and false otherwise

pub fn row(&self, index_: u32) -> Vec4

Retrieves the given row vector at index_ inside a matrix.

`index_`

the index of the row vector, between 0 and 3

Returns

`res`

return location for the Vec4 that is used to store the row vector

pub fn value(&self, row: u32, col: u32) -> f32

Retrieves the value at the given row and col index.

`row`

the row index

`col`

the column index

Returns

the value at the given indices

pub fn x_scale(&self) -> f32

Retrieves the scaling factor on the X axis in self.

Returns

the value of the scaling factor

pub fn x_translation(&self) -> f32

Retrieves the translation component on the X axis from self.

Returns

the translation component

pub fn y_scale(&self) -> f32

Retrieves the scaling factor on the Y axis in self.

Returns

the value of the scaling factor

pub fn y_translation(&self) -> f32

Retrieves the translation component on the Y axis from self.

Returns

the translation component

pub fn z_scale(&self) -> f32

Retrieves the scaling factor on the Z axis in self.

Returns

the value of the scaling factor

pub fn z_translation(&self) -> f32

Retrieves the translation component on the Z axis from self.

Returns

the translation component

pub fn interpolate(&self, b: &Matrix, factor: f64) -> Matrix

Linearly interpolates the two given Matrix 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.

`b`

`factor`

the linear interpolation factor

Returns

`res`

return location for the interpolated matrix

pub fn inverse(&self) -> Option<Matrix>

Inverts the given matrix.

Returns

true if the matrix is invertible

`res`

return location for the inverse matrix

pub fn is_2d(&self) -> bool

Checks whether the given Matrix is compatible with an a 2D affine transformation matrix.

Returns

true if the matrix is compatible with an affine transformation matrix

pub fn is_backface_visible(&self) -> bool

Checks whether a Matrix has a visible back face.

Returns

true if the back face of the matrix is visible

pub fn is_identity(&self) -> bool

Checks whether the given Matrix is the identity matrix.

Returns

true if the matrix is the identity matrix

pub fn is_singular(&self) -> bool

Checks whether a matrix is singular.

Returns

true if the matrix is singular

pub fn multiply(&self, b: &Matrix) -> Matrix

Multiplies two Matrix.

Matrix multiplication is not commutative in general; the order of the factors matters. The product of this multiplication is (self × b)

`b`

Returns

`res`

return location for the matrix result

pub fn near(&self, b: &Matrix, epsilon: f32) -> bool

Compares the two given Matrix matrices and checks whether their values are within the given epsilon of each other.

`b`

`epsilon`

the threshold between the two matrices

Returns

true if the two matrices are near each other, and false otherwise

pub fn normalize(&self) -> Matrix

Normalizes the given Matrix.

Returns

`res`

return location for the normalized matrix

pub fn perspective(&self, depth: f32) -> Matrix

Applies a perspective of depth to the matrix.

`depth`

the depth of the perspective

Returns

`res`

return location for the perspective matrix

pub fn print(&self)

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.

pub fn project_point(&self, p: &Point) -> Point

Projects a Point using the matrix self.

`p`

a Point

Returns

`res`

return location for the projected point

pub fn project_rect(&self, r: &Rect) -> Quad

Projects all corners of a Rect using the given matrix.

`r`

Returns

`res`

return location for the projected rectangle

pub fn project_rect_bounds(&self, r: &Rect) -> Rect

Projects a Rect using the given matrix.

The resulting rectangle is the axis aligned bounding rectangle capable of fully containing the projected rectangle.

`r`

Returns

`res`

return location for the projected rectangle

pub fn rotate(&mut self, angle: f32, axis: &Vec3)

Adds a rotation transformation to self, using the given angle and axis vector.

This is the equivalent of calling new_rotate() and then multiplying the matrix self with the rotation matrix.

`angle`

the rotation angle, in degrees

`axis`

the rotation axis, as a Vec3

pub fn rotate_euler(&mut self, e: &Euler)

Adds a rotation transformation to self, using the given Euler.

`e`

a rotation described by a Euler

pub fn rotate_quaternion(&mut self, q: &Quaternion)

Adds a rotation transformation to self, using the given Quaternion.

This is the equivalent of calling Quaternion::to_matrix() and then multiplying self with the rotation matrix.

`q`

a rotation described by a Quaternion

pub fn rotate_x(&mut self, angle: f32)

Adds a rotation transformation around the X axis to self, using the given angle.

`angle`

the rotation angle, in degrees

pub fn rotate_y(&mut self, angle: f32)

Adds a rotation transformation around the Y axis to self, using the given angle.

`angle`

the rotation angle, in degrees

pub fn rotate_z(&mut self, angle: f32)

Adds a rotation transformation around the Z axis to self, using the given angle.

`angle`

the rotation angle, in degrees

pub fn scale(&mut self, factor_x: f32, factor_y: f32, factor_z: f32)

Adds a scaling transformation to self, using the three given factors.

This is the equivalent of calling new_scale() and then multiplying the matrix self with the scale matrix.

`factor_x`

scaling factor on the X axis

`factor_y`

scaling factor on the Y axis

`factor_z`

scaling factor on the Z axis

pub fn skew_xy(&mut self, factor: f32)

Adds a skew of factor on the X and Y axis to the given matrix.

`factor`

skew factor

pub fn skew_xz(&mut self, factor: f32)

Adds a skew of factor on the X and Z axis to the given matrix.

`factor`

skew factor

pub fn skew_yz(&mut self, factor: f32)

Adds a skew of factor on the Y and Z axis to the given matrix.

`factor`

skew factor

pub fn to_2d(&self) -> Option<(f64, f64, f64, f64, f64, f64)>

Converts a Matrix to an affine transformation matrix, if the given matrix is compatible.

The returned values have the following layout:

⚠️ The following code is in 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 Matrix and an affine matrix type from other libraries.

Returns

true if the matrix is compatible with an affine transformation matrix

`xx`

return location for the xx member

`yx`

return location for the yx member

`xy`

return location for the xy member

`yy`

return location for the yy member

`x_0`

return location for the x0 member

`y_0`

return location for the y0 member

pub fn transform_bounds(&self, r: &Rect) -> Rect

Transforms each corner of a Rect using the given matrix self.

The result is the axis aligned bounding rectangle containing the coplanar quadrilateral.

`r`

Returns

`res`

return location for the bounds of the transformed rectangle

pub fn transform_box(&self, b: &Box) -> Box

Transforms the vertices of a Box using the given matrix self.

The result is the axis aligned bounding box containing the transformed vertices.

`b`

a Box

Returns

`res`

return location for the bounds of the transformed box

pub fn transform_point(&self, p: &Point) -> Point

Transforms the given Point using the matrix self.

Unlike transform_vec3(), this function will take into account the fourth row vector of the Matrix when computing the dot product of each row vector of the matrix.

See also: graphene_simd4x4f_point3_mul()

`p`

a Point

Returns

`res`

return location for the transformed Point

pub fn transform_point3d(&self, p: &Point3D) -> Point3D

Transforms the given Point3D using the matrix self.

Unlike transform_vec3(), this function will take into account the fourth row vector of the Matrix when computing the dot product of each row vector of the matrix.

See also: graphene_simd4x4f_point3_mul()

`p`

a Point3D

Returns

`res`

return location for the result

pub fn transform_ray(&self, r: &Ray) -> Ray

Transform a Ray using the given matrix self.

`r`

a Ray

Returns

`res`

return location for the transformed ray

pub fn transform_rect(&self, r: &Rect) -> Quad

Transforms each corner of a Rect using the given matrix self.

The result is a coplanar quadrilateral.

`r`

Returns

`res`

return location for the transformed quad

pub fn transform_sphere(&self, s: &Sphere) -> Sphere

Transforms a Sphere using the given matrix self. The result is the bounding sphere containing the transformed sphere.

`s`

a Sphere

Returns

`res`

return location for the bounds of the transformed sphere

pub fn transform_vec3(&self, v: &Vec3) -> Vec3

Transforms the given Vec3 using the matrix self.

This function will multiply the X, Y, and Z row vectors of the matrix self with the corresponding components of the vector v. The W row vector will be ignored.

See also: graphene_simd4x4f_vec3_mul()

`v`

a Vec3

Returns

`res`

return location for a Vec3

pub fn transform_vec4(&self, v: &Vec4) -> Vec4

Transforms the given Vec4 using the matrix self.

See also: graphene_simd4x4f_vec4_mul()

`v`

a Vec4

Returns

`res`

return location for a Vec4

pub fn translate(&mut self, pos: &Point3D)

Adds a translation transformation to self using the coordinates of the given Point3D.

This is the equivalent of calling new_translate() and then multiplying self with the translation matrix.

`pos`

a Point3D

pub fn transpose(&self) -> Matrix

Transposes the given matrix.

Returns

`res`

return location for the transposed matrix

pub fn unproject_point3d(&self, modelview: &Matrix, point: &Point3D) -> Point3D

Unprojects the given point using the self matrix and a modelview matrix.

`modelview`

a Matrix for the modelview matrix; this is the inverse of the modelview used when projecting the point

`point`

a Point3D with the coordinates of the point

Returns

`res`

return location for the unprojected point

pub fn untransform_bounds(&self, r: &Rect, bounds: &Rect) -> Rect

Undoes the transformation on the corners of a Rect using the given matrix, within the given axis aligned rectangular bounds.

`r`

`bounds`

the bounds of the transformation

Returns

`res`

return location for the untransformed rectangle

pub fn untransform_point(&self, p: &Point, bounds: &Rect) -> Option<Point>

Undoes the transformation of a Point using the given matrix, within the given axis aligned rectangular bounds.

`p`

a Point

`bounds`

the bounds of the transformation

Returns

true if the point was successfully untransformed

`res`

return location for the untransformed point

source §

impl Matrix

pub fn from_2d(xx: f64, yx: f64, xy: f64, yy: f64, x_0: f64, y_0: f64) -> Self

Initializes a Matrix from the values of an affine transformation matrix.

The arguments map to the following matrix layout:

⚠️ The following code is in 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 Matrix.

`xx`

the xx member

`yx`

the yx member

`xy`

the xy member

`yy`

the yy member

`x_0`

the x0 member

`y_0`

the y0 member

Returns

the initialized matrix

pub fn from_float(v: [f32; 16]) -> Self

Initializes a Matrix with the given array of floating point values.

`v`

an array of at least 16 floating point values

Returns

the initialized matrix

pub fn from_vec4(v0: &Vec4, v1: &Vec4, v2: &Vec4, v3: &Vec4) -> Self

Initializes a Matrix with the given four row vectors.

`v0`

the first row vector

`v1`

the second row vector

`v2`

the third row vector

`v3`

the fourth row vector

Returns

the initialized matrix

pub fn new_frustum( left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32 ) -> Self

Initializes a Matrix compatible with Frustum.

`left`

distance of the left clipping plane

`right`

distance of the right clipping plane

`bottom`

distance of the bottom clipping plane

`top`

distance of the top clipping plane

`z_near`

distance of the near clipping plane

`z_far`

distance of the far clipping plane

Returns

the initialized matrix

pub fn new_identity() -> Self

Initializes a Matrix with the identity matrix.

Returns

the initialized matrix