Struct Matrix4 

pub struct Matrix4 { /* private fields */ }

• Matrix4 Module
• 2D Representation of a 4x4 Matrix
• It’s a row-major matrix.

Implementations

impl Matrix4

pub fn elements(&self) -> Vec<f64>

Examples found in repository

examples/matrix-example.rs (line 6)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

pub fn new() -> Matrix4

• Create a new Matrix4 with identity elements.

Examples found in repository

examples/matrix-example.rs (line 5)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

pub fn set( m0: f64, m1: f64, m2: f64, m3: f64, m4: f64, m5: f64, m6: f64, m7: f64, m8: f64, m9: f64, m10: f64, m11: f64, m12: f64, m13: f64, m14: f64, m15: f64, ) -> Matrix4

Examples found in repository

examples/matrix-example.rs (lines 13-18)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

examples/vector-example.rs (lines 99-104)

fn main() {
  // Create two Vector3 instances
  let mut v1 = Vector3::new(1.0, 2.0, 3.0);
  let v2 = Vector3::new(4.0, 5.0, 6.0);

  // Vector addition
  v1.add(&v2);
  println!("1. Elements of v1 after addition: ({}, {}, {})", v1.x, v1.y, v1.z);

  // Adding a Scalar value to a Vector3
  let mut v3 = Vector3::new(1.0, 3.0, 2.0);
  v3.add_scalar(2.0);
  println!("2. Adding a Scalar to v3, new elements: ({}, {}, {})", v3.x, v3.y, v3.z);

  // Subtracting a Vector3
  let mut v4 = Vector3::new(10.0, 9.0, 8.0);
  v4.subtract(&v2);
  println!("3. Elements of v4 after subtraction: ({}, {}, {})", v4.x, v4.y, v4.z);

  // Subtracting a Scalar value from a Vector3
  let mut v5 = Vector3::new(5.0, 6.0, 7.0);
  v5.subtract_scalar(3.0);
  println!("4. Subtracting a Scalar from v5, new elements: ({}, {}, {})", v5.x, v5.y, v5.z);

  // Cloning a Vector3
  let v6 = v1.clone();
  println!("5. Cloned Vector3 v6: ({}, {}, {})", v6.x, v6.y, v6.z);

  // Zeroing a Vector3
  let mut v7 = Vector3::new(8.0, 9.0, 10.0);
  v7.zero();
  println!("6. Zeroed Vector3 v7: ({}, {}, {})", v7.x, v7.y, v7.z);

  // Copying a Vector3
  let mut v8 = Vector3::new(2.0, 3.0, 4.0);
  v8.copy(&v6);
  println!("7. Copied Vector3 v8 from v6: ({}, {}, {})", v8.x, v8.y, v8.z);

  // Multiplying a Vector3 by a scalar
  let mut v9 = Vector3::new(1.0, 2.0, 3.0);
  v9.multiply_scalar(2.0);
  println!("8. v9 after multiplying by scalar: ({}, {}, {})", v9.x, v9.y, v9.z);

  // Multiply two vectors
  let v10 = Vector3::new(2.0, 3.0, 4.0);
  let v11 = Vector3::new(5.0, 6.0, 7.0);
  let mut v12 = v10.clone();
  v12.multiply(&v11);
  println!("9. v12 after multiplying v10 and v11: ({}, {}, {})", v12.x, v12.y, v12.z);

  // Divide a Vector3 by a scalar
  let mut v13 = Vector3::new(10.0, 20.0, 30.0);
  v13.divide_scalar(2.0);
  println!("10. v13 after dividing by scalar: ({}, {}, {})", v13.x, v13.y, v13.z);

  // Divide two vectors
  let mut v14 = Vector3::new(20.0, 30.0, 40.0);
  let v15 = Vector3::new(2.0, 3.0, 4.0);
  v14.divide(&v15);
  println!("11. v14 after dividing by v15: ({}, {}, {})", v14.x, v14.y, v14.z);

  // Negate a Vector3
  let mut v16 = Vector3::new(1.0, -2.0, 3.0);
  v16.negate();
  println!("12. v16 after negation: ({}, {}, {})", v16.x, v16.y, v16.z);

  // Dot product of two vectors
  let v17 = Vector3::new(1.0, 2.0, 3.0);
  let v18 = Vector3::new(4.0, 5.0, 6.0);
  let dot_product = v17.dot(&v18);
  println!("13. Dot product of v17 and v18: {}", dot_product);

  // Magnitude of a Vector3
  let v19 = Vector3::new(3.0, 4.0, 0.0);
  let magnitude = v19.magnitude();
  println!("14. Magnitude/Length of v19: {}", magnitude);

  // Normalize a Vector3
  let mut v20 = Vector3::new(3.0, 4.0, 0.0);
  v20.normalize();
  println!("15. Normalized v20: ({}, {}, {})", v20.x, v20.y, v20.z);

  // Cross product of two vectors
  let v21 = Vector3::new(1.0, 0.0, 0.0);
  let v22 = Vector3::new(0.0, 1.0, 0.0);
  let v23 = v21.cross(&v22);
  println!("16. Cross product of v21 and v22: ({}, {}, {})", v23.x, v23.y, v23.z);

  // Distance between two vectors
  let v24 = Vector3::new(1.0, 2.0, 3.0);
  let v25 = Vector3::new(4.0, 5.0, 6.0);
  let distance = v24.distance(&v25);
  println!("17. Distance between v24 and v25: {}", distance);

  // Apply a transformation matrix with translation at 2 in x axis, to a vector
  let mut v26 = Vector3::new(1.0, 2.0, 3.0);
  let matrix = openmaths::Matrix4::set(
    1.0, 0.0, 0.0, 2.0,
    0.0, 1.0, 0.0, 5.0,
    0.0, 0.0, 1.0, 0.0,
    0.0, 0.0, 0.0, 1.0
  );
  v26.apply_matrix4(matrix);
  println!("18. v26 after applying transformation matrix: ({}, {}, {})", v26.x, v26.y, v26.z);
}

pub fn clone(&self) -> Matrix4

• Clone the Matrix4 instance and return a new one.

Examples found in repository

examples/matrix-example.rs (line 62)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

pub fn identity(&mut self)

• Sets the matrix element to create an identity matrix.

Examples found in repository

examples/matrix-example.rs (line 9)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

pub fn determinant(&self) -> f64

• Determinant for a 4x4 matrix.
• https://en.wikipedia.org/wiki/Determinant

Examples found in repository

examples/matrix-example.rs (line 41)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

pub fn adjucate(&self) -> Matrix4

pub fn inverse(&self) -> Matrix4

• Inverse of a matrix
• Returns a new Matrix4 instance.
• If the determinant is zero, it returns a zero matrix.
• It can be checked with is_zero() method.

pub fn multiply(&self, other: &Matrix4) -> Matrix4

• Multiply this matrix with another Matrix4
• Returns a new Matrix4 instance

pub fn add(&self, incoming: &Matrix4) -> Matrix4

• Add another Matrix4 to this one.
• Returns a new Matrix4 instance with the result.

pub fn subtract(&self, incoming: &Matrix4) -> Matrix4

• Subtract another Matrix4 from this one.
• Returns a new Matrix4 instance with the result.

pub fn flatten(&self) -> Vec<f64>

• Flatten the matrix into a vector of f64.

pub fn get_element_at(&self, index: usize) -> Option<f64>

• Get the element at a specific index in the flattened matrix.

pub fn is_zero(&self) -> bool

• Check if the matrix is a zero matrix.

pub fn is_identity(&self) -> bool

• Check if the matrix is an identity matrix.

pub fn transpose(&self) -> Matrix4

• Create a Transpose of the matrix.
• Returns a new Matrix4 instance.

Examples found in repository

examples/matrix-example.rs (line 62)

fn main() {
    // Create a new Matrix4 instance
    let mut m1 = Matrix4::new();
    println!("1. Initial Matrix4 m1: {:?}", m1.elements());

    // Set m1 to identity matrix
    m1.identity();
    println!("2. Identity Matrix4 m1: {:?}", m1.elements());

    // Create another Matrix4 instance with specific elements
    let m2 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );

    println!("3. Matrix4 m2: {:?}", m2.elements());

    // // Multiply two matrices
    // let m3 = m1.clone().multiply(&m2);
    // println!("4. Result of multiplying m1 and m2: {:?}", m3.elements);

    // // Add two matrices
    // let m4 = m1.clone().add(&m2);
    // println!("5. Result of adding m1 and m2: {:?}", m4.elements);

    // // Subtract two matrices
    // let m5 = m2.clone().subtract(&m1);
    // println!("6. Result of subtracting m1 from m2: {:?}", m5.elements);

    // Determinant of a matrix m6
    let m6 = Matrix4::set(
        1.0, 2.0, 3.0, 4.0,
        5.0, 6.0, 7.0, 8.0,
        9.0, 10.0, 11.0, 12.0,
        13.0, 14.0, 15.0, 16.0,
    );
    let det = m6.determinant();
    println!("7. Determinant of m6: {}", det);

    // // Adjugate of a matrix
    // let adj = m6.adjucate();
    // println!("8. Adjugate of m6: {:?}", adj.elements);

    // // Inverse of a matrix
    // let m7 = m6.clone().inverse();
    // println!("9. Inverse of m6: {:?}", m7.elements);

    // // Check if the inverse is correct by multiplying m6 with its inverse
    // let m6_cloned = m6.clone();
    // let m6_inverse_multiplied = m6_cloned.multiply(&m7);
    // println!("10. Result of multiplying m6 with its inverse: {:?}", m6_inverse_multiplied.elements);
    
    // // Check if the inverse multiplication gives identity matrix
    // let identity_check = m6_inverse_multiplied.is_identity();
    // println!("11. Is the result an identity matrix? - {}", identity_check);

    // Transpose of a matrix
    let m8 = m2.clone().transpose();
    println!("12. Transpose of m2: {:?}", m8.elements());
}

Trait Implementations

impl Clone for Matrix4

fn clone(&self) -> Matrix4

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Matrix4

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Matrix4> for JsValue

fn from(value: Matrix4) -> Self

Converts to this type from the input type.

impl FromWasmAbi for Matrix4

type Abi = u32

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for Matrix4

type Abi = u32

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for Matrix4

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRef<Matrix4>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for Matrix4

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for Matrix4

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl RefFromWasmAbi for Matrix4

type Abi = u32

The Wasm ABI type references to Self are recovered from.

type Anchor = RcRef<Matrix4>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for Matrix4

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRefMut<Matrix4>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl Serialize for Matrix4

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFromJsValue for Matrix4

type Error = JsValue

The type returned in the event of a conversion error.

fn try_from_js_value(value: JsValue) -> Result<Self, Self::Error>

Performs the conversion.

impl VectorFromWasmAbi for Matrix4

type Abi = <Box<[JsValue]> as FromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[Matrix4]>

impl VectorIntoJsValue for Matrix4

fn vector_into_jsvalue(vector: Box<[Matrix4]>) -> JsValue

impl VectorIntoWasmAbi for Matrix4

type Abi = <Box<[JsValue]> as IntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[Matrix4]>) -> Self::Abi

impl WasmDescribe for Matrix4

fn describe()

impl WasmDescribeVector for Matrix4

fn describe_vector()

impl SupportsConstructor for Matrix4

impl SupportsInstanceProperty for Matrix4

impl SupportsStaticProperty for Matrix4