mirror of
https://github.com/zhenyan121/Cubed.git
synced 2026-08-08 17:57:02 +08:00
feature: hud (#37)
* build: replace FetchContent with direct includes for glm * build(deps): replace SOIL2 with stb for image and vorbis decoding * build: replace FetchContent with direct includes for toml++ * refactor(texture): bump block texture size to 512 and disable items tab * feat: add hotbar system with ItemStack and RowLayout * fix(ui): restrict Ctrl key handling to typing mode * feat(ui): add widget border support and highlight selected hotbar slot * fix(ui): update borders on scale change and correct Image width - Added update_border() calls in set_scale() for Button, ChatBox, Image, Label, and TextField. - Fixed Image::width() to multiply by width instead of height. - Added early return in Widget::update_border() if border is not supported. * feat(ui): add border visual feedback on slider drag * feat(ui): add ItemSlot widget and refactor hotbar to use it * feat(world_scene): add inventory UI and pause type enum * feat(ui): add item slot tooltip and make window size static * fix(ui label): account for background offset in width/height * refactor(ui): centralize item info label in inventory and add update * feat(ui): add hotbar interaction in inventory UI * fix(inventory-ui): correct row creation logic for first item The loop starting at index 0 created a new row on the first iteration (i % 10 == 0). Shift the loop to start at 1 and adjust modulus condition to create rows correctly every 10 items. * feat(block): add name_key for localized block names Add `name_key` field to all block TOML definitions, enabling per-block localization. Update `BlockData` struct and `BlockManager` with `local_name()` method that returns a localized string via the translation system. Add corresponding entries to `en_US.json` and `zh_CN.json`. Modify inventory UI to use the localized name when displaying block info, and fix a bug where emptying a hotbar slot did not clear the item locally. * fix(ui): change inventory item slot color from white to gray * fix(ui): add missing include for std::array
This commit is contained in:
zhenyan121
615
include/glm/detail/func_common_simd.inl
Normal file
615
include/glm/detail/func_common_simd.inl
Normal file
@@ -0,0 +1,615 @@
|
||||
/// @ref core
|
||||
/// @file glm/detail/func_common_simd.inl
|
||||
|
||||
#if GLM_ARCH & GLM_ARCH_SSE2_BIT
|
||||
|
||||
#include "../simd/common.h"
|
||||
|
||||
#include <immintrin.h>
|
||||
|
||||
namespace glm{
|
||||
namespace detail
|
||||
{
|
||||
template<qualifier Q>
|
||||
struct compute_abs_vector<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_abs(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_abs_vector<4, int, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
|
||||
{
|
||||
vec<4, int, Q> result;
|
||||
result.data = glm_ivec4_abs(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_floor<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_floor(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_ceil<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_ceil(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_fract<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_fract(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_round<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_round(v.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_mod<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = glm_vec4_mod(x.data, y.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_min_vector<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = _mm_min_ps(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_min_vector<4, int, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
|
||||
{
|
||||
vec<4, int, Q> result;
|
||||
result.data = _mm_min_epi32(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_min_vector<4, uint, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
|
||||
{
|
||||
vec<4, uint, Q> result;
|
||||
result.data = _mm_min_epu32(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_max_vector<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = _mm_max_ps(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_max_vector<4, int, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v1, vec<4, int, Q> const& v2)
|
||||
{
|
||||
vec<4, int, Q> result;
|
||||
result.data = _mm_max_epi32(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_max_vector<4, uint, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& v1, vec<4, uint, Q> const& v2)
|
||||
{
|
||||
vec<4, uint, Q> result;
|
||||
result.data = _mm_max_epu32(v1.data, v2.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_clamp_vector<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal)
|
||||
{
|
||||
vec<4, float, Q> result;
|
||||
result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_clamp_vector<4, int, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& x, vec<4, int, Q> const& minVal, vec<4, int, Q> const& maxVal)
|
||||
{
|
||||
vec<4, int, Q> result;
|
||||
result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_clamp_vector<4, uint, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, uint, Q> call(vec<4, uint, Q> const& x, vec<4, uint, Q> const& minVal, vec<4, uint, Q> const& maxVal)
|
||||
{
|
||||
vec<4, uint, Q> result;
|
||||
result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_mix_vector<4, float, bool, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a)
|
||||
{
|
||||
__m128i const Load = _mm_set_epi32(-static_cast<int>(a.w), -static_cast<int>(a.z), -static_cast<int>(a.y), -static_cast<int>(a.x));
|
||||
__m128 const Mask = _mm_castsi128_ps(Load);
|
||||
|
||||
vec<4, float, Q> Result;
|
||||
# if 0 && GLM_ARCH & GLM_ARCH_AVX
|
||||
Result.data = _mm_blendv_ps(x.data, y.data, Mask);
|
||||
# else
|
||||
Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
|
||||
# endif
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
/* FIXME
|
||||
template<qualifier Q>
|
||||
struct compute_step_vector<float, Q, tvec4>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x)
|
||||
{
|
||||
vec<4, float, Q> Result;
|
||||
result.data = glm_vec4_step(edge.data, x.data);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
*/
|
||||
template<qualifier Q>
|
||||
struct compute_smoothstep_vector<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x)
|
||||
{
|
||||
vec<4, float, Q> Result;
|
||||
Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_fma<4, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& a, vec<4, float, Q> const& b, vec<4, float, Q> const& c)
|
||||
{
|
||||
vec<4, float, Q> Result;
|
||||
Result.data = glm_vec4_fma(a.data, b.data, c.data);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_fma<3, float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b, vec<3, float, Q> const& c)
|
||||
{
|
||||
vec<3, float, Q> Result;
|
||||
Result.data = glm_vec4_fma(a.data, b.data, c.data);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_fma<4, double, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<4, double, Q> const& a, vec<4, double, Q> const& b, vec<4, double, Q> const& c)
|
||||
{
|
||||
vec<4, double, Q> Result;
|
||||
# if (GLM_ARCH & GLM_ARCH_AVX2_BIT) && !(GLM_COMPILER & GLM_COMPILER_CLANG)
|
||||
Result.data = _mm256_fmadd_pd(a.data, b.data, c.data);
|
||||
# elif (GLM_ARCH & GLM_ARCH_AVX_BIT)
|
||||
Result.data = _mm256_add_pd(_mm256_mul_pd(a.data, b.data), c.data);
|
||||
# else
|
||||
Result.data.setv(0, _mm_add_pd(_mm_mul_pd(a.data.getv(0), b.data.getv(0)), c.data.getv(0)));
|
||||
Result.data.setv(1, _mm_add_pd(_mm_mul_pd(a.data.getv(1), b.data.getv(1)), c.data.getv(1)));
|
||||
# endif
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to 0
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4W0<float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<3, float, Q> const& a)
|
||||
{
|
||||
vec<4, float, Q> v;
|
||||
#if (GLM_ARCH & GLM_ARCH_SSE41_BIT)
|
||||
v.data = _mm_blend_ps(a.data, _mm_setzero_ps(), 8);
|
||||
#else
|
||||
__m128i mask = _mm_set_epi32(0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
|
||||
__m128 v0 = _mm_castsi128_ps(_mm_and_si128(_mm_castps_si128(a.data), mask));
|
||||
v.data = v0;
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to 1
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4W1<float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<3, float, Q> const& a)
|
||||
{
|
||||
vec<4, float, Q> v;
|
||||
#if (GLM_ARCH & GLM_ARCH_SSE41_BIT)
|
||||
v.data = _mm_blend_ps(a.data, _mm_set1_ps(1.0f), 8);
|
||||
#else
|
||||
__m128 t1 = _mm_shuffle_ps(a.data, a.data, _MM_SHUFFLE(0, 2, 1, 3)); //permute x, w
|
||||
__m128 t2 = _mm_move_ss(t1, _mm_set_ss(1.0f)); // set x to 1.0f
|
||||
v.data = _mm_shuffle_ps(t2, t2, _MM_SHUFFLE(0, 2, 1, 3)); //permute x, w
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to vec3.z
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4WZ<float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<3, float, Q> const& a)
|
||||
{
|
||||
vec<4, float, Q> v;
|
||||
v.data = _mm_shuffle_ps(a.data, a.data, _MM_SHUFFLE(2, 2, 1, 0));
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to 0
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4W0<double, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<3, double, Q> const& a)
|
||||
{
|
||||
vec<4, double, Q> v;
|
||||
#if (GLM_ARCH & GLM_ARCH_AVX_BIT)
|
||||
v.data = _mm256_blend_pd(a.data, _mm256_setzero_pd(), 8);
|
||||
#else
|
||||
v.data.setv(0, a.data.getv(0));
|
||||
glm_dvec2 av2 = a.data.getv(1);
|
||||
av2 = _mm_shuffle_pd(av2, _mm_setzero_pd(), 2);
|
||||
v.data.setv(1, av2);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to vec3.z
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4WZ<double, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<3, double, Q> const& a)
|
||||
{
|
||||
vec<4, double, Q> v;
|
||||
#if (GLM_ARCH & GLM_ARCH_AVX_BIT)
|
||||
v.data = _mm256_permute_pd(a.data, 2);
|
||||
#else
|
||||
v.data.setv(0, a.data.getv(0));
|
||||
glm_dvec2 av2 = a.data.getv(1);
|
||||
__m128d t1 = _mm_shuffle_pd(av2, av2, 0);
|
||||
v.data.setv(1, t1);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
// copy vec3 to vec4 and set w to 1
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4W1<double, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, double, Q> call(vec<3, double, Q> const& a)
|
||||
{
|
||||
vec<4, double, Q> v;
|
||||
#if (GLM_ARCH & GLM_ARCH_AVX_BIT)
|
||||
v.data = _mm256_blend_pd(a.data, _mm256_set1_pd(1.0), 8);
|
||||
#else
|
||||
v.data.setv(0, a.data.getv(0));
|
||||
glm_dvec2 av2 = a.data.getv(1);
|
||||
av2 = _mm_shuffle_pd(av2, _mm_set1_pd(1.), 2);
|
||||
v.data.setv(1, av2);
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct convert_vec4_to_vec3<float, Q, true> {
|
||||
GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<4, float, Q> const& a)
|
||||
{
|
||||
vec<3, float, Q> v;
|
||||
v.data = a.data;
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct convert_vec4_to_vec3<double, Q, true> {
|
||||
GLM_FUNC_QUALIFIER static vec<3, double, Q> call(vec<4, double, Q> const& a)
|
||||
{
|
||||
vec<3, double, Q> v;
|
||||
#if GLM_ARCH & GLM_ARCH_AVX_BIT
|
||||
v.data = a.data;
|
||||
#else
|
||||
v.data.setv(0, a.data.getv(0));
|
||||
v.data.setv(1, a.data.getv(1));
|
||||
#endif
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// set all coordinates to same value vec[c]
|
||||
template<length_t L, qualifier Q>
|
||||
struct convert_splat<L, float, Q, true> {
|
||||
template<int c>
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, float, Q> call(vec<L, float, Q> const& a)
|
||||
{
|
||||
vec<L, float, Q> Result;
|
||||
const int s = _MM_SHUFFLE(c, c, c, c);
|
||||
glm_f32vec4 va = static_cast<glm_f32vec4>(a.data);
|
||||
# if GLM_ARCH & GLM_ARCH_AVX_BIT
|
||||
Result.data = _mm_permute_ps(va, s);
|
||||
# else
|
||||
Result.data = _mm_shuffle_ps(va, va, s);
|
||||
# endif
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
// set all coordinates to same value vec[c]
|
||||
template<length_t L, qualifier Q>
|
||||
struct convert_splat<L, double, Q, true> {
|
||||
|
||||
template<bool, int c>
|
||||
struct detailSSE
|
||||
{};
|
||||
|
||||
template<int c>
|
||||
struct detailSSE<true, c>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
glm_f64vec2 r0 = _mm_shuffle_pd(a.data.getv(0), a.data.getv(0), c | c << 1);
|
||||
Result.data.setv(0, r0);
|
||||
Result.data.setv(1, r0);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<int c>
|
||||
struct detailSSE<false, c>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
const unsigned int d = static_cast<unsigned int>(c - 2);
|
||||
glm_f64vec2 r0 = _mm_shuffle_pd(a.data.getv(1), a.data.getv(1), d | d << 1);
|
||||
Result.data.setv(0, r0);
|
||||
Result.data.setv(1, r0);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
#if GLM_ARCH & GLM_ARCH_AVX_BIT
|
||||
template<bool, int c> //note: bool is useless but needed to compil on linux (gcc)
|
||||
struct detailAVX
|
||||
{};
|
||||
|
||||
template<bool b>
|
||||
struct detailAVX<b, 0>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
__m256d t1 = _mm256_permute2f128_pd(a.data, a.data, 0x0);
|
||||
Result.data = _mm256_permute_pd(t1, 0);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<bool b>
|
||||
struct detailAVX<b, 1>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
__m256d t1 = _mm256_permute2f128_pd(a.data, a.data, 0x0);
|
||||
Result.data = _mm256_permute_pd(t1, 0xf);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<bool b>
|
||||
struct detailAVX<b, 2>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
__m256d t2 = _mm256_permute2f128_pd(a.data, a.data, 0x11);
|
||||
Result.data = _mm256_permute_pd(t2, 0x0);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
template<bool b>
|
||||
struct detailAVX<b, 3>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
vec<L, double, Q> Result;
|
||||
__m256d t2 = _mm256_permute2f128_pd(a.data, a.data, 0x11);
|
||||
Result.data = _mm256_permute_pd(t2, 0xf);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
#endif //GLM_ARCH & GLM_ARCH_AVX_BIT
|
||||
|
||||
template<int c>
|
||||
GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, double, Q> call(vec<L, double, Q> const& a)
|
||||
{
|
||||
//return compute_splat<L, double, Q, false>::call<c>(a);
|
||||
vec<L, double, Q> Result;
|
||||
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
|
||||
Result.data = _mm256_permute4x64_pd(a.data, _MM_SHUFFLE(c, c, c, c));
|
||||
# elif GLM_ARCH & GLM_ARCH_AVX_BIT
|
||||
Result = detailAVX<true, c>::call(a);
|
||||
# else
|
||||
#if 1 //detail<(c <= 1), c>::call2(a) is equivalent to following code but without if constexpr usage
|
||||
Result = detailSSE<(c <= 1), c>::call(a);
|
||||
#else
|
||||
if constexpr (c <= 1)
|
||||
{
|
||||
glm_f64vec2 r0 = _mm_shuffle_pd(a.data.getv(0), a.data.getv(0), c | c << 1);
|
||||
Result.data.setv(0, r0);
|
||||
Result.data.setv(1, r0);
|
||||
}
|
||||
else
|
||||
{
|
||||
const unsigned int d = (unsigned int)(c - 2);
|
||||
glm_f64vec2 r0 = _mm_shuffle_pd(a.data.getv(1), a.data.getv(1), d | d << 1);
|
||||
Result.data.setv(0, r0);
|
||||
Result.data.setv(1, r0);
|
||||
}
|
||||
#endif
|
||||
# endif
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}//namespace detail
|
||||
}//namespace glm
|
||||
|
||||
#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT
|
||||
|
||||
#if GLM_ARCH & GLM_ARCH_NEON_BIT
|
||||
namespace glm {
|
||||
namespace detail {
|
||||
template<qualifier Q>
|
||||
struct convert_vec3_to_vec4W0<float, Q, true>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<3, float, Q> const& a)
|
||||
{
|
||||
vec<4, float, Q> v;
|
||||
static const uint32x4_t mask = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0 };
|
||||
v.data = vbslq_f32(mask, a.data, vdupq_n_f32(0));
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct convert_vec4_to_vec3<float, Q, true> {
|
||||
GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<4, float, Q> const& a)
|
||||
{
|
||||
vec<3, float, Q> v;
|
||||
v.data = a.data;
|
||||
return v;
|
||||
}
|
||||
};
|
||||
|
||||
/* compute_splat is never called?
|
||||
template<length_t L, qualifier Q>
|
||||
struct compute_splat<L, float, Q, true> {
|
||||
template<int c>
|
||||
GLM_FUNC_QUALIFIER static vec<L, float, Q> call(vec<L, float, Q> const& a)
|
||||
{
|
||||
(void)a;
|
||||
}
|
||||
|
||||
template<>
|
||||
GLM_FUNC_QUALIFIER static vec<L, float, Q> call<0>(vec<L, float, Q> const& a)
|
||||
{
|
||||
vec<L, float, Q> Result;
|
||||
Result.data = vdupq_lane_f32(vget_low_f32(a.data), 0);
|
||||
return Result;
|
||||
}
|
||||
|
||||
template<>
|
||||
GLM_FUNC_QUALIFIER static vec<L, float, Q> call<1>(vec<L, float, Q> const& a)
|
||||
{
|
||||
vec<L, float, Q> Result;
|
||||
Result.data = vdupq_lane_f32(vget_low_f32(a.data), 1);
|
||||
return Result;
|
||||
}
|
||||
|
||||
template<>
|
||||
GLM_FUNC_QUALIFIER static vec<L, float, Q> call<2>(vec<L, float, Q> const& a)
|
||||
{
|
||||
vec<L, float, Q> Result;
|
||||
Result.data = vdupq_lane_f32(vget_high_f32(a.data), 0);
|
||||
return Result;
|
||||
}
|
||||
|
||||
template<>
|
||||
GLM_FUNC_QUALIFIER static vec<L, float, Q> call<3>(vec<L, float, Q> const& a)
|
||||
{
|
||||
vec<L, float, Q> Result;
|
||||
Result.data = vdupq_lane_f32(vget_high_f32(a.data), 1);
|
||||
return Result;
|
||||
}
|
||||
};
|
||||
*/
|
||||
}//namespace detail
|
||||
}//namespace glm
|
||||
#endif //GLM_ARCH & GLM_ARCH_NEON_BIT
|
||||
Reference in New Issue
Block a user