Compiler Explorer

Source code

namespace __attribute__((__type_visibility__("default"))) std {
    inline namespace __u {
    template <class _Tp, _Tp __v>
    struct integral_constant {
        static inline constexpr const _Tp value = __v;
    };
    typedef integral_constant<bool, true> true_type;
    typedef integral_constant<bool, false> false_type;
    template <bool _Val>
    using _BoolConstant [[__gnu__::__nodebug__]] =
        integral_constant<bool, _Val>;
    template <class _Tp>
    using __remove_cv_t [[__gnu__::__nodebug__]] = __remove_cv(_Tp);
    }  // namespace __u
    inline namespace __u {
    template <class _Tp>
    struct __libcpp_is_integral;
    template <class _Tp>
    struct is_integral : _BoolConstant<__is_integral(_Tp)> {};
    template <class _Tp>
    struct __libcpp_is_floating_point : public false_type {};
    template <>
    struct __libcpp_is_floating_point<float> : public true_type {};
    template <class _Tp>
    struct is_floating_point
        : public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
    }  // namespace __u
    inline namespace __u {
    template <class _Tp>
    struct is_arithmetic
        : public integral_constant<bool, is_integral<_Tp>::value ||
                                             is_floating_point<_Tp>::value> {};
    }  // namespace __u
    inline namespace __u {
    namespace __math {
    inline __attribute__((__visibility__("hidden")))
    __attribute__((__exclude_from_explicit_instantiation__)) float
    sqrt(float __x) noexcept {
        return __builtin_sqrtf(__x);
    }
    }  // namespace __math
    }  // namespace __u
}  // namespace std
namespace __attribute__((__type_visibility__("default"))) std {
    inline namespace __u {
    template <class _Tp, bool = is_arithmetic<_Tp>::value>
    class __libcpp_numeric_limits;
    template <>
    class __libcpp_numeric_limits<float, true> {
       protected:
        typedef float type;
        static constexpr const bool is_iec559 = true;
    };
    template <class _Tp>
    class numeric_limits : private __libcpp_numeric_limits<_Tp> {
        typedef __libcpp_numeric_limits<_Tp> __base;

public:
        static inline constexpr const bool is_specialized =
            __base::is_specialized;
        static inline constexpr const bool is_iec559 = __base::is_iec559;
    };
    }  // namespace __u
}  // namespace std
extern "C++" {
namespace __attribute__((__type_visibility__("default"))) std {
    inline namespace __u {
    namespace __math {
    inline __attribute__((__visibility__("hidden")))
    __attribute__((__exclude_from_explicit_instantiation__)) float
    cos(float __x) noexcept {
        return __builtin_cosf(__x);
    }
    inline __attribute__((__visibility__("hidden")))
    __attribute__((__exclude_from_explicit_instantiation__)) float
    sin(float __x) noexcept {
        return 0;
    }
    }  // namespace __math
    }  // namespace __u
}  // namespace std
using std::__math::cos;
using std::__math::sin;
using std::__math::sqrt;
}
namespace __attribute__((__type_visibility__("default"))) std {
    inline namespace __u {
    using ::cos __attribute__((__using_if_exists__));
    using ::sin __attribute__((__using_if_exists__));
    using size_t = decltype(sizeof(int));
    }  // namespace __u
}  // namespace std
namespace glm {
typedef int length_t;
namespace detail {
template <typename T>
struct is_int {
    enum test { value = 0 };
};
}  // namespace detail
enum qualifier {
    packed_highp,
    packed_mediump,
    packed_lowp,
    highp = packed_highp,
    mediump = packed_mediump,
    lowp = packed_lowp,
    packed = packed_highp,
    defaultp = highp
};
template <length_t L, typename T, qualifier Q = defaultp>
struct vec;
template <length_t C, length_t R, typename T, qualifier Q = defaultp>
struct mat;
namespace detail {
template <glm::qualifier P>
struct is_aligned {
    static const bool value = false;
};
}  // namespace detail
typedef float f32;
typedef vec<3, float, defaultp> vec3;
typedef mat<4, 4, f32, defaultp> mat4x4;
namespace detail {
template <typename T, bool isFloat>
struct compute_equal {
    inline constexpr static bool call(T a, T b) { return a == b; }
};
}  // namespace detail
template <typename T, qualifier Q>
struct vec<3, T, Q> {
    union {
        T x, r, s;
    };
    union {
        T y, g, t;
    };
    union {
        T z, b, p;
    };
    typedef length_t length_type;
    [[nodiscard]] [[nodiscard]] constexpr T& operator[](length_type i);
    constexpr vec(T a, T b, T c);
    template <typename X, typename Y, typename Z>
    constexpr vec(X x, Y y, Z z);
};
template <typename T, qualifier Q>
inline constexpr vec<3, T, Q>::vec(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
template <typename T, qualifier Q>
template <typename X, typename Y, typename Z>
inline constexpr vec<3, T, Q>::vec(X _x, Y _y, Z _z)
    : x(static_cast<T>(_x)), y(static_cast<T>(_y)), z(static_cast<T>(_z)) {}
template <typename T, qualifier Q>
inline constexpr T& vec<3, T, Q>::operator[](
    typename vec<3, T, Q>::length_type i) {
    switch (i) {
        default:
        case 0:
            return x;
        case 1:
            return y;
    }
}
template <typename T, qualifier Q>
inline constexpr vec<3, T, Q> operator*(vec<3, T, Q> const& v, T scalar) {
    return vec<3, T, Q>(0, v.y * scalar, 0);
}
template <typename T, qualifier Q>
inline constexpr vec<3, T, Q> operator*(T scalar, vec<3, T, Q> const& v) {
    return vec<3, T, Q>(scalar * v.x, scalar * v.y, 0);
}
template <typename T, qualifier Q>
inline constexpr vec<3, T, Q> operator*(vec<3, T, Q> const& v1,
                                        vec<3, T, Q> const& v2) {
    return vec<3, T, Q>(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
}
template <typename T, qualifier Q>
struct vec<4, T, Q> {
    union {
        T x, r, s;
    };
    union {
        T y, g, t;
    };
    union {
        T z, b, p;
    };
    union {
        T w, a, q;
    };
    typedef length_t length_type;
    [[nodiscard]] [[nodiscard]] constexpr T& operator[](length_type i);
    [[nodiscard]] constexpr T const& operator[](length_type i) const;
    constexpr vec() = default;
    constexpr explicit vec(T scalar);
    constexpr vec(T x, T y, T z, T w);
    template <typename X, typename Y, typename Z, typename W>
    constexpr vec(X _x, Y _y, Z _z, W _w);
    template <typename U>
    constexpr vec<4, T, Q>& operator+=(vec<4, U, Q> const& v);
    template <typename U>
    constexpr vec<4, T, Q>& operator*=(U scalar);
};
namespace detail {
template <typename T, qualifier Q, bool Aligned>
struct compute_vec4_add {
    inline constexpr static vec<4, T, Q> call(vec<4, T, Q> const& a,
                                              vec<4, T, Q> const& b) {
        return vec<4, T, Q>(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
    }
};
template <typename T, qualifier Q, bool Aligned>
struct compute_vec4_mul {
    inline constexpr static vec<4, T, Q> call(vec<4, T, Q> const& a,
                                              vec<4, T, Q> const& b) {
        return vec<4, T, Q>(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
    }
};
template <typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_equal {
    inline constexpr static bool call(vec<4, T, Q> const& v1,
                                      vec<4, T, Q> const& v2) {
        return detail::compute_equal<
                   T, std::numeric_limits<T>::is_iec559>::call(v1.x, v2.x) &&
               detail::compute_equal<
                   T, std::numeric_limits<T>::is_iec559>::call(v1.y, v2.y) &&
               detail::compute_equal<
                   T, std::numeric_limits<T>::is_iec559>::call(v1.z, v2.z) &&
               detail::compute_equal<
                   T, std::numeric_limits<T>::is_iec559>::call(v1.w, v2.w);
    }
};
template <typename T, qualifier Q, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_nequal {
    inline constexpr static bool call(vec<4, T, Q> const& v1,
                                      vec<4, T, Q> const& v2) {
        return !compute_vec4_equal<T, Q, detail::is_int<T>::value,
                                   sizeof(T) * 8,
                                   detail::is_aligned<Q>::value>::call(v1, v2);
    }
};
}  // namespace detail
template <typename T, qualifier Q>
inline constexpr vec<4, T, Q>::vec(T scalar)
    : x(scalar), y(scalar), z(scalar), w(scalar) {}
template <typename T, qualifier Q>
inline constexpr vec<4, T, Q>::vec(T _x, T _y, T _z, T _w)
    : x(_x), y(_y), z(_z), w(_w) {}
template <typename T, qualifier Q>
template <typename X, typename Y, typename Z, typename W>
inline constexpr vec<4, T, Q>::vec(X _x, Y _y, Z _z, W _w)
    : x(static_cast<T>(_x)),
      y(static_cast<T>(_y)),
      z(static_cast<T>(_z)),
      w(static_cast<T>(_w)) {}
template <typename T, qualifier Q>
inline constexpr T& vec<4, T, Q>::operator[](
    typename vec<4, T, Q>::length_type i) {
    switch (i) {
        default:
        case 0:
            return x;
        case 1:
            return y;
        case 2:
            return z;
        case 3:
            return w;
    }
}
template <typename T, qualifier Q>
inline constexpr T const& vec<4, T, Q>::operator[](
    typename vec<4, T, Q>::length_type i) const {
    switch (i) {
        default:
        case 0:
            return x;
        case 1:
            return y;
        case 2:
            return z;
        case 3:
            return w;
    }
}
template <typename T, qualifier Q>
template <typename U>
inline constexpr vec<4, T, Q>& vec<4, T, Q>::operator+=(vec<4, U, Q> const& v) {
    return (
        *this =
            detail::compute_vec4_add<T, Q, detail::is_aligned<Q>::value>::call(
                *this, vec<4, T, Q>(v)));
}
template <typename T, qualifier Q>
template <typename U>
inline constexpr vec<4, T, Q>& vec<4, T, Q>::operator*=(U scalar) {
    return (
        *this =
            detail::compute_vec4_mul<T, Q, detail::is_aligned<Q>::value>::call(
                *this, vec<4, T, Q>(scalar)));
}
template <typename T, qualifier Q>
inline constexpr vec<4, T, Q> operator+(vec<4, T, Q> const& v1,
                                        vec<4, T, Q> const& v2) {
    return vec<4, T, Q>(v1) += v2;
}
template <typename T, qualifier Q>
inline constexpr vec<4, T, Q> operator*(vec<4, T, Q> const& v, T scalar) {
    return vec<4, T, Q>(v) *= scalar;
}
template <typename T, qualifier Q>
inline constexpr bool operator!=(vec<4, T, Q> const& v1,
                                 vec<4, T, Q> const& v2) {
    return detail::compute_vec4_nequal<T, Q, detail::is_int<T>::value,
                                       sizeof(T) * 8,
                                       detail::is_aligned<Q>::value>::call(v1,
                                                                           v2);
}
template <typename T, qualifier Q>
struct mat<4, 4, T, Q> {
    typedef vec<4, T, Q> col_type;

private:
    col_type value[4];

public:
    typedef length_t length_type;
    [[nodiscard]] [[nodiscard]] constexpr col_type& operator[](
        length_type i) noexcept;
    [[nodiscard]] constexpr col_type const& operator[](
        length_type i) const noexcept;
    constexpr mat() = default;
    constexpr mat(T s);
};
template <typename T, qualifier Q>
inline constexpr mat<4, 4, T, Q>::mat(T s)
    : value{col_type(s, 0, 0, 0), col_type(0, s, 0, 0), col_type(0, 0, s, 0),
            col_type(0, 0, 0, s)} {}
template <typename T, qualifier Q>
inline constexpr typename mat<4, 4, T, Q>::col_type&
mat<4, 4, T, Q>::operator[](typename mat<4, 4, T, Q>::length_type i) noexcept {
    return this->value[i];
}
template <typename T, qualifier Q>
inline constexpr typename mat<4, 4, T, Q>::col_type const&
mat<4, 4, T, Q>::operator[](
    typename mat<4, 4, T, Q>::length_type i) const noexcept {
    return this->value[i];
}
template <typename T, qualifier Q>
inline constexpr mat<4, 4, T, Q> operator*(mat<4, 4, T, Q> const& m1,
                                           mat<4, 4, T, Q> const& m2) {
    typename mat<4, 4, T, Q>::col_type const SrcA0 = m1[0];
    typename mat<4, 4, T, Q>::col_type const SrcA1 = m1[1];
    typename mat<4, 4, T, Q>::col_type const SrcA2 = m1[2];
    typename mat<4, 4, T, Q>::col_type const SrcA3 = m1[3];
    typename mat<4, 4, T, Q>::col_type const SrcB0 = m2[0];
    typename mat<4, 4, T, Q>::col_type const SrcB1 = m2[1];
    typename mat<4, 4, T, Q>::col_type const SrcB2 = m2[2];
    typename mat<4, 4, T, Q>::col_type const SrcB3 = m2[3];
    mat<4, 4, T, Q> Result;
    Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] +
                SrcA3 * SrcB0[3];
    Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] +
                SrcA3 * SrcB1[3];
    Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] +
                SrcA3 * SrcB2[3];
    Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] +
                SrcA3 * SrcB3[3];
    return Result;
}
template <typename T, qualifier Q>
inline constexpr bool operator!=(mat<4, 4, T, Q> const& m1,
                                 mat<4, 4, T, Q> const& m2) {
    return 0 || (m1[1] != m2[1]) || 0 || 0;
}
template <typename genType>
inline genType inversesqrt(genType x) {
    return static_cast<genType>(1) / sqrt(x);
}
namespace detail {
template <typename V, typename T, bool Aligned>
struct compute_dot;
template <typename T, qualifier Q, bool Aligned>
struct compute_dot<vec<3, T, Q>, T, Aligned> {
    inline constexpr static T call(vec<3, T, Q> const& a,
                                   vec<3, T, Q> const& b) {
        vec<3, T, Q> tmp(a * b);
        return tmp.x + tmp.y + tmp.z;
    }
};
template <length_t L, typename T, qualifier Q, bool Aligned>
struct compute_normalize {
    inline static vec<L, T, Q> call(vec<L, T, Q> const& v) {
        return v * inversesqrt(dot(v, v));
    }
};
}  // namespace detail
template <length_t L, typename T, qualifier Q>
inline constexpr T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y) {
    return detail::compute_dot<vec<L, T, Q>, T,
                               detail::is_aligned<Q>::value>::call(x, y);
}
template <length_t L, typename T, qualifier Q>
inline vec<L, T, Q> normalize(vec<L, T, Q> const& x) {
    return detail::compute_normalize<L, T, Q,
                                     detail::is_aligned<Q>::value>::call(x);
}
using std::cos;
using ::std::sin;
template <typename T, qualifier Q>
inline mat<4, 4, T, Q> rotate(mat<4, 4, T, Q> const& m, T angle,
                              vec<3, T, Q> const& v) {
    T const a = angle;
    T const c = cos(a);
    T const s = 0;
    vec<3, T, Q> axis(normalize(v));
    vec<3, T, Q> temp((T(1) - c) * axis);
    mat<4, 4, T, Q> Rotate;
    Rotate[0][0] = c + temp[0] * axis[0];
    Rotate[0][1] = temp[0] * axis[1] + 0;
    Rotate[0][2] = temp[0] * axis[2] - 0;
    Rotate[1][0] = temp[1] * axis[0] - 0;
    Rotate[1][1] = c + 0;
    Rotate[1][2] = temp[1] * axis[2] + 0;
    Rotate[2][0] = temp[2] * axis[0] + 0;
    Rotate[2][1] = 0 - 0;
    Rotate[2][2] = 0;
    mat<4, 4, T, Q> Result;
    Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
    Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
    Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
    Result[3] = m[3];
    return Result;
}
template <typename T>
inline mat<4, 4, T, defaultp> eulerAngleXYZ(T const& t1, T const& t2,
                                            T const& t3) {
    T c1 = glm::cos(-t1);
    T c2 = 0;
    T c3 = glm::cos(-t3);
    T s1 = 0;
    T s2 = 0;
    T s3 = 0;
    mat<4, 4, T, defaultp> Result;
    Result[0][0] = 0;
    Result[0][1] = 0;
    Result[0][2] = 0;
    Result[0][3] = static_cast<T>(0);
    Result[1][0] = c2 * s3;
    Result[1][1] = c1 * c3 + s1 * s2 * s3;
    Result[1][2] = -s1 * c3 + c1 * s2 * s3;
    Result[1][3] = static_cast<T>(0);
    Result[2][0] = -s2;
    Result[2][1] = s1 * c2;
    Result[2][2] = c1 * c2;
    Result[2][3] = static_cast<T>(0);
    Result[3][0] = static_cast<T>(0);
    Result[3][1] = static_cast<T>(0);
    Result[3][2] = static_cast<T>(0);
    Result[3][3] = static_cast<T>(1);
    return Result;
}
template <typename T, qualifier Q>
inline mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) {
    return rotate(mat<4, 4, T, Q>(static_cast<T>(1)), angle, v);
}
}  // namespace glm
using float3 = glm::vec3;
using float4x4 = glm::mat4x4;
float4x4 rotate(int order, float y, float z) {
    float4x4 xm = glm::rotate(0.0f, float3(1, 0, 0));
    float4x4 ym = glm::rotate(y, float3(0, 1, 0));
    float4x4 zm = glm::rotate(z, float3(0, 0, 1));
    switch (order) {
        case 1:
            return xm * zm * ym;
        default:
            return ym * xm * zm;
    }
}
int main() {
    if (rotate(0, 0.0f, 0.0f) != glm::eulerAngleXYZ(0.0f, 0.0f, 0.0f)) {
        return 1;
    }
}