glam_det 2.0.0

// Copyright (C) 2020-2025 glam-det authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

mod affine2;
mod affine3a;
mod isometry3;
mod mat3;
mod point2;
mod point3;
#[cfg(any(
    not(any(
        target_feature = "sse2",
        target_feature = "simd128",
        all(target_feature = "neon", target_arch = "aarch64")
    )),
    feature = "scalar-math"
))]
pub(crate) mod scalar;
mod unit_vec2;
mod unit_vec3;
mod vec2;
mod vec3;
mod vec3_ext;

#[cfg(any(
    not(any(
        target_feature = "sse2",
        target_feature = "simd128",
        all(target_feature = "neon", target_arch = "aarch64")
    )),
    feature = "scalar-math"
))]
pub(crate) use scalar as simd_alias;

#[cfg(all(target_feature = "sse2", not(feature = "scalar-math")))]
pub(crate) mod sse2;

#[cfg(all(target_feature = "sse2", not(feature = "scalar-math")))]
pub(crate) use sse2 as simd_alias;

#[cfg(all(target_feature = "simd128", not(feature = "scalar-math")))]
pub(crate) mod wasm32;

#[cfg(all(target_feature = "simd128", not(feature = "scalar-math")))]
pub(crate) use wasm32 as simd_alias;

#[cfg(all(
    target_feature = "neon",
    target_arch = "aarch64",
    not(feature = "scalar-math")
))]
pub(crate) mod neon;

#[cfg(all(
    target_feature = "neon",
    target_arch = "aarch64",
    not(feature = "scalar-math")
))]
pub(crate) use neon as simd_alias;

#[cfg(all(
    any(
        target_feature = "sse2",
        target_feature = "simd128",
        all(target_feature = "neon", target_arch = "aarch64")
    ),
    not(feature = "scalar-math"),
    feature = "ffi-safe"
))]
pub(crate) mod ffi;

pub use affine2::Affine2;
pub use affine3a::Affine3A;
pub use isometry3::Isometry3;
pub use mat3::{mat3, Mat3};
pub use point2::{point2, Point2};
pub use point3::{point3, Point3};
pub use unit_vec2::UnitVec2;
pub use unit_vec3::UnitVec3;
pub use vec2::{vec2, Vec2};
pub use vec3::{vec3, Vec3};
pub use vec3_ext::{
    AbsExternal, CrossExternal, DotExternal, NormalizeAndLengthExternal, Vec3OnlyX, Vec3OnlyXY,
    Vec3OnlyXZ, Vec3OnlyY, Vec3OnlyYZ, Vec3OnlyZ,
};

#[cfg(not(all(
    any(
        target_feature = "sse2",
        target_feature = "simd128",
        all(target_feature = "neon", target_arch = "aarch64")
    ),
    not(feature = "scalar-math"),
    feature = "ffi-safe"
)))]
pub use simd_alias::{
    mat2::{mat2, Mat2},
    mat3a::{mat3a, Mat3A},
    mat4::{mat4, Mat4},
    point3a::{point3a, Point3A},
    point4::{point4, Point4},
    quat::{quat, Quat},
    unit_quat::UnitQuat,
    unit_vec3a::UnitVec3A,
    unit_vec4::UnitVec4,
    vec3a::{vec3a, Vec3A},
    vec4::{vec4, Vec4},
};

#[cfg(all(
    any(
        target_feature = "sse2",
        target_feature = "simd128",
        all(target_feature = "neon", target_arch = "aarch64")
    ),
    not(feature = "scalar-math"),
    feature = "ffi-safe"
))]
pub use ffi::{
    mat2::{mat2, Mat2},
    mat3a::{mat3a, Mat3A},
    mat4::{mat4, Mat4},
    point3a::{point3a, Point3A},
    point4::{point4, Point4},
    quat::{quat, Quat},
    unit_quat::UnitQuat,
    unit_vec3a::UnitVec3A,
    unit_vec4::UnitVec4,
    vec3a::{vec3a, Vec3A},
    vec4::{vec4, Vec4},
};

#[cfg(not(target_arch = "spirv"))]
mod test {
    use super::*;

    #[cfg(all(not(feature = "cuda"), feature = "scalar-math"))]
    mod const_test_affine2 {
        const_assert_eq!(
            core::mem::align_of::<super::Vec2>(),
            core::mem::align_of::<super::Affine2>()
        );
        const_assert_eq!(24, core::mem::size_of::<super::Affine2>());
    }

    #[cfg(not(feature = "scalar-math"))]
    mod const_test_affine2 {
        const_assert_eq!(16, core::mem::align_of::<super::Affine2>());
        const_assert_eq!(32, core::mem::size_of::<super::Affine2>());
    }

    mod const_test_affine3a {
        const_assert_eq!(16, core::mem::align_of::<super::Affine3A>());
        const_assert_eq!(64, core::mem::size_of::<super::Affine3A>());
    }

    mod const_test_isometry3 {
        const_assert_eq!(16, core::mem::align_of::<super::Isometry3>());
        const_assert_eq!(32, core::mem::size_of::<super::Isometry3>());
    }

    mod const_test_mat2 {
        #[cfg(feature = "scalar-math")]
        const_assert_eq!(
            core::mem::align_of::<super::Vec2>(),
            core::mem::align_of::<super::Mat2>()
        );
        #[cfg(not(any(feature = "scalar-math", target_arch = "spirv")))]
        const_assert_eq!(16, core::mem::align_of::<super::Mat2>());
        const_assert_eq!(16, core::mem::size_of::<super::Mat2>());
    }

    mod const_test_mat3 {
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Mat3>()
        );
        const_assert_eq!(36, core::mem::size_of::<super::Mat3>());
    }

    mod const_test_mat3a {
        const_assert_eq!(16, core::mem::align_of::<super::Mat3A>());
        const_assert_eq!(48, core::mem::size_of::<super::Mat3A>());
    }

    mod const_test_mat4 {
        const_assert_eq!(
            core::mem::align_of::<super::Vec4>(),
            core::mem::align_of::<super::Mat4>()
        );
        const_assert_eq!(64, core::mem::size_of::<super::Mat4>());
    }

    mod const_test_quat {
        #[cfg(feature = "scalar-math")]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Quat>()
        );
        #[cfg(not(any(feature = "scalar-math", target_arch = "spirv")))]
        const_assert_eq!(16, core::mem::align_of::<super::Quat>());
        const_assert_eq!(16, core::mem::size_of::<super::Quat>());
    }

    mod const_test_unit_quat {
        #[cfg(feature = "scalar-math")]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::UnitQuat>()
        );
        #[cfg(not(any(feature = "scalar-math", target_arch = "spirv")))]
        const_assert_eq!(16, core::mem::align_of::<super::UnitQuat>());
        const_assert_eq!(16, core::mem::size_of::<super::UnitQuat>());
    }

    mod const_test_vec2 {
        #[cfg(not(feature = "cuda"))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Vec2>()
        );
        #[cfg(feature = "cuda")]
        const_assert_eq!(8, core::mem::align_of::<super::Vec2>());
        const_assert_eq!(8, core::mem::size_of::<super::Vec2>());
    }

    mod const_test_vec3 {
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Vec3>()
        );
        const_assert_eq!(12, core::mem::size_of::<super::Vec3>());
    }

    mod const_test_vec3a {
        const_assert_eq!(16, core::mem::align_of::<super::Vec3A>());
        const_assert_eq!(16, core::mem::size_of::<super::Vec3A>());
    }

    mod const_test_vec4 {
        #[cfg(all(feature = "scalar-math", not(feature = "cuda")))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Vec4>()
        );
        #[cfg(not(feature = "scalar-math"))]
        const_assert_eq!(16, core::mem::align_of::<super::Vec4>());
        const_assert_eq!(16, core::mem::size_of::<super::Vec4>());
    }

    mod const_test_unit_vec2 {
        #[cfg(not(feature = "cuda"))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::UnitVec2>()
        );
        #[cfg(feature = "cuda")]
        const_assert_eq!(8, core::mem::align_of::<super::UnitVec2>());
        const_assert_eq!(8, core::mem::size_of::<super::UnitVec2>());
    }

    mod const_test_unit_vec3 {
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::UnitVec3>()
        );
        const_assert_eq!(12, core::mem::size_of::<super::UnitVec3>());
    }

    mod const_test_unit_vec3a {
        const_assert_eq!(16, core::mem::align_of::<super::UnitVec3A>());
        const_assert_eq!(16, core::mem::size_of::<super::UnitVec3A>());
    }

    mod const_test_unit_vec4 {
        #[cfg(all(feature = "scalar-math", not(feature = "cuda")))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::UnitVec4>()
        );
        #[cfg(not(feature = "scalar-math"))]
        const_assert_eq!(16, core::mem::align_of::<super::UnitVec4>());
        const_assert_eq!(16, core::mem::size_of::<super::UnitVec4>());
    }

    mod const_test_point2 {
        #[cfg(not(feature = "cuda"))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Point2>()
        );
        #[cfg(feature = "cuda")]
        const_assert_eq!(8, core::mem::align_of::<super::Point2>());
        const_assert_eq!(8, core::mem::size_of::<super::Point2>());
    }

    mod const_test_point3 {
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Point3>()
        );
        const_assert_eq!(12, core::mem::size_of::<super::Point3>());
    }

    mod const_test_point3a {
        const_assert_eq!(16, core::mem::align_of::<super::Point3A>());
        const_assert_eq!(16, core::mem::size_of::<super::Point3A>());
    }

    mod const_test_point4 {
        #[cfg(all(feature = "scalar-math", not(feature = "cuda")))]
        const_assert_eq!(
            core::mem::align_of::<f32>(),
            core::mem::align_of::<super::Point4>()
        );
        #[cfg(not(feature = "scalar-math"))]
        const_assert_eq!(16, core::mem::align_of::<super::Point4>());
        const_assert_eq!(16, core::mem::size_of::<super::Point4>());
    }
}