AuroraMiddleware/glm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored low level SIMD API, refract SIMD optimization

Browse Source
This commit is contained in:
Christophe Riccio 2016-05-29 20:29:16 +02:00
parent 25b3c9f821
commit 0722404fb6
8 changed files with 105 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
glm/detail/func_common_simd.inl
View File

@ -16,7 +16,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_abs(v.data);
result.data = glm_vec4_abs(v.data);
return result;
}
};
@ -27,7 +27,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v)
{
tvec4<int, P> result(uninitialize);
result.data = glm_i32v4_abs(v.data);
result.data = glm_ivec4_abs(v.data);
return result;
}
};
@ -38,7 +38,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_flr(v.data);
result.data = glm_vec4_floor(v.data);
return result;
}
};
@ -49,7 +49,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_ceil(v.data);
result.data = glm_vec4_ceil(v.data);
return result;
}
};
@ -60,7 +60,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_frc(v.data);
result.data = glm_vec4_fract(v.data);
return result;
}
};
@ -71,7 +71,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_rnd(v.data);
result.data = glm_vec4_round(v.data);
return result;
}
};
@ -82,7 +82,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_mod(x.data, y.data);
result.data = glm_vec4_mod(x.data, y.data);
return result;
}
};

2
glm/detail/func_exponential_simd.inl
View File

@ -25,7 +25,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, lowp> call(tvec4<float, lowp> const & v)
{
tvec4<float, lowp> result(uninitialize);
result.data = glm_f32v4_sqrt_lowp(v.data);
result.data = glm_vec4_sqrt_lowp(v.data);
return result;
}
};

19
glm/detail/func_geometric.inl
View File

@ -114,6 +114,17 @@ namespace detail
return I - N * dot(N, I) * static_cast<T>(2);
}
};
template <typename T, precision P, template <typename, precision> class vecType>
struct compute_refract
{
GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
{
T const dotValue(dot(N, I));
T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
}
};
}//namespace detail
// length
@ -215,10 +226,9 @@ namespace detail
// refract
template <typename genType>
GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType eta)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
genType const dotValue(dot(N, I));
genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
@ -228,10 +238,7 @@ namespace detail
GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
T const dotValue(dot(N, I));
T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
return detail::compute_refract<T, P, vecType>::call(I, N, eta);
}
}//namespace glm

30
glm/detail/func_geometric_simd.inl
View File

@ -13,7 +13,7 @@ namespace detail
{
GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & v)
{
return _mm_cvtss_f32(glm_f32v4_len(v.data));
return _mm_cvtss_f32(glm_vec4_length(v.data));
}
};
@ -22,7 +22,7 @@ namespace detail
{
GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1)
{
return _mm_cvtss_f32(glm_f32v4_dst(p0.data, p1.data));
return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
}
};
@ -31,7 +31,7 @@ namespace detail
{
GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const& x, tvec4<float, P> const& y)
{
return _mm_cvtss_f32(glm_f32v1_dot(x.data, y.data));
return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
}
};
@ -42,11 +42,10 @@ namespace detail
{
__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
__m128 const xpd0 = glm_f32v4_xpd(set0, set1);
__m128 const xpd0 = glm_vec4_cross(set0, set1);
tvec4<float, P> result(uninitialize);
result.data = xpd0;
return tvec3<float, P>(result);
}
};
@ -57,7 +56,7 @@ namespace detail
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_nrm(v.data);
result.data = glm_vec4_normalize(v.data);
return result;
}
};
@ -65,10 +64,10 @@ namespace detail
template <precision P>
struct compute_faceforward<float, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & N, tvec4<float, P> const & I, tvec4<float, P> const & Nref)
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_ffd(N.data. I.data, Nref.data);
result.data = glm_vec4_faceforward(N.data. I.data, Nref.data);
return result;
}
};
@ -76,10 +75,21 @@ namespace detail
template <precision P>
struct compute_reflect<float, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & I, tvec4<float, P> const & N)
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N)
{
tvec4<float, P> result(uninitialize);
result.data = glm_f32v4_rfe(I.data, N.data);
result.data = glm_vec4_reflect(I.data, N.data);
return result;
}
};
template <precision P>
struct compute_refract<float, P, tvec4>
{
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta)
{
tvec4<float, P> result(uninitialize);
result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
return result;
}
};

57
glm/simd/common.h
View File

@ -7,8 +7,10 @@
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
//mad
GLM_FUNC_QUALIFIER __m128 glm_f32v1_mad(__m128 a, __m128 b, __m128 c)
typedef __m128 glm_vec4;
typedef __m128i glm_ivec4;
GLM_FUNC_QUALIFIER __m128 glm_vec1_fma(__m128 a, __m128 b, __m128 c)
{
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
return _mm_fmadd_ss(a, b, c);
@ -17,8 +19,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v1_mad(__m128 a, __m128 b, __m128 c)
# endif
}
//mad
GLM_FUNC_QUALIFIER __m128 glm_f32v4_mad(__m128 a, __m128 b, __m128 c)
GLM_FUNC_QUALIFIER __m128 glm_vec4_fma(__m128 a, __m128 b, __m128 c)
{
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
return _mm_fmadd_ps(a, b, c);
@ -27,13 +28,12 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_mad(__m128 a, __m128 b, __m128 c)
# endif
}
//abs
GLM_FUNC_QUALIFIER __m128 glm_f32v4_abs(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_abs(__m128 x)
{
return _mm_and_ps(x, _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF)));
}
GLM_FUNC_QUALIFIER __m128i glm_i32v4_abs(__m128i x)
GLM_FUNC_QUALIFIER __m128i glm_ivec4_abs(__m128i x)
{
# if GLM_ARCH & GLM_ARCH_SSSE3_BIT
return _mm_sign_epi32(x, x);
@ -45,8 +45,7 @@ GLM_FUNC_QUALIFIER __m128i glm_i32v4_abs(__m128i x)
# endif
}
//sign
GLM_FUNC_QUALIFIER __m128 glm_f32v4_sgn(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_sign(__m128 x)
{
__m128 const zro0 = _mm_setzero_ps();
__m128 const cmp0 = _mm_cmplt_ps(x, zro0);
@ -57,8 +56,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_sgn(__m128 x)
return or0;
}
//round
GLM_FUNC_QUALIFIER __m128 glm_f32v4_rnd(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_round(__m128 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_round_ps(x, _MM_FROUND_TO_NEAREST_INT);
@ -72,13 +70,12 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_rnd(__m128 x)
# endif
}
//floor
GLM_FUNC_QUALIFIER __m128 glm_f32v4_flr(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_floor(__m128 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_floor_ps(x);
# else
__m128 const rnd0 = glm_f32v4_rnd(x);
__m128 const rnd0 = glm_vec4_round(x);
__m128 const cmp0 = _mm_cmplt_ps(x, rnd0);
__m128 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
__m128 const sub0 = _mm_sub_ps(rnd0, and0);
@ -87,14 +84,14 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_flr(__m128 x)
}
/* trunc TODO
GLM_FUNC_QUALIFIER __m128 glm_f32v4_trc(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_trunc(__m128 x)
{
return __m128();
}
*/
//roundEven
GLM_FUNC_QUALIFIER __m128 glm_f32v4_rde(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_roundEven(__m128 x)
{
__m128 const sgn0 = _mm_castsi128_ps(_mm_set1_epi32(0x80000000));
__m128 const and0 = _mm_and_ps(sgn0, x);
@ -104,12 +101,12 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_rde(__m128 x)
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_ceil(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_ceil(__m128 x)
{
# if GLM_ARCH & GLM_ARCH_SSE41_BIT
return _mm_ceil_ps(x);
# else
__m128 const rnd0 = glm_f32v4_rnd(x);
__m128 const rnd0 = glm_vec4_round(x);
__m128 const cmp0 = _mm_cmpgt_ps(x, rnd0);
__m128 const and0 = _mm_and_ps(cmp0, _mm_set1_ps(1.0f));
__m128 const add0 = _mm_add_ps(rnd0, and0);
@ -117,51 +114,51 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_ceil(__m128 x)
# endif
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_frc(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_fract(__m128 x)
{
__m128 const flr0 = glm_f32v4_flr(x);
__m128 const flr0 = glm_vec4_floor(x);
__m128 const sub0 = _mm_sub_ps(x, flr0);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_mod(__m128 x, __m128 y)
GLM_FUNC_QUALIFIER __m128 glm_vec4_mod(__m128 x, __m128 y)
{
__m128 const div0 = _mm_div_ps(x, y);
__m128 const flr0 = glm_f32v4_flr(div0);
__m128 const flr0 = glm_vec4_floor(div0);
__m128 const mul0 = _mm_mul_ps(y, flr0);
__m128 const sub0 = _mm_sub_ps(x, mul0);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_clp(__m128 v, __m128 minVal, __m128 maxVal)
GLM_FUNC_QUALIFIER __m128 glm_vec4_clamp(__m128 v, __m128 minVal, __m128 maxVal)
{
__m128 const min0 = _mm_min_ps(v, maxVal);
__m128 const max0 = _mm_max_ps(min0, minVal);
return max0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_mix(__m128 v1, __m128 v2, __m128 a)
GLM_FUNC_QUALIFIER __m128 glm_vec4_mix(__m128 v1, __m128 v2, __m128 a)
{
__m128 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), a);
__m128 const mul0 = _mm_mul_ps(v1, sub0);
__m128 const mad0 = glm_f32v4_mad(v2, a, mul0);
__m128 const mad0 = glm_vec4_fma(v2, a, mul0);
return mad0;
}
//step
GLM_FUNC_QUALIFIER __m128 glm_f32v4_stp(__m128 edge, __m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_step(__m128 edge, __m128 x)
{
__m128 const cmp = _mm_cmple_ps(x, edge);
return _mm_movemask_ps(cmp) == 0 ? _mm_set1_ps(1.0f) : _mm_setzero_ps();
}
// smoothstep
GLM_FUNC_QUALIFIER __m128 glm_f32v4_ssp(__m128 edge0, __m128 edge1, __m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_smoothstep(__m128 edge0, __m128 edge1, __m128 x)
{
__m128 const sub0 = _mm_sub_ps(x, edge0);
__m128 const sub1 = _mm_sub_ps(edge1, edge0);
__m128 const div0 = _mm_sub_ps(sub0, sub1);
__m128 const clp0 = glm_f32v4_clp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f));
__m128 const clp0 = glm_vec4_clamp(div0, _mm_setzero_ps(), _mm_set1_ps(1.0f));
__m128 const mul0 = _mm_mul_ps(_mm_set1_ps(2.0f), clp0);
__m128 const sub2 = _mm_sub_ps(_mm_set1_ps(3.0f), mul0);
__m128 const mul1 = _mm_mul_ps(clp0, clp0);
@ -170,7 +167,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_ssp(__m128 edge0, __m128 edge1, __m128 x)
}
// Agner Fog method
GLM_FUNC_QUALIFIER __m128 glm_f32v4_nan(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_nan(__m128 x)
{
__m128i const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer
__m128i const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit
@ -184,7 +181,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_nan(__m128 x)
}
// Agner Fog method
GLM_FUNC_QUALIFIER __m128 glm_f32v4_inf(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_inf(__m128 x)
{
__m128i const t1 = _mm_castps_si128(x); // reinterpret as 32-bit integer
__m128i const t2 = _mm_sll_epi32(t1, _mm_cvtsi32_si128(1)); // shift out sign bit

8
glm/simd/exponential.h
View File

@ -5,16 +5,12 @@
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
// By Elan Ruskin, http://assemblyrequired.crashworks.org/
GLM_FUNC_QUALIFIER __m128 glm_f32v1_sqrt_lowp(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec1_sqrt_lowp(__m128 x)
{
return _mm_mul_ss(_mm_rsqrt_ss(x), x);
}
// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
// By Elan Ruskin, http://assemblyrequired.crashworks.org/
GLM_FUNC_QUALIFIER __m128 glm_f32v4_sqrt_lowp(__m128 x)
GLM_FUNC_QUALIFIER __m128 glm_vec4_sqrt_lowp(__m128 x)
{
return _mm_mul_ps(_mm_rsqrt_ps(x), x);
}

57
glm/simd/geometric.h
View File

@ -7,7 +7,24 @@
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
GLM_FUNC_QUALIFIER __m128 glm_f32v4_dot(__m128 v1, __m128 v2)
GLM_FUNC_DECL __m128 glm_vec4_dot(__m128 v1, __m128 v2);
GLM_FUNC_DECL __m128 glm_vec1_dot(__m128 v1, __m128 v2);
GLM_FUNC_QUALIFIER __m128 glm_vec4_length(__m128 x)
{
__m128 const dot0 = glm_vec4_dot(x, x);
__m128 const sqt0 = _mm_sqrt_ps(dot0);
return sqt0;
}
GLM_FUNC_QUALIFIER __m128 glm_vec4_distance(__m128 p0, __m128 p1)
{
__m128 const sub0 = _mm_sub_ps(p0, p1);
__m128 const len0 = glm_vec4_length(sub0);
return len0;
}
GLM_FUNC_QUALIFIER __m128 glm_vec4_dot(__m128 v1, __m128 v2)
{
# if GLM_ARCH & GLM_ARCH_AVX_BIT
return _mm_dp_ps(v1, v2, 0xff);
@ -26,7 +43,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_dot(__m128 v1, __m128 v2)
# endif
}
GLM_FUNC_QUALIFIER __m128 glm_f32v1_dot(__m128 v1, __m128 v2)
GLM_FUNC_QUALIFIER __m128 glm_vec1_dot(__m128 v1, __m128 v2)
{
# if GLM_ARCH & GLM_ARCH_AVX_BIT
return _mm_dp_ps(v1, v2, 0xff);
@ -45,21 +62,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v1_dot(__m128 v1, __m128 v2)
# endif
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_len(__m128 x)
{
__m128 const dot0 = glm_f32v4_dot(x, x);
__m128 const sqt0 = _mm_sqrt_ps(dot0);
return sqt0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_dst(__m128 p0, __m128 p1)
{
__m128 const sub0 = _mm_sub_ps(p0, p1);
__m128 const len0 = glm_f32v4_len(sub0);
return len0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_xpd(__m128 v1, __m128 v2)
GLM_FUNC_QUALIFIER __m128 glm_vec4_cross(__m128 v1, __m128 v2)
{
__m128 const swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
__m128 const swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
@ -71,35 +74,35 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_xpd(__m128 v1, __m128 v2)
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_nrm(__m128 v)
GLM_FUNC_QUALIFIER __m128 glm_vec4_normalize(__m128 v)
{
__m128 const dot0 = glm_f32v4_dot(v, v);
__m128 const dot0 = glm_vec4_dot(v, v);
__m128 const isr0 = _mm_rsqrt_ps(dot0);
__m128 const mul0 = _mm_mul_ps(v, isr0);
return mul0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_ffd(__m128 N, __m128 I, __m128 Nref)
GLM_FUNC_QUALIFIER __m128 glm_vec4_faceforward(__m128 N, __m128 I, __m128 Nref)
{
__m128 const dot0 = glm_f32v4_dot(Nref, I);
__m128 const sgn0 = glm_f32v4_sgn(dot0);
__m128 const dot0 = glm_vec4_dot(Nref, I);
__m128 const sgn0 = glm_vec4_sign(dot0);
__m128 const mul0 = _mm_mul_ps(sgn0, _mm_set1_ps(-1.0f));
__m128 const mul1 = _mm_mul_ps(N, mul0);
return mul1;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_rfe(__m128 I, __m128 N)
GLM_FUNC_QUALIFIER __m128 glm_vec4_reflect(__m128 I, __m128 N)
{
__m128 const dot0 = glm_f32v4_dot(N, I);
__m128 const dot0 = glm_vec4_dot(N, I);
__m128 const mul0 = _mm_mul_ps(N, dot0);
__m128 const mul1 = _mm_mul_ps(mul0, _mm_set1_ps(2.0f));
__m128 const sub0 = _mm_sub_ps(I, mul1);
return sub0;
}
GLM_FUNC_QUALIFIER __m128 glm_f32v4_rfa(__m128 I, __m128 N, __m128 eta)
GLM_FUNC_QUALIFIER __m128 glm_vec4_refract(__m128 I, __m128 N, __m128 eta)
{
__m128 const dot0 = glm_f32v4_dot(N, I);
__m128 const dot0 = glm_vec4_dot(N, I);
__m128 const mul0 = _mm_mul_ps(eta, eta);
__m128 const mul1 = _mm_mul_ps(dot0, dot0);
__m128 const sub0 = _mm_sub_ps(_mm_set1_ps(1.0f), mul0);
@ -110,7 +113,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32v4_rfa(__m128 I, __m128 N, __m128 eta)
return _mm_set1_ps(0.0f);
__m128 const sqt0 = _mm_sqrt_ps(mul2);
__m128 const mad0 = glm_f32v4_mad(eta, dot0, sqt0);
__m128 const mad0 = glm_vec4_fma(eta, dot0, sqt0);
__m128 const mul4 = _mm_mul_ps(mad0, N);
__m128 const mul5 = _mm_mul_ps(eta, I);
__m128 const sub2 = _mm_sub_ps(mul5, mul4);

10
glm/simd/matrix.h
View File

@ -380,7 +380,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32m4_det_highp(__m128 const in[4])
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_f32v4_dot(in[0], Row2);
__m128 Det0 = glm_vec4_dot(in[0], Row2);
return Det0;
}
@ -444,7 +444,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32m4_detd(__m128 const m[4])
// + m[0][2] * DetCof[2]
// + m[0][3] * DetCof[3];
return glm_f32v4_dot(m[0], DetCof);
return glm_vec4_dot(m[0], DetCof);
}
GLM_FUNC_QUALIFIER __m128 glm_f32m4_det(__m128 const m[4])
@ -507,7 +507,7 @@ GLM_FUNC_QUALIFIER __m128 glm_f32m4_det(__m128 const m[4])
// + m[0][2] * DetCof[2]
// + m[0][3] * DetCof[3];
return glm_f32v4_dot(m[0], DetCof);
return glm_vec4_dot(m[0], DetCof);
}
GLM_FUNC_QUALIFIER void glm_f32m4_inv(__m128 const in[4], __m128 out[4])
@ -720,7 +720,7 @@ GLM_FUNC_QUALIFIER void glm_f32m4_inv(__m128 const in[4], __m128 out[4])
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_f32v4_dot(in[0], Row2);
__m128 Det0 = glm_vec4_dot(in[0], Row2);
__m128 Rcp0 = _mm_div_ps(_mm_set1_ps(1.0f), Det0);
//__m128 Rcp0 = _mm_rcp_ps(Det0);
@ -941,7 +941,7 @@ GLM_FUNC_QUALIFIER void glm_f32m4_inv_lowp(__m128 const in[4], __m128 out[4])
// + m[0][1] * Inverse[1][0]
// + m[0][2] * Inverse[2][0]
// + m[0][3] * Inverse[3][0];
__m128 Det0 = glm_f32v4_dot(in[0], Row2);
__m128 Det0 = glm_vec4_dot(in[0], Row2);
__m128 Rcp0 = _mm_rcp_ps(Det0);
//__m128 Rcp0 = _mm_div_ps(one, Det0);
// Inverse /= Determinant;