Vendor dependencies for 0.3.0 release

vendor/glam/benches/affine2.rs

@@ -0,0 +1,79 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Affine2;
+use std::ops::Mul;
+use support::*;
+
+pub fn random_srt_affine2(rng: &mut PCG32) -> Affine2 {
+    Affine2::from_scale_angle_translation(
+        random_nonzero_vec2(rng),
+        random_radians(rng),
+        random_vec2(rng),
+    )
+}
+
+bench_unop!(affine2_inverse, "affine2 inverse", op => inverse, from => random_srt_affine2);
+bench_binop!(
+    affine2_transform_point2,
+    "affine2 transform point2",
+    op => transform_point2,
+    from1 => random_srt_affine2,
+    from2 => random_vec2
+);
+
+bench_binop!(
+    affine2_transform_vector2,
+    "affine2 transform vector2",
+    op => transform_vector2,
+    from1 => random_srt_affine2,
+    from2 => random_vec2
+);
+bench_binop!(affine2_mul_affine2, "affine2 mul affine2", op => mul, from => random_srt_affine2);
+bench_binop!(affine2_mul_mat3, "affine2 mul mat3", op => mul, from1 => random_srt_affine2, from2 => random_srt_mat3);
+bench_binop!(mat3_mul_affine2, "mat3 mul affine2", op => mul, from1 => random_srt_mat3, from2 => random_srt_affine2);
+
+pub fn affine2_from_srt(c: &mut Criterion) {
+    use glam::Vec2;
+    const SIZE: usize = 1 << 13;
+    let mut rng = support::PCG32::default();
+    let inputs = criterion::black_box(
+        (0..SIZE)
+            .map(|_| {
+                (
+                    random_nonzero_vec2(&mut rng),
+                    random_radians(&mut rng),
+                    random_vec2(&mut rng),
+                )
+            })
+            .collect::<Vec<(Vec2, f32, Vec2)>>(),
+    );
+    let mut outputs = vec![Affine2::default(); SIZE];
+    let mut i = 0;
+    c.bench_function("affine2 from srt", |b| {
+        b.iter(|| {
+            i = (i + 1) & (SIZE - 1);
+            unsafe {
+                let data = inputs.get_unchecked(i);
+                *outputs.get_unchecked_mut(i) =
+                    Affine2::from_scale_angle_translation(data.0, data.1, data.2);
+            }
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    affine2_inverse,
+    affine2_transform_point2,
+    affine2_transform_vector2,
+    affine2_mul_affine2,
+    affine2_mul_mat3,
+    mat3_mul_affine2,
+    affine2_from_srt,
+);
+
+criterion_main!(benches);

vendor/glam/benches/affine3.rs

@@ -0,0 +1,117 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Affine3A;
+use std::ops::Mul;
+use support::*;
+
+pub fn random_srt_affine3a(rng: &mut PCG32) -> Affine3A {
+    Affine3A::from_scale_rotation_translation(
+        random_nonzero_vec3(rng),
+        random_quat(rng),
+        random_vec3(rng),
+    )
+}
+
+bench_unop!(affine3a_inverse, "affine3a inverse", op => inverse, from => random_srt_affine3a);
+
+bench_binop!(
+    affine3a_transform_point3,
+    "affine3a transform point3",
+    op => transform_point3,
+    from1 => random_srt_affine3a,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    affine3a_transform_vector3,
+    "affine3a transform vector3",
+    op => transform_vector3,
+    from1 => random_srt_affine3a,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    affine3a_transform_point3a,
+    "affine3a transform point3a",
+    op => transform_point3a,
+    from1 => random_srt_affine3a,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    affine3a_transform_vector3a,
+    "affine3a transform vector3a",
+    op => transform_vector3a,
+    from1 => random_srt_affine3a,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    affine3a_mul_affine3a,
+    "affine3a mul affine3a",
+    op => mul,
+    from => random_srt_affine3a
+);
+
+bench_binop!(affine3a_mul_mat4,
+    "affine3a mul mat4",
+    op => mul,
+    from1 => random_srt_affine3a,
+    from2 => random_srt_mat4
+);
+
+bench_binop!(
+    mat4_mul_affine3a,
+    "mat4 mul affine3a",
+    op => mul,
+    from1 => random_srt_mat4,
+    from2 => random_srt_affine3a
+);
+
+pub fn affine3a_from_srt(c: &mut Criterion) {
+    use glam::{Quat, Vec3};
+    const SIZE: usize = 1 << 13;
+    let mut rng = support::PCG32::default();
+    let inputs = criterion::black_box(
+        (0..SIZE)
+            .map(|_| {
+                (
+                    random_nonzero_vec3(&mut rng),
+                    random_quat(&mut rng),
+                    random_vec3(&mut rng),
+                )
+            })
+            .collect::<Vec<(Vec3, Quat, Vec3)>>(),
+    );
+    let mut outputs = vec![Affine3A::IDENTITY; SIZE];
+    let mut i = 0;
+    c.bench_function("affine3a from srt", |b| {
+        b.iter(|| {
+            i = (i + 1) & (SIZE - 1);
+            unsafe {
+                let data = inputs.get_unchecked(i);
+                *outputs.get_unchecked_mut(i) =
+                    Affine3A::from_scale_rotation_translation(data.0, data.1, data.2);
+            }
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    affine3a_from_srt,
+    affine3a_inverse,
+    affine3a_mul_affine3a,
+    affine3a_mul_mat4,
+    affine3a_transform_point3,
+    affine3a_transform_point3a,
+    affine3a_transform_vector3,
+    affine3a_transform_vector3a,
+    mat4_mul_affine3a,
+);
+
+criterion_main!(benches);

vendor/glam/benches/iai.rs

@@ -0,0 +1,282 @@
+#![allow(clippy::all)]
+
+use core::hint::black_box;
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+
+use glam::{BVec3A, Mat2, Mat3A, Mat4, Quat, Vec2, Vec3A, Vec4};
+
+#[cfg(feature = "scalar-math")]
+use glam::BVec4 as BVec4A;
+
+#[cfg(not(feature = "scalar-math"))]
+use glam::BVec4A;
+
+#[inline]
+fn mat2() -> Mat2 {
+    black_box(Mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]))
+}
+
+#[inline]
+fn mat3a() -> Mat3A {
+    black_box(Mat3A::from_cols_array(&[
+        1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0,
+    ]))
+}
+
+#[inline]
+fn mat4() -> Mat4 {
+    black_box(Mat4::from_cols_array(&[
+        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,
+    ]))
+}
+
+#[inline]
+fn quat() -> Quat {
+    black_box(Quat::from_xyzw(0.0, 0.0, 0.0, 1.0))
+}
+
+#[inline]
+fn vec2() -> Vec2 {
+    black_box(Vec2::new(1.0, 2.0))
+}
+
+#[inline]
+fn vec3a() -> Vec3A {
+    black_box(Vec3A::new(1.0, 2.0, 3.0))
+}
+
+#[inline]
+fn bvec3a() -> BVec3A {
+    black_box(BVec3A::new(true, false, true))
+}
+
+#[inline]
+fn vec4() -> Vec4 {
+    black_box(Vec4::new(1.0, 2.0, 3.0, 4.0))
+}
+
+#[inline]
+fn bvec4a() -> BVec4A {
+    black_box(BVec4A::new(true, false, true, false))
+}
+
+#[library_benchmark]
+#[bench::args(mat2())]
+fn mat2_determinant(m: Mat2) -> f32 {
+    black_box(m.determinant())
+}
+
+#[library_benchmark]
+#[bench::args(mat2())]
+fn mat2_inverse(m: Mat2) -> Mat2 {
+    black_box(m.inverse())
+}
+
+#[library_benchmark]
+#[bench::args(mat2())]
+fn mat2_transpose(m: Mat2) -> Mat2 {
+    black_box(m.transpose())
+}
+
+#[library_benchmark]
+#[bench::args(mat2(), mat2())]
+fn mat2_mul_mat2(m1: Mat2, m2: Mat2) -> Mat2 {
+    black_box(m1 * m2)
+}
+
+#[library_benchmark]
+#[bench::args(mat2(), vec2())]
+fn mat2_mul_vec2(m: Mat2, v: Vec2) -> Vec2 {
+    black_box(m * v)
+}
+
+#[library_benchmark]
+#[bench::args(mat3a())]
+fn mat3a_determinant(m: Mat3A) -> f32 {
+    black_box(m.determinant())
+}
+
+#[library_benchmark]
+#[bench::args(mat3a())]
+fn mat3a_inverse(m: Mat3A) -> Mat3A {
+    black_box(m.inverse())
+}
+
+#[library_benchmark]
+#[bench::args(mat3a())]
+fn mat3a_transpose(m: Mat3A) -> Mat3A {
+    black_box(m.transpose())
+}
+
+#[library_benchmark]
+#[bench::args(mat3a(), mat3a())]
+fn mat3a_mul_mat3a(m1: Mat3A, m2: Mat3A) -> Mat3A {
+    black_box(m1 * m2)
+}
+
+#[library_benchmark]
+#[bench::args(mat3a(), vec3a())]
+fn mat3a_mul_vec3a(m: Mat3A, v: Vec3A) -> Vec3A {
+    black_box(m * v)
+}
+
+#[library_benchmark]
+#[bench::args(mat4())]
+fn mat4_determinant(m: Mat4) -> f32 {
+    black_box(m.determinant())
+}
+
+#[library_benchmark]
+#[bench::args(mat4())]
+fn mat4_inverse(m: Mat4) -> Mat4 {
+    black_box(m.inverse())
+}
+
+#[library_benchmark]
+#[bench::args(mat4())]
+fn mat4_transpose(m: Mat4) -> Mat4 {
+    black_box(m.transpose())
+}
+
+#[library_benchmark]
+#[bench::args(mat4(), mat4())]
+fn mat4_mul_mat4(m1: Mat4, m2: Mat4) -> Mat4 {
+    black_box(m1 * m2)
+}
+
+#[library_benchmark]
+#[bench::args(mat4(), vec4())]
+fn mat4_mul_vec4(m: Mat4, v: Vec4) -> Vec4 {
+    black_box(m * v)
+}
+
+#[library_benchmark]
+#[bench::args(quat(), quat())]
+fn quat_mul_quat(q1: Quat, q2: Quat) -> Quat {
+    black_box(q1 * q2)
+}
+
+#[library_benchmark]
+#[bench::args(quat(), vec3a())]
+fn quat_mul_vec3a(q: Quat, v: Vec3A) -> Vec3A {
+    black_box(q * v)
+}
+
+#[library_benchmark]
+#[bench::args(vec3a(), vec3a())]
+fn vec3a_dot(v1: Vec3A, v2: Vec3A) -> f32 {
+    black_box(v1.dot(v2))
+}
+
+#[library_benchmark]
+#[bench::args(vec3a(), vec3a())]
+fn vec3a_cross(v1: Vec3A, v2: Vec3A) -> Vec3A {
+    black_box(v1.cross(v2))
+}
+
+#[library_benchmark]
+#[bench::args(vec3a())]
+fn vec3a_length(v: Vec3A) -> f32 {
+    black_box(v.length())
+}
+
+#[library_benchmark]
+#[bench::args(vec3a())]
+fn vec3a_normalize(v: Vec3A) -> Vec3A {
+    black_box(v.normalize())
+}
+
+#[library_benchmark]
+#[bench::args(bvec3a(), vec3a(), vec3a())]
+fn vec3a_select(b: BVec3A, v1: Vec3A, v2: Vec3A) -> Vec3A {
+    black_box(Vec3A::select(b, v1, v2))
+}
+
+#[library_benchmark]
+#[bench::args(vec4(), vec4())]
+fn vec4_dot(v1: Vec4, v2: Vec4) -> f32 {
+    black_box(v1.dot(v2))
+}
+
+#[library_benchmark]
+#[bench::args(vec4())]
+fn vec4_length(v: Vec4) -> f32 {
+    black_box(v.length())
+}
+
+#[library_benchmark]
+#[bench::args(vec4())]
+fn vec4_normalize(v: Vec4) -> Vec4 {
+    black_box(v.normalize())
+}
+
+#[library_benchmark]
+#[bench::args(bvec4a(), vec4(), vec4())]
+fn vec4_select(b: BVec4A, v1: Vec4, v2: Vec4) -> Vec4 {
+    black_box(Vec4::select(b, v1, v2))
+}
+
+library_benchmark_group!(
+    name = bench_mat2;
+    benchmarks =
+        mat2_determinant,
+        mat2_inverse,
+        mat2_mul_mat2,
+        mat2_mul_vec2,
+        mat2_transpose,
+);
+
+library_benchmark_group!(
+    name = bench_mat3a;
+    benchmarks =
+        mat3a_determinant,
+        mat3a_inverse,
+        mat3a_mul_mat3a,
+        mat3a_mul_vec3a,
+        mat3a_transpose,
+);
+
+library_benchmark_group!(
+    name = bench_mat4;
+    benchmarks =
+        mat4_determinant,
+        mat4_inverse,
+        mat4_mul_mat4,
+        mat4_mul_vec4,
+        mat4_transpose,
+);
+
+library_benchmark_group!(
+    name = bench_quat;
+    benchmarks =
+        quat_mul_quat,
+        quat_mul_vec3a,
+);
+
+library_benchmark_group!(
+    name = bench_vec3a;
+    benchmarks =
+        vec3a_dot,
+        vec3a_cross,
+        vec3a_length,
+        vec3a_normalize,
+        vec3a_select,
+);
+
+library_benchmark_group!(
+    name = bench_vec4;
+    benchmarks =
+        vec4_dot,
+        vec4_length,
+        vec4_normalize,
+        vec4_select,
+);
+
+main!(
+    library_benchmark_groups = bench_mat2,
+    bench_mat3a,
+    bench_mat4,
+    bench_quat,
+    bench_vec3a,
+    bench_vec4
+);

vendor/glam/benches/mat2.rs

@@ -0,0 +1,42 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::ops::Mul;
+use support::*;
+
+bench_binop!(
+    mat2_mul_vec2,
+    "mat2 mul vec2",
+    op => mul,
+    from1 => random_mat2,
+    from2 => random_vec2
+);
+
+bench_unop!(
+    mat2_transpose,
+    "mat2 transpose",
+    op => transpose,
+    from => random_mat2
+);
+bench_unop!(
+    mat2_determinant,
+    "mat2 determinant",
+    op => determinant,
+    from => random_mat2
+);
+bench_unop!(mat2_inverse, "mat2 inverse", op => inverse, from => random_mat2);
+bench_binop!(mat2_mul_mat2, "mat2 mul mat2", op => mul, from => random_mat2);
+
+criterion_group!(
+    benches,
+    mat2_transpose,
+    mat2_determinant,
+    mat2_inverse,
+    mat2_mul_vec2,
+    mat2_mul_mat2,
+);
+
+criterion_main!(benches);

vendor/glam/benches/mat3.rs

@@ -0,0 +1,72 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Mat3;
+use std::ops::Mul;
+use support::*;
+
+bench_unop!(
+    mat3_transpose,
+    "mat3 transpose",
+    op => transpose,
+    from => random_mat3
+);
+bench_unop!(
+    mat3_determinant,
+    "mat3 determinant",
+    op => determinant,
+    from => random_mat3
+);
+bench_unop!(mat3_inverse, "mat3 inverse", op => inverse, from => random_mat3);
+bench_binop!(mat3_mul_mat3, "mat3 mul mat3", op => mul, from => random_mat3);
+bench_from_ypr!(mat3_from_ypr, "mat3 from ypr", ty => Mat3);
+
+bench_binop!(
+    mat3_mul_vec3,
+    "mat3 mul vec3",
+    op => mul,
+    from1 => random_mat3,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    mat3_mul_vec3a,
+    "mat3 mul vec3a",
+    op => mul,
+    from1 => random_mat3,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    mat3_transform_point2,
+    "mat3 transform point2",
+    op => transform_point2,
+    from1 => random_srt_mat3,
+    from2 => random_vec2
+);
+
+bench_binop!(
+    mat3_transform_vector2,
+    "mat3 transform vector2",
+    op => transform_vector2,
+    from1 => random_srt_mat3,
+    from2 => random_vec2
+);
+
+criterion_group!(
+    benches,
+    mat3_transpose,
+    mat3_determinant,
+    mat3_inverse,
+    mat3_mul_vec3,
+    mat3_mul_vec3a,
+    mat3_mul_mat3,
+    mat3_from_ypr,
+    mat3_transform_vector2,
+    mat3_transform_point2,
+);
+
+criterion_main!(benches);

vendor/glam/benches/mat3a.rs

@@ -0,0 +1,72 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Mat3A;
+use std::ops::Mul;
+use support::*;
+
+bench_unop!(
+    mat3a_transpose,
+    "mat3a transpose",
+    op => transpose,
+    from => random_mat3a
+);
+bench_unop!(
+    mat3a_determinant,
+    "mat3a determinant",
+    op => determinant,
+    from => random_mat3a
+);
+bench_unop!(mat3a_inverse, "mat3a inverse", op => inverse, from => random_mat3a);
+bench_binop!(mat3a_mul_mat3a, "mat3a mul mat3a", op => mul, from => random_mat3a);
+bench_from_ypr!(mat3a_from_ypr, "mat3a from ypr", ty => Mat3A);
+
+bench_binop!(
+    mat3a_mul_vec3,
+    "mat3a mul vec3",
+    op => mul,
+    from1 => random_mat3a,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    mat3a_mul_vec3a,
+    "mat3a mul vec3a",
+    op => mul,
+    from1 => random_mat3a,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    mat3a_transform_point2,
+    "mat3a transform point2",
+    op => transform_point2,
+    from1 => random_srt_mat3a,
+    from2 => random_vec2
+);
+
+bench_binop!(
+    mat3a_transform_vector2,
+    "mat3a transform vector2",
+    op => transform_vector2,
+    from1 => random_srt_mat3a,
+    from2 => random_vec2
+);
+
+criterion_group!(
+    benches,
+    mat3a_transpose,
+    mat3a_determinant,
+    mat3a_inverse,
+    mat3a_mul_vec3,
+    mat3a_mul_vec3a,
+    mat3a_mul_mat3a,
+    mat3a_from_ypr,
+    mat3a_transform_vector2,
+    mat3a_transform_point2,
+);
+
+criterion_main!(benches);

vendor/glam/benches/mat4.rs

@@ -0,0 +1,129 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Mat4;
+use std::ops::Mul;
+use support::*;
+
+bench_unop!(
+    mat4_transpose,
+    "mat4 transpose",
+    op => transpose,
+    from => random_srt_mat4
+);
+
+bench_unop!(
+    mat4_determinant,
+    "mat4 determinant",
+    op => determinant,
+    from => random_srt_mat4
+);
+
+bench_unop!(
+    mat4_inverse,
+    "mat4 inverse",
+    op => inverse,
+    from => random_srt_mat4
+);
+
+bench_binop!(
+    mat4_mul_vec4,
+    "mat4 mul vec4",
+    op => mul,
+    from1 => random_srt_mat4,
+    from2 => random_vec4
+);
+
+bench_binop!(
+    mat4_transform_point3,
+    "mat4 transform point3",
+    op => transform_point3,
+    from1 => random_srt_mat4,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    mat4_transform_vector3,
+    "mat4 transform vector3",
+    op => transform_vector3,
+    from1 => random_srt_mat4,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    mat4_transform_point3a,
+    "mat4 transform point3a",
+    op => transform_point3a,
+    from1 => random_srt_mat4,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    mat4_transform_vector3a,
+    "mat4 transform vector3a",
+    op => transform_vector3a,
+    from1 => random_srt_mat4,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    mat4_mul_mat4,
+    "mat4 mul mat4",
+    op => mul,
+    from => random_srt_mat4
+);
+
+bench_from_ypr!(
+    mat4_from_ypr,
+    "mat4 from ypr",
+    ty => Mat4
+);
+
+pub fn mat4_from_srt(c: &mut Criterion) {
+    use glam::{Quat, Vec3};
+    const SIZE: usize = 1 << 13;
+    let mut rng = support::PCG32::default();
+    let inputs = criterion::black_box(
+        (0..SIZE)
+            .map(|_| {
+                (
+                    random_nonzero_vec3(&mut rng),
+                    random_quat(&mut rng),
+                    random_vec3(&mut rng),
+                )
+            })
+            .collect::<Vec<(Vec3, Quat, Vec3)>>(),
+    );
+    let mut outputs = vec![Mat4::default(); SIZE];
+    let mut i = 0;
+    c.bench_function("mat4 from srt", |b| {
+        b.iter(|| {
+            i = (i + 1) & (SIZE - 1);
+            unsafe {
+                let data = inputs.get_unchecked(i);
+                *outputs.get_unchecked_mut(i) =
+                    Mat4::from_scale_rotation_translation(data.0, data.1, data.2);
+            }
+        });
+    });
+}
+
+criterion_group!(
+    benches,
+    mat4_determinant,
+    mat4_from_srt,
+    mat4_from_ypr,
+    mat4_inverse,
+    mat4_mul_mat4,
+    mat4_mul_vec4,
+    mat4_transform_point3,
+    mat4_transform_point3a,
+    mat4_transform_vector3,
+    mat4_transform_vector3a,
+    mat4_transpose,
+);
+
+criterion_main!(benches);

vendor/glam/benches/quat.rs

@@ -0,0 +1,80 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Quat;
+use std::ops::Mul;
+use support::*;
+
+bench_unop!(
+    quat_conjugate,
+    "quat conjugate",
+    op => conjugate,
+    from => random_quat
+);
+
+bench_binop!(
+    quat_mul_vec3,
+    "quat mul vec3",
+    op => mul,
+    from1 => random_quat,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    quat_mul_vec3a,
+    "quat mul vec3a",
+    op => mul,
+    from1 => random_quat,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    quat_mul_quat,
+    "quat mul quat",
+    op => mul,
+    from => random_quat
+);
+
+bench_binop!(
+    quat_dot,
+    "quat dot",
+    op => dot,
+    from => random_quat
+);
+
+bench_trinop!(
+    quat_lerp,
+    "quat lerp",
+    op => lerp,
+    from1 => random_quat,
+    from2 => random_quat,
+    from3 => random_f32
+);
+
+bench_trinop!(
+    quat_slerp,
+    "quat slerp",
+    op => slerp,
+    from1 => random_quat,
+    from2 => random_quat,
+    from3 => random_f32
+);
+
+bench_from_ypr!(quat_from_ypr, "quat from ypr", ty => Quat);
+
+criterion_group!(
+    benches,
+    quat_conjugate,
+    quat_dot,
+    quat_lerp,
+    quat_slerp,
+    quat_mul_quat,
+    quat_mul_vec3,
+    quat_mul_vec3a,
+    quat_from_ypr
+);
+
+criterion_main!(benches);

vendor/glam/benches/support.rs

@@ -0,0 +1,131 @@
+#![allow(dead_code)]
+use core::f32;
+use glam::{Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4};
+
+pub struct PCG32 {
+    state: u64,
+    inc: u64,
+}
+
+impl Default for PCG32 {
+    fn default() -> Self {
+        PCG32::seed(0x853c49e6748fea9b, 0xda3e39cb94b95bdb)
+    }
+}
+
+impl PCG32 {
+    pub fn seed(initstate: u64, initseq: u64) -> Self {
+        let mut rng = PCG32 {
+            state: 0,
+            inc: (initseq << 1) | 1,
+        };
+        rng.next_u32();
+        rng.state = rng.state.wrapping_add(initstate);
+        rng.next_u32();
+        rng
+    }
+
+    pub fn next_u32(&mut self) -> u32 {
+        let oldstate = self.state;
+        self.state = oldstate
+            .wrapping_mul(6364136223846793005)
+            .wrapping_add(self.inc | 1);
+        let xorshifted = ((oldstate >> 18) ^ oldstate) >> 27;
+        let rot = oldstate >> 59;
+        ((xorshifted >> rot) | (xorshifted << (rot.wrapping_neg() & 31))) as u32
+    }
+
+    pub fn next_f32(&mut self) -> f32 {
+        (self.next_u32() & 0xffffff) as f32 / 16777216.0
+    }
+}
+
+pub fn random_vec2(rng: &mut PCG32) -> Vec2 {
+    Vec2::new(rng.next_f32(), rng.next_f32())
+}
+
+pub fn random_vec3(rng: &mut PCG32) -> Vec3 {
+    Vec3::new(rng.next_f32(), rng.next_f32(), rng.next_f32())
+}
+
+pub fn random_vec3a(rng: &mut PCG32) -> Vec3A {
+    Vec3A::new(rng.next_f32(), rng.next_f32(), rng.next_f32())
+}
+
+pub fn random_vec4(rng: &mut PCG32) -> Vec4 {
+    Vec4::new(
+        rng.next_f32(),
+        rng.next_f32(),
+        rng.next_f32(),
+        rng.next_f32(),
+    )
+}
+
+pub fn random_nonzero_vec2(rng: &mut PCG32) -> Vec2 {
+    loop {
+        let v = random_vec2(rng);
+        if v.length_squared() > 0.01 {
+            return v;
+        }
+    }
+}
+
+pub fn random_nonzero_vec3(rng: &mut PCG32) -> Vec3 {
+    loop {
+        let v = random_vec3(rng);
+        if v.length_squared() > 0.01 {
+            return v;
+        }
+    }
+}
+
+pub fn random_f32(rng: &mut PCG32) -> f32 {
+    rng.next_f32()
+}
+
+pub fn random_radians(rng: &mut PCG32) -> f32 {
+    -f32::consts::PI + rng.next_f32() * 2.0 * f32::consts::PI
+}
+
+pub fn random_quat(rng: &mut PCG32) -> Quat {
+    let yaw = random_radians(rng);
+    let pitch = random_radians(rng);
+    let roll = random_radians(rng);
+    Quat::from_euler(glam::EulerRot::YXZ, yaw, pitch, roll)
+}
+
+pub fn random_mat2(rng: &mut PCG32) -> Mat2 {
+    Mat2::from_cols(random_vec2(rng), random_vec2(rng))
+}
+
+pub fn random_mat3(rng: &mut PCG32) -> Mat3 {
+    Mat3::from_cols(random_vec3(rng), random_vec3(rng), random_vec3(rng))
+}
+
+pub fn random_srt_mat3(rng: &mut PCG32) -> Mat3 {
+    Mat3::from_scale_angle_translation(
+        random_nonzero_vec2(rng),
+        random_radians(rng),
+        random_vec2(rng),
+    )
+}
+
+pub fn random_mat3a(rng: &mut PCG32) -> Mat3A {
+    Mat3A::from_cols(random_vec3a(rng), random_vec3a(rng), random_vec3a(rng))
+}
+
+pub fn random_srt_mat3a(rng: &mut PCG32) -> Mat3A {
+    Mat3A::from_scale_angle_translation(
+        random_nonzero_vec2(rng),
+        random_radians(rng),
+        random_vec2(rng),
+    )
+}
+
+pub fn random_srt_mat4(rng: &mut PCG32) -> Mat4 {
+    Mat4::from_scale_rotation_translation(
+        random_nonzero_vec3(rng),
+        random_quat(rng),
+        random_vec3(rng),
+    )
+}

vendor/glam/benches/support/macros.rs

@@ -0,0 +1,210 @@
+#[macro_export]
+macro_rules! bench_func {
+    ($name: ident, $desc: expr, op => $func: ident, from => $from: expr) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs =
+                criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
+            // pre-fill output vector with some random value
+            let mut outputs = vec![$func($from(&mut rng)); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        *outputs.get_unchecked_mut(i) = $func(*inputs.get_unchecked(i));
+                    }
+                })
+            });
+            criterion::black_box(outputs);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! bench_unop {
+    ($name: ident, $desc: expr, op => $unop: ident, from => $from: expr) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs =
+                criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
+            // pre-fill output vector with some random value
+            let mut outputs = vec![$from(&mut rng).$unop(); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        *outputs.get_unchecked_mut(i) = inputs.get_unchecked(i).$unop();
+                    }
+                })
+            });
+            criterion::black_box(outputs);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! bench_binop {
+    ($name: ident, $desc: expr, op => $binop: ident, from1 => $from1:expr, from2 => $from2:expr) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs1 =
+                criterion::black_box((0..SIZE).map(|_| $from1(&mut rng)).collect::<Vec<_>>());
+            let inputs2 =
+                criterion::black_box((0..SIZE).map(|_| $from2(&mut rng)).collect::<Vec<_>>());
+            // pre-fill output vector with some random value
+            let mut outputs = vec![$from1(&mut rng).$binop($from2(&mut rng)); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        *outputs.get_unchecked_mut(i) = inputs1.get_unchecked(i).$binop(*inputs2.get_unchecked(i));
+                    }
+                })
+            });
+            criterion::black_box(outputs);
+        }
+    };
+    ($name: ident, $desc: expr, op => $binop: ident, from => $from: expr) => {
+        bench_binop!($name, $desc, op => $binop, from1 => $from, from2 => $from);
+    };
+}
+
+#[macro_export]
+macro_rules! bench_trinop {
+    ($name: ident, $desc: expr, op => $trinop: ident, from1 => $from1:expr, from2 => $from2:expr, from3 => $from3:expr) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs1 =
+                criterion::black_box((0..SIZE).map(|_| $from1(&mut rng)).collect::<Vec<_>>());
+            let inputs2 =
+                criterion::black_box((0..SIZE).map(|_| $from2(&mut rng)).collect::<Vec<_>>());
+            let inputs3 =
+                criterion::black_box((0..SIZE).map(|_| $from3(&mut rng)).collect::<Vec<_>>());
+            // pre-fill output vector with some random value
+            let mut outputs =
+                vec![$from1(&mut rng).$trinop($from2(&mut rng), $from3(&mut rng)); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        *outputs.get_unchecked_mut(i) = inputs1
+                            .get_unchecked(i)
+                            .$trinop(*inputs2.get_unchecked(i), *inputs3.get_unchecked(i));
+                    }
+                })
+            });
+            criterion::black_box(outputs);
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! bench_select {
+    ($name:ident, $desc:expr, ty => $ty: ident, op => $op: ident, from => $from:expr) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs1 =
+                criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
+            let inputs2 =
+                criterion::black_box((0..SIZE).map(|_| $from(&mut rng)).collect::<Vec<_>>());
+            let masks = vec![$from(&mut rng).$op($from(&mut rng)); SIZE];
+            // pre-fill output vector with some random value
+            let mut outputs = vec![$from(&mut rng); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        *outputs.get_unchecked_mut(i) = $ty::select(
+                            *masks.get_unchecked(i),
+                            *inputs1.get_unchecked(i),
+                            *inputs2.get_unchecked(i),
+                        );
+                    }
+                })
+            });
+            criterion::black_box(outputs);
+        }
+    };
+}
+#[macro_export]
+macro_rules! bench_from_ypr {
+    ($name: ident, $desc: expr, ty => $ty:ty) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const SIZE: usize = 1 << 13;
+            let mut rng = support::PCG32::default();
+            let inputs = criterion::black_box(
+                (0..SIZE)
+                    .map(|_| {
+                        (
+                            random_radians(&mut rng),
+                            random_radians(&mut rng),
+                            random_radians(&mut rng),
+                        )
+                    })
+                    .collect::<Vec<_>>(),
+            );
+            let mut outputs = vec![<$ty>::default(); SIZE];
+            let mut i = 0;
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    i = (i + 1) & (SIZE - 1);
+                    unsafe {
+                        let data = inputs.get_unchecked(i);
+                        *outputs.get_unchecked_mut(i) =
+                            <$ty>::from_euler(glam::EulerRot::YXZ, data.0, data.1, data.2)
+                    }
+                })
+            });
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! euler {
+    ($name: ident, $desc: expr, ty => $t: ty, storage => $storage: ty, zero => $zero: expr, rand => $rand: ident) => {
+        pub(crate) fn $name(c: &mut Criterion) {
+            const UPDATE_RATE: f32 = 1.0 / 60.0;
+            const NUM_OBJECTS: usize = 10000;
+
+            struct TestData {
+                acc: Vec<$storage>,
+                vel: Vec<$storage>,
+                pos: Vec<$storage>,
+            }
+
+            let mut rng = support::PCG32::default();
+            let mut data = TestData {
+                acc: vec![$rand(&mut rng); NUM_OBJECTS],
+                vel: vec![$zero; NUM_OBJECTS],
+                pos: vec![$zero; NUM_OBJECTS],
+            };
+            let dt = <$t>::splat(UPDATE_RATE);
+
+            c.bench_function($desc, |b| {
+                b.iter(|| {
+                    for ((position, acceleration), velocity) in
+                        data.pos.iter_mut().zip(&data.acc).zip(&mut data.vel)
+                    {
+                        let local_acc: $t = (*acceleration).into();
+                        let mut local_pos: $t = (*position).into();
+                        let mut local_vel: $t = (*velocity).into();
+                        local_vel += local_acc * dt;
+                        local_pos += local_vel * dt;
+                        *velocity = local_vel.into();
+                        *position = local_pos.into();
+                    }
+                })
+            });
+        }
+    };
+}

vendor/glam/benches/vec2.rs

@@ -0,0 +1,51 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Vec2;
+use std::ops::Mul;
+use support::*;
+
+euler!(
+    vec2_euler,
+    "vec2 euler",
+    ty => Vec2,
+    storage => Vec2,
+    zero => Vec2::ZERO,
+    rand => random_vec2);
+
+bench_binop!(
+    vec2_mul_vec2,
+    "vec2 mul vec2",
+    op => mul,
+    from1 => random_vec2,
+    from2 => random_vec2
+);
+
+bench_binop!(
+    vec2_angle_to,
+    "vec2 angle_to",
+    op => angle_to,
+    from1 => random_vec2,
+    from2 => random_vec2
+);
+
+bench_select!(
+    vec2_select,
+    "vec2 select",
+    ty => Vec2,
+    op => cmple,
+    from => random_vec2
+);
+
+criterion_group!(
+    benches,
+    vec2_mul_vec2,
+    vec2_euler,
+    vec2_select,
+    vec2_angle_to
+);
+
+criterion_main!(benches);

vendor/glam/benches/vec3.rs

@@ -0,0 +1,208 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Vec3;
+use std::ops::Mul;
+use support::*;
+
+bench_binop!(
+    vec3_mul_vec3,
+    "vec3 mul vec3",
+    op => mul,
+    from1 => random_vec3,
+    from2 => random_vec3
+);
+
+#[inline]
+fn vec3_to_rgb_op(v: Vec3) -> u32 {
+    let (red, green, blue) = (v.min(Vec3::ONE).max(Vec3::ZERO) * 255.0).into();
+    ((red as u32) << 16) | ((green as u32) << 8) | (blue as u32)
+}
+
+#[inline]
+fn vec3_fields(v: Vec3) -> [f32; 3] {
+    [v.x, v.y, v.z]
+}
+
+#[inline]
+fn vec3_into_array(v: Vec3) -> [f32; 3] {
+    v.into()
+}
+
+#[inline]
+fn vec3_into_tuple(v: Vec3) -> (f32, f32, f32) {
+    v.into()
+}
+
+bench_func!(
+vec3_to_rgb,
+"vec3 to rgb",
+op => vec3_to_rgb_op,
+from => random_vec3
+);
+
+bench_func!(
+vec3_to_array_fields,
+"vec3 into array fields",
+op => vec3_fields,
+from => random_vec3
+);
+
+bench_func!(
+vec3_to_array_into,
+"vec3 into array fast",
+op => vec3_into_array,
+from => random_vec3
+);
+
+bench_func!(
+vec3_to_tuple_into,
+"vec3 into tuple fast",
+op => vec3_into_tuple,
+from => random_vec3
+);
+
+// ---
+
+#[inline]
+fn vec3_normalize(v: Vec3) -> Vec3 {
+    v.normalize()
+}
+
+bench_func!(
+    vec3_normalize_bench,
+    "vec3 normalize",
+    op => vec3_normalize,
+    from => random_vec3
+);
+
+#[inline]
+fn vec3_normalize_or(v: Vec3) -> Vec3 {
+    v.normalize_or(Vec3::X)
+}
+
+bench_func!(
+    vec3_normalize_or_bench,
+    "vec3 normalize_or",
+    op => vec3_normalize_or,
+    from => random_vec3
+);
+
+#[inline]
+fn vec3_normalize_or_zero(v: Vec3) -> Vec3 {
+    v.normalize_or_zero()
+}
+
+bench_func!(
+    vec3_normalize_or_zero_bench,
+    "vec3 normalize_or_zero",
+    op => vec3_normalize_or_zero,
+    from => random_vec3
+);
+
+// ---
+
+#[inline(always)]
+fn vec3_any_orthogonal_vector(v: Vec3) -> Vec3 {
+    v.any_orthogonal_vector()
+}
+
+bench_func!(
+    vec3_any_orthogonal_vector_bench,
+    "vec3 any_orthogonal_vector",
+    op => vec3_any_orthogonal_vector,
+    from => random_vec3
+);
+
+#[inline(always)]
+fn vec3_any_orthonormal_vector(v: Vec3) -> Vec3 {
+    v.any_orthonormal_vector()
+}
+
+bench_func!(
+    vec3_any_orthonormal_vector_bench,
+    "vec3 any_orthonormal_vector",
+    op => vec3_any_orthonormal_vector,
+    from => random_vec3
+);
+
+#[inline(always)]
+fn vec3_any_orthonormal_pair(v: Vec3) -> (Vec3, Vec3) {
+    v.any_orthonormal_pair()
+}
+
+bench_func!(
+    vec3_any_orthonormal_pair_bench,
+    "vec3 any_orthonormal_pair",
+    op => vec3_any_orthonormal_pair,
+    from => random_vec3
+);
+
+// ---
+
+euler!(vec3_euler, "vec3 euler", ty => Vec3, storage => Vec3, zero => Vec3::ZERO, rand => random_vec3);
+
+bench_binop!(
+    vec3_angle_between,
+    "vec3 angle_between",
+    op => angle_between,
+    from1 => random_vec3,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    vec3_cross,
+    "vec3 cross",
+    op => cross,
+    from1 => random_vec3,
+    from2 => random_vec3
+);
+
+bench_binop!(
+    vec3_dot,
+    "vec3 dot",
+    op => dot,
+    from1 => random_vec3,
+    from2 => random_vec3
+);
+
+bench_unop!(
+    vec3_length,
+    "vec3 length",
+    op => length,
+    from => random_vec3
+);
+
+bench_select!(
+    vec3_select,
+    "vec3 select",
+    ty => Vec3,
+    op => cmple,
+    from => random_vec3
+);
+
+criterion_group!(
+    benches,
+    vec3_angle_between,
+    vec3_any_orthogonal_vector_bench,
+    vec3_any_orthonormal_pair_bench,
+    vec3_any_orthonormal_vector_bench,
+    vec3_cross,
+    vec3_dot,
+    vec3_euler,
+    vec3_length,
+    vec3_mul_vec3,
+    vec3_normalize_bench,
+    vec3_normalize_or_bench,
+    vec3_normalize_or_zero_bench,
+    vec3_select,
+    vec3_to_array_fields,
+    vec3_to_array_into,
+    vec3_to_rgb,
+    vec3_to_tuple_into,
+);
+
+criterion_main!(benches);

vendor/glam/benches/vec3a.rs

@@ -0,0 +1,176 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::{Vec3, Vec3A};
+use std::ops::Mul;
+use support::*;
+
+bench_binop!(
+    vec3a_mul_vec3a,
+    "vec3a mul vec3a",
+    op => mul,
+    from1 => random_vec3a,
+    from2 => random_vec3a
+);
+
+#[inline]
+fn vec3a_to_rgb_op(v: Vec3A) -> u32 {
+    let (red, green, blue) = (v.min(Vec3A::ONE).max(Vec3A::ZERO) * 255.0).into();
+    ((red as u32) << 16) | ((green as u32) << 8) | (blue as u32)
+}
+
+#[inline]
+fn vec3a_deref(v: Vec3A) -> [f32; 3] {
+    [v.x, v.y, v.z]
+}
+
+#[inline]
+fn vec3a_into_array(v: Vec3A) -> [f32; 3] {
+    v.into()
+}
+
+#[inline]
+fn vec3a_into_tuple(v: Vec3A) -> (f32, f32, f32) {
+    v.into()
+}
+
+#[inline]
+fn vec3a_into_vec3(v: Vec3A) -> Vec3 {
+    v.into()
+}
+
+bench_func!(
+vec3a_to_vec3,
+"vec3a into vec3",
+op => vec3a_into_vec3,
+from => random_vec3a
+);
+
+bench_func!(
+vec3a_to_rgb,
+"vec3a to rgb",
+op => vec3a_to_rgb_op,
+from => random_vec3a
+);
+
+bench_func!(
+vec3a_to_array_deref,
+"vec3a into array deref",
+op => vec3a_deref,
+from => random_vec3a
+);
+
+bench_func!(
+vec3a_to_array_into,
+"vec3a into array fast",
+op => vec3a_into_array,
+from => random_vec3a
+);
+
+bench_func!(
+vec3a_to_tuple_into,
+"vec3a into tuple fast",
+op => vec3a_into_tuple,
+from => random_vec3a
+);
+
+euler!(vec3a_euler, "vec3a euler", ty => Vec3A, storage => Vec3A, zero => Vec3A::ZERO, rand => random_vec3a);
+
+#[inline]
+fn vec3a_normalize(v: Vec3A) -> Vec3A {
+    v.normalize()
+}
+
+bench_func!(
+    vec3a_normalize_bench,
+    "vec3a normalize",
+    op => vec3a_normalize,
+    from => random_vec3a
+);
+
+#[inline]
+fn vec3a_normalize_or(v: Vec3A) -> Vec3A {
+    v.normalize_or(Vec3A::X)
+}
+
+bench_func!(
+    vec3a_normalize_or_bench,
+    "vec3a normalize_or",
+    op => vec3a_normalize_or,
+    from => random_vec3a
+);
+
+#[inline]
+fn vec3a_normalize_or_zero(v: Vec3A) -> Vec3A {
+    v.normalize_or_zero()
+}
+
+bench_func!(
+    vec3a_normalize_or_zero_bench,
+    "vec3a normalize_or_zero",
+    op => vec3a_normalize_or_zero,
+    from => random_vec3a
+);
+
+bench_binop!(
+    vec3a_angle_between,
+    "vec3a angle_between",
+    op => angle_between,
+    from1 => random_vec3a,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    vec3a_cross,
+    "vec3a cross",
+    op => cross,
+    from1 => random_vec3a,
+    from2 => random_vec3a
+);
+
+bench_binop!(
+    vec3a_dot,
+    "vec3a dot",
+    op => dot,
+    from1 => random_vec3a,
+    from2 => random_vec3a
+);
+
+bench_unop!(
+    vec3a_length,
+    "vec3a length",
+    op => length,
+    from => random_vec3a
+);
+
+bench_select!(
+    vec3a_select,
+    "vec3a select",
+    ty => Vec3A,
+    op => cmple,
+    from => random_vec3a
+);
+
+criterion_group!(
+    benches,
+    vec3a_normalize_bench,
+    vec3a_normalize_or_bench,
+    vec3a_normalize_or_zero_bench,
+    vec3a_angle_between,
+    vec3a_cross,
+    vec3a_dot,
+    vec3a_length,
+    vec3a_euler,
+    vec3a_mul_vec3a,
+    vec3a_select,
+    vec3a_to_array_deref,
+    vec3a_to_array_into,
+    vec3a_to_rgb,
+    vec3a_to_tuple_into,
+    vec3a_to_vec3,
+);
+
+criterion_main!(benches);

vendor/glam/benches/vec4.rs

@@ -0,0 +1,29 @@
+#[path = "support/macros.rs"]
+#[macro_use]
+mod macros;
+mod support;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use glam::Vec4;
+use std::ops::Mul;
+use support::random_vec4;
+
+bench_binop!(
+    vec4_mul_vec4,
+    "vec4 mul vec4",
+    op => mul,
+    from1 => random_vec4,
+    from2 => random_vec4
+);
+
+bench_select!(
+    vec4_select,
+    "vec4 select",
+    ty => Vec4,
+    op => cmple,
+    from => random_vec4
+);
+
+criterion_group!(benches, vec4_mul_vec4, vec4_select);
+
+criterion_main!(benches);